docs(task): split implementation audit out of post-split cleanup

- move implementation-audit notes into a separate task directory
- keep post-split-cleanup focused on SVC v9.3 docs adoption
- note that some audit mismatches may come from outdated docs or local guides

Author: xiaoland

tasks/core-py-business-pipeline-implementation-audit/50-implementation-audit-scope-boundary.md

@@ -0,0 +1,69 @@
+# Implementation Audit Scope Boundary
+
+## Purpose
+
+Record the implementation drifts discovered while checking `docs/30-unit-tdd/business-pipeline-and-authority.md` and related local guides against code, in a task that is explicitly separate from `core-py-post-split-cleanup`.
+
+## Decision
+
+This task is a separate follow-up.
+
+`core-py-post-split-cleanup` remains a SVC v9.3 adoption task about shared baseline consumption, Unit TDD admission, and local `AGENTS.md` strengthening.
+
+Any code changes or implementation verification work should happen here instead of being folded back into that post-split cleanup task.
+
+## Important Caution
+
+Not every issue found during the audit should be assumed to be a code bug. Some apparent mismatches may come from outdated docs, stale local guides, or legacy notes that no longer describe the current implementation correctly.
+
+So every follow-up item below must be re-verified before code changes are made. The decision shape should be:
+
+- code is wrong and should change, or
+- docs / local guides are outdated and should change, or
+- both drifted and need to be realigned together
+
+## Why
+
+The drifts found during implementation review are real signals, but they are not automatically durable-doc placement work.
+
+Under SVC v9.3, code bugs and legacy implementation seams should not be "fixed" by rewriting durable docs to mirror the bug. They should either:
+
+- be corrected in code and tests in a separate execution task, or
+- be reclassified as documentation drift if the code is actually the more current source of truth
+
+## Audit Leads
+
+### 1. Embedding upsert call shape
+
+- `app/business/info_base/block.py` currently calls `EmbeddingManager.upsert_block_embedding(...)` with positional arguments that appear not to match the current signature in `app/business/sink/embedding.py`.
+- This may be a real implementation bug, or a sign that the documented/assumed call contract needs re-verification.
+
+### 2. Extension running-state checks
+
+- `app/business/extension/main.py` checks `RUNNING_EXTENSIONS` using the extension class object, while the registry is keyed by extension ID.
+- This looks like a runtime lifecycle bug, but should still be re-verified against the intended registry contract before changing code.
+
+### 3. Legacy resolver/storage API remnants
+
+- several built-in resolvers still look shaped for older storage APIs or incomplete resolver contracts
+- this includes missing/legacy methods in built-in resolver files and stale references to storage helpers that no longer match the current storage manager shape
+- part of this may be code drift, part of it may be local guide / note drift
+
+### 4. Source scheduling remains undecided
+
+- the current dual-path source scheduling situation was reconfirmed
+- but the scheduling cleanup decision remains a separate design/execution question and should not be silently collapsed into this audit
+
+## Explicit Non-Actions
+
+- do not change `docs/30-unit-tdd/` to normalize temporary broken behavior into durable architecture
+- do not rewrite local `AGENTS.md` to preserve a bug as if it were stable truth
+- do not assume every mismatch is a code bug before re-checking whether the docs are outdated
+
+## Follow-Up Shape
+
+If this work proceeds later, split it into separate execution slices such as:
+
+1. code/task for embedding and extension lifecycle correctness
+2. code/task for resolver/storage legacy cleanup
+3. separate decision task for source scheduling convergence

tasks/core-py-business-pipeline-implementation-audit/STATUS.md

@@ -0,0 +1,41 @@
+# Status
+
+## Purpose
+
+This directory holds the implementation-audit follow-up that was split out of `tasks/core-py-post-split-cleanup/`.
+
+## Current State
+
+Status: `not started; audit notes separated from post-split cleanup scope`
+
+## Why It Was Split Out
+
+`core-py-post-split-cleanup` is about applying SVC v9.3 to `core-py` through:
+
+- shared baseline consumption
+- Unit TDD admission
+- local `AGENTS.md` strengthening
+- routing / setup doc cleanup
+
+Implementation drift work would make that task boundary muddy, so it now lives here.
+
+## Important Caution
+
+Some issues noticed during the audit may be true code bugs, but some may only be symptoms of outdated docs or stale local guides. Re-verify each item before changing code.
+
+## Read Order
+
+1. `tasks/core-py-business-pipeline-implementation-audit/STATUS.md`
+2. `tasks/core-py-business-pipeline-implementation-audit/50-implementation-audit-scope-boundary.md`
+3. `docs/30-unit-tdd/business-pipeline-and-authority.md`
+4. relevant local guides under `app/business/**/AGENTS.md`
+5. target implementation files in `app/business/**`
+
+## Scope Reminder
+
+This task is the correct place for any future execution work around:
+
+- embedding upsert correctness
+- extension running-state bookkeeping
+- resolver/storage legacy drift
+- re-verification of whether mismatches are code drift or doc drift

tasks/core-py-post-split-cleanup/50-implementation-audit-scope-boundary.md

@@ -45,11 +45,15 @@ Admitted structure:
 
 Local `docs/00-meta/` was explicitly **not** admitted for `core-py` at this stage.
 
-### Implementation Audit Boundary
+### Implementation Follow-Up Split
 
-An implementation audit against business-pipeline docs found real code drifts, but they are explicitly left in `tasks/` and out of scope for this cleanup slice:
+Implementation audit work is no longer tracked inside this cleanup slice.
 
-- see `50-implementation-audit-scope-boundary.md`
+If implementation verification or code changes are needed later, use:
+
+- `tasks/core-py-business-pipeline-implementation-audit/`
+
+Some mismatches noticed during the audit may be code bugs, but some may also come from outdated docs or local guides, so that follow-up must re-verify both sides before changing code.
 
 ## What Was Explicitly Rejected
 
@@ -66,9 +70,8 @@ These remain tactical or unstable and should stay out of `docs/30-unit-tdd/` unl
 2. `tasks/core-py-post-split-cleanup/00-meta.md`
 3. `tasks/core-py-post-split-cleanup/30-phase-3-4-execution-output.md`
 4. `tasks/core-py-post-split-cleanup/40-phase-5-meta-gap-decision.md`
-5. `tasks/core-py-post-split-cleanup/50-implementation-audit-scope-boundary.md`
-6. `docs/30-unit-tdd/business-pipeline-and-authority.md`
-7. relevant local guides under `app/business/**/AGENTS.md`
+5. `docs/30-unit-tdd/business-pipeline-and-authority.md`
+6. relevant local guides under `app/business/**/AGENTS.md`
 
 ## Resume Conditions
 
@@ -84,6 +87,7 @@ Only reopen this task if one of these happens:
 These are not required to consider this task complete, but are the most plausible next work:
 
 - audit whether `app/business/AGENTS.md` should become thinner now that routing is stronger below it
+- use `tasks/core-py-business-pipeline-implementation-audit/` if implementation-vs-doc drift needs follow-up
 - revisit source scheduling only when the TODO in `app/business/source/main.py` is actually being resolved
 - revisit `docs/30-unit-tdd/` only if another slow-moving structural truth clearly survives locality