easy-coding-harness 0.10.0-beta.5 → 0.10.0-beta.6

package/CHANGELOG.md

@@ -6,6 +6,22 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 0.10.0-beta.6
+
+- Canonical Spec 首次路由新增 `inspect-dev-spec --manifest-only`：只通过 normalized remote
+  识别当前 worktree、展示任务目录和共享 execution 状态，不再为未选仓库解析本地路径或
+  为任何未选任务计算 baseline；`path_hint` 明确降级为提示信息。
+- 用户选定 task 后，`inspect-dev-spec --spec-task ...` 只检查所选任务所属仓库及其
+  change/test 范围；当前 worktree remote 唯一匹配时无需手工传 `--repo-path`，即使旧
+  `path_hint` 指向仍存在的原 checkout，也优先绑定当前 worktree。
+- `ec-workflow` 不再在路由阶段提前读取消费闭包；`ec-analysis` 负责唯一一次精确 selector
+  调用，并对 `exact` / `scope-unchanged` 使用快速投影，对 `scope-drifted` 只分析所选任务
+  的漂移文件和符号，派生 dev-spec 不再被解释为第二轮 Spec 创作。
+- 共享 `EDS:EXECUTION` 固化为依赖事实来源：已完成 hard task 或已满足依赖边直接放行；
+  禁止通过另一个本地 Harness task、Git 历史或 Agent 推断重复考古完成状态。
+- 保持项目外原始 Spec absolute locator、身份校验 rebind、共享 writer/CAS 及旧版全量
+  `inspect-dev-spec` 调用兼容；新增 worktree、未选仓库隔离和三平台安装产物回归测试。
+
 ## 0.10.0-beta.5
 
 - 兼容新版 `easy-dev-spec/v1` 共享执行区：同步设计/整文双摘要与 execution 投影协议，新增

package/README.md

@@ -101,15 +101,19 @@ any stage --[user abort via ec-task-close]--> CLOSED
 
 Harness 可选择性消费 easy-dev-spec 生成的单文件 `easy-dev-spec/v1` Canonical Spec：
 
-1. `ec-workflow` 先只读检查 manifest、仓库、任务 DAG、依赖、baseline 与共享 execution；
-   旧 Spec 仍可只读检查，但成为可执行任务前必须初始化共享执行区。
-2. 用户明确选择一个或多个 Spec task；`select-dev-spec-scope` 按仓库提取确定性消费
-   闭包，Harness 不默认导入整份 Spec，也不会读取未选任务正文。
-3. 一次选择创建一个 Harness task；ANALYSIS 使用最终 producer READY 门禁，并将
-   selected task 映射为带 `repo_id`、`source_task_id`、source steps、文件、符号和测试
-   命令的 Unit。
-4. `hard` 依赖决定执行顺序，冻结的 `contract` 依赖允许并行编码，`integration` 依赖
-   在证据闭合前阻止全链路完成。
+1. `ec-workflow` 先用 `inspect-dev-spec --manifest-only` 只读校验 manifest，通过 normalized
+   remote 识别当前 worktree，并展示任务 DAG 与共享 execution；不会解析未选仓库路径，也
+   不在选择前计算任何任务的 baseline。旧 Spec 仍可只读检查，但成为可执行任务前必须
+   初始化共享执行区。
+2. 用户明确选择一个或多个 Spec task 后，Harness 用 `--spec-task` 只检查所选任务仓库和
+   change/test 范围。当前 worktree remote 唯一匹配时无需手工路径；`path_hint` 不一致只会
+   形成一次运行时映射提示，不会复制或修复原 Spec。
+3. 一次选择创建一个 Harness task；ANALYSIS 唯一一次调用 `select-dev-spec-scope` 提取确定性
+   消费闭包。`exact` / `scope-unchanged` 直接快速投影为 Unit、测试策略和派生 dev-spec，
+   `scope-drifted` 才读取所选范围内的漂移文件与符号；未选任务正文始终不进入上下文。
+4. `EDS:EXECUTION` 是依赖事实来源：`hard` 依赖决定执行顺序，冻结的 `contract` 依赖允许
+   并行编码，`integration` 依赖在证据闭合前阻止全链路完成；不会再从本地任务或 Git 历史
+   重复推断共享状态。
 
 Canonical Spec 的静态设计由 design revision + `design_sha256` 冻结；共享
 `EDS:EXECUTION` 则接收 Harness 的 Task/Step/dependency 投影。写回使用

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easy-coding-harness",
-  "version": "0.10.0-beta.5",
+  "version": "0.10.0-beta.6",
   "description": "CLI scaffold for installing Easy Coding harness files into agent-native directories.",
   "repository": {
     "type": "git",

package/templates/common/skills/ec-analysis/SKILL.md

@@ -21,15 +21,18 @@ Communicate with the user in the user's language.
 4. Inspect concrete code paths and tests. Expand context only when evidence reveals another
    dependency or risk.
 
-For a task with `task.json.spec_source`, re-run `inspect-dev-spec` against the stored source and
-every stored `task.repo_paths` repository binding. Schema, Spec ID, design revision, and
-`design_sha256` must still match. A changed `document_sha256` with the same design is normal
-shared progress; refresh `execution_revision` without invalidating plan/review/verify evidence.
-An execution revision rollback is blocking. Then call the selector for the exact selection:
+For a task with `task.json.spec_source`, re-run `inspect-dev-spec` against the stored source, exact
+`selected_spec_tasks`, and only their stored `task.repo_paths` bindings. Schema, Spec ID, design
+revision, and `design_sha256` must still match. A changed `document_sha256` with the same design is
+normal shared progress; refresh `execution_revision` without invalidating plan/review/verify
+evidence. An execution revision rollback is blocking. Then call the selector once for the exact
+selection:
 
 ```bash
 {{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py inspect-dev-spec \
-  --spec <stored-source> --repo-path <repo-id>=<stored-path> [--repo-path <repo-id>=<stored-path>]...
+  --spec <stored-source> \
+  --spec-task <selected-task-id> [--spec-task <selected-task-id>]... \
+  [--repo-path <repo-id>=<stored-path>]...
 
 {{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py select-dev-spec-scope \
   --spec <stored-source> --spec-task <selected-task-id> [--spec-task <selected-task-id>]...
@@ -38,8 +41,20 @@ An execution revision rollback is blocking. Then call the selector for the exact
 Load only the returned per-repository consumption closures: manifest/global context, selected
 task and repository sections, related contracts, direct dependency summaries, selected
 changes/steps/tests, and relevant integration rows. Never replace the selector with a whole-file
-read. `scope-drifted` requires current-code conflict analysis before confirmation;
-`baseline-unavailable` or unresolved repository identity remains blocked in ANALYSIS.
+read. Treat the Canonical closure as frozen design, not as a prompt to design the task again:
+
+- `exact` and `scope-unchanged` use the fast projection path. Confirm the selected paths, symbols,
+  and test entry points, then map the closure into Units, `test-strategy.md`, and the derived
+  `dev-spec.md` in one pass. Do not reselect interfaces, fields, task boundaries, Steps, or Tests,
+  and do not ask questions already answered by the source Spec.
+- `scope-drifted` reads and analyzes only changed files and symbols in the selected task scope.
+  Escalate to a static design revision only when that evidence changes a frozen contract or task
+  boundary; unrelated repository or completed-task changes are background, not current drift.
+- `baseline-unavailable` or unresolved selected-repository identity remains blocked in ANALYSIS.
+
+Use shared execution dependency status directly. Do not inspect another local Harness task or Git
+history to re-prove a completed hard dependency, and do not repeat dependency or baseline
+explanations after the selected inspection has recorded them.
 
 ## Analysis artifacts
 
@@ -107,6 +122,10 @@ digest, current document digest/execution revision/writeback status, selected ta
 and repositories, baseline/conflict result, Unit mapping, source test mapping, and pending
 integration edges.
 
+The required skeleton is a mechanical artifact schema. For a Canonical-backed task it is filled
+from the selected closure and current-code delta; it must never become a second round of Spec
+authoring.
+
 Every source test command remains mandatory. Additional commands from the current repository are
 allowed only when `test-strategy.md` records why the Canonical command alone is insufficient.
 For every selected source test, `test-strategy.md` must spell out its Test ID, source task ID,

package/templates/common/skills/ec-workflow/SKILL.md

@@ -61,36 +61,52 @@ plan decision; Auto continues immediately. Both remove later waiting, not qualit
    - Present with `status != "COMPLETE"`: invoke `{{skill_trigger}}ec-init`, then stop.
    - `[easy-coding:upgrade-init-pending:X]`: recommend `{{skill_trigger}}ec-init` for vX
      adaptation, but allow the user to continue; this reminder is not a workflow block.
-3. When the user explicitly references a Dev-Spec, run the read-only `inspect-dev-spec` command
-   before ordinary task creation. For `protocol=canonical-v1`, show every task ID, repository,
-   title, dependency, and baseline status; never select all tasks by default. After the user
-   chooses one or more tasks and resolves repository paths or omitted hard-dependency evidence,
-   call `create-task-from-spec` once for the complete selection. A document without a Canonical
-   manifest remains a legacy ANALYSIS input for an ordinary task. A malformed, DRAFT, or otherwise
-   non-READY Canonical Spec stays blocked and must never be downgraded to the legacy route. A
-   READY Canonical Spec without shared execution remains readable, but run
-   `initialize-spec-execution` before selection can become an executable Harness task.
+3. When the user explicitly references a Dev-Spec, first run read-only `inspect-dev-spec
+   --manifest-only`. This routing pass validates the document, identifies the current worktree by
+   normalized remote, and returns the task catalog without resolving unrelated repositories. For
+   `protocol=canonical-v1`, show every task ID, repository, title, static status, actual execution
+   status, and dependency; never select all tasks by default and never calculate baseline drift
+   before selection.
+
+   After the user chooses one or more tasks, run one selected inspection with repeated
+   `--spec-task`. Resolve paths only for repositories that own selected tasks. The current
+   worktree needs no explicit mapping when its normalized remote matches uniquely; pass
+   `--repo-path` only for an additional selected repository or to confirm an ambiguous current
+   match. A differing `path_hint` is a one-time runtime mapping notice, not a Spec portability
+   failure: never copy, mirror, or rewrite the source Spec because of it.
+
+   Then call `create-task-from-spec` once for the complete selection. Do not call
+   `select-dev-spec-scope` during routing; `ec-analysis` owns the single consumption-closure read
+   after task creation. A document without a Canonical manifest remains a legacy ANALYSIS input
+   for an ordinary task. A malformed, DRAFT, or otherwise non-READY Canonical Spec stays blocked
+   and must never be downgraded to the legacy route. A READY Canonical Spec without shared
+   execution remains readable, but run `initialize-spec-execution` before selection can become an
+   executable Harness task.
 
    ```bash
    {{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py inspect-dev-spec \
-     --spec <path> [--repo-path <repo-id>=<path>]...
+     --spec <path> --manifest-only
+
+   {{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py inspect-dev-spec \
+     --spec <path> --spec-task <task-id> [--spec-task <task-id>]... \
+     [--repo-path <repo-id>=<path>]...
 
    {{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py initialize-spec-execution \
      --spec <path>
 
-   {{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py select-dev-spec-scope \
-     --spec <path> --spec-task <task-id> [--spec-task <task-id>]...
-
    {{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py create-task-from-spec \
      --spec <path> --spec-task <task-id> [--spec-task <task-id>]... \
      --task-id <harness-task-id> --type <type> --title <title> \
-     --repo-path <repo-id>=<path> [--dependency-evidence <dependency-id>=<evidence>]... \
+     [--repo-path <repo-id>=<path>]... \
+     [--dependency-evidence <dependency-id>=<evidence>]... \
      --agent <agent-id> --session-file <P>
    ```
 
-   `select-dev-spec-scope` is read-only and may run only after explicit task selection. Its
-   per-repository payload is the authoritative ANALYSIS context; do not load unselected task
-   bodies from the source document.
+   Shared `EDS:EXECUTION` is the dependency fact source. Accept a completed hard dependency or a
+   satisfied edge directly from that snapshot. Only accept manual dependency evidence when the
+   shared edge is still pending and the user explicitly supplies independently verifiable
+   evidence; never reconstruct completion from another local Harness task, Git history, or an
+   agent's inference.
 
    When multiple selected tasks depend on the same target, disambiguate creation evidence with
    `<source-task-id>-><dependency-task-id>=<evidence>`.

package/templates/main-constraint/AGENTS.md.tpl

@@ -92,6 +92,11 @@ First run `ec-init`; daily work goes through `ec-workflow`.
   external explicit Spec paths are allowed and may be repaired only with identity-checked rebind.
   Runtime progress must use the shared writer with CAS/idempotency and reconciliation; static
   design changes require revision + READY + `sync-spec-design`. Never hand-edit `EDS:EXECUTION`.
+- Canonical routing is two-pass: first use manifest-only discovery for the current worktree, then
+  inspect only the explicitly selected task IDs and repositories. A remote-confirmed worktree
+  overrides a stale `path_hint`; never mirror the source Spec or re-check unselected repositories.
+  ANALYSIS reads the selected consumption closure once and treats exact/scope-unchanged as a fast
+  projection, while shared execution is the dependency fact source.
 - MEMORY combines short-memory creation and the conditional long-memory gate. Entry follows the
   effective confirmation mode; once memory processing completes, COMPLETE is automatic.
 - NO CODE-TASK COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE.

package/templates/main-constraint/CLAUDE.md.tpl

@@ -90,6 +90,11 @@ First run `/ec-init`; daily work goes through `/ec-workflow`.
   external explicit Spec paths are allowed and may be repaired only with identity-checked rebind.
   Runtime progress must use the shared writer with CAS/idempotency and reconciliation; static
   design changes require revision + READY + `sync-spec-design`. Never hand-edit `EDS:EXECUTION`.
+- Canonical routing is two-pass: first use manifest-only discovery for the current worktree, then
+  inspect only the explicitly selected task IDs and repositories. A remote-confirmed worktree
+  overrides a stale `path_hint`; never mirror the source Spec or re-check unselected repositories.
+  ANALYSIS reads the selected consumption closure once and treats exact/scope-unchanged as a fast
+  projection, while shared execution is the dependency fact source.
 - MEMORY combines short-memory creation and the conditional long-memory gate. Entry follows the
   effective confirmation mode; once memory processing completes, COMPLETE is automatic.
 - NO CODE-TASK COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE.

package/templates/shared-hooks/easy_coding_state.py

@@ -16,6 +16,7 @@ import sys
 
 from easy_dev_spec import (
     EasyDevSpecError,
+    inspect_manifest,
     inspect_spec,
     inspection_summary,
     select_consumption_scopes,
@@ -1754,8 +1755,16 @@ def inspect_task_spec(root: Path, task: dict) -> tuple[dict, dict]:
             if stored.get(field) != expected.get(field):
                 raise StateError("Canonical Spec dependency metadata no longer matches source selection.")
         refreshed = dict(stored)
-        refreshed["status"] = expected.get("status")
-        refreshed["shared_status"] = expected.get("shared_status")
+        for field in (
+            "status",
+            "shared_status",
+            "dependency_task_status",
+            "basis",
+        ):
+            if expected.get(field) is None:
+                refreshed.pop(field, None)
+            else:
+                refreshed[field] = expected.get(field)
         if expected.get("evidence"):
             refreshed["evidence"] = expected.get("evidence")
         refreshed_dependencies.append(refreshed)
@@ -6735,6 +6744,8 @@ def main() -> int:
     inspect_spec_parser = subcommands.add_parser("inspect-dev-spec", parents=[common])
     inspect_spec_parser.add_argument("--spec", required=True)
     inspect_spec_parser.add_argument("--repo-path", action="append", default=[])
+    inspect_spec_parser.add_argument("--spec-task", action="append", default=[])
+    inspect_spec_parser.add_argument("--manifest-only", action="store_true")
 
     initialize_spec = subcommands.add_parser("initialize-spec-execution", parents=[common])
     initialize_spec.add_argument("--spec", required=True)
@@ -6756,7 +6767,7 @@ def main() -> int:
     create_from_spec.add_argument("--task-id", required=True)
     create_from_spec.add_argument("--type", required=True)
     create_from_spec.add_argument("--title", required=True)
-    create_from_spec.add_argument("--repo-path", required=True, action="append")
+    create_from_spec.add_argument("--repo-path", action="append", default=[])
     create_from_spec.add_argument("--dependency-evidence", action="append", default=[])
     create_from_spec.add_argument("--agent", required=True)
     create_from_spec.add_argument("--no-set-current", action="store_true")
@@ -7017,15 +7028,21 @@ def main() -> int:
             emit(snapshot_state(root, session_file))
         elif command == "inspect-dev-spec":
             spec_path = Path(args.spec).expanduser()
-            emit(
-                inspection_summary(
-                    inspect_spec(
-                        spec_path if spec_path.is_absolute() else root / spec_path,
-                        root,
-                        parse_mapping_args(args.repo_path, "--repo-path"),
-                    )
+            if args.manifest_only and args.spec_task:
+                raise StateError("--manifest-only cannot be combined with --spec-task")
+            resolved_spec = spec_path if spec_path.is_absolute() else root / spec_path
+            repo_paths = parse_mapping_args(args.repo_path, "--repo-path")
+            inspection = (
+                inspect_manifest(resolved_spec, root, repo_paths)
+                if args.manifest_only
+                else inspect_spec(
+                    resolved_spec,
+                    root,
+                    repo_paths,
+                    args.spec_task or None,
                 )
             )
+            emit(inspection_summary(inspection))
         elif command == "initialize-spec-execution":
             emit(initialize_spec_execution_state(root, args.spec))
         elif command == "select-dev-spec-scope":

package/templates/shared-hooks/easy_dev_spec.py

@@ -128,31 +128,300 @@ def portable_path(root: Path, path: Path) -> str:
             )
 
 
+def _path_hint_status(root: Path, repository: dict[str, Any], repository_path: Path) -> str:
+    hint = Path(str(repository.get("path_hint") or ""))
+    if not str(hint):
+        return "missing"
+    resolved_hint = (hint if hint.is_absolute() else root / hint).resolve()
+    return "matched" if resolved_hint == repository_path.resolve() else "different"
+
+
 def _candidate_repository_paths(
     root: Path,
     repository: dict[str, Any],
     explicit_paths: dict[str, str],
-) -> list[Path]:
+) -> list[tuple[str, Path]]:
     repo_id = str(repository["repo_id"])
-    candidates: list[Path] = []
+    candidates: list[tuple[str, Path]] = []
     explicit = explicit_paths.get(repo_id)
     if explicit:
         path = Path(explicit)
         # An explicit binding is authoritative. Falling back to path_hint/root would make a
         # mistyped --repo-path appear valid while silently binding a different checkout.
-        return [(path if path.is_absolute() else root / path).resolve()]
+        return [("explicit", (path if path.is_absolute() else root / path).resolve())]
+    candidates.append(("current-root", root))
     hint = Path(str(repository.get("path_hint") or ""))
     if str(hint):
-        candidates.append(hint if hint.is_absolute() else root / hint)
-    candidates.append(root)
-    unique: list[Path] = []
-    for candidate in candidates:
+        candidates.append(("path-hint", hint if hint.is_absolute() else root / hint))
+    unique: list[tuple[str, Path]] = []
+    seen: set[Path] = set()
+    for binding_source, candidate in candidates:
         resolved = candidate.resolve()
-        if resolved not in unique:
-            unique.append(resolved)
+        if resolved not in seen:
+            unique.append((binding_source, resolved))
+            seen.add(resolved)
     return unique
 
 
+def _resolve_repository_binding(
+    root: Path,
+    repository: dict[str, Any],
+    explicit_paths: dict[str, str],
+) -> dict[str, Any] | None:
+    expected_remotes = {
+        normalize_remote(remote) for remote in repository["remote_urls"]
+    }
+    # 显式路径保持权威；否则当前 worktree 一旦通过 remote 验证就立即返回，不再探测旧 path_hint。
+    for binding_source, repository_path in _candidate_repository_paths(
+        root, repository, explicit_paths
+    ):
+        if not repository_path.is_dir():
+            continue
+        if not expected_remotes.intersection(repository_remotes(repository_path)):
+            continue
+        return {
+            "path": repository_path,
+            "binding_source": binding_source,
+            "path_hint_status": _path_hint_status(root, repository, repository_path),
+        }
+    return None
+
+
+def _current_repository_match(
+    root: Path,
+    repositories: list[dict[str, Any]],
+    explicit_paths: dict[str, str],
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    resolved_root = root.resolve()
+    repository_by_id = {
+        str(repository["repo_id"]): repository for repository in repositories
+    }
+    if len(explicit_paths) > 1:
+        raise EasyDevSpecError(
+            "Manifest routing accepts at most one --repo-path for the current repository"
+        )
+    if explicit_paths:
+        repo_id, raw_path = next(iter(explicit_paths.items()))
+        repository = repository_by_id.get(repo_id)
+        if repository is None:
+            raise EasyDevSpecError(f"Unknown Canonical repository: {repo_id}")
+        path = Path(raw_path)
+        resolved_path = (path if path.is_absolute() else root / path).resolve()
+        if resolved_path != resolved_root:
+            raise EasyDevSpecError(
+                "Manifest routing --repo-path must identify the current Git worktree"
+            )
+        binding = _resolve_repository_binding(root, repository, explicit_paths)
+        if binding is None:
+            raise EasyDevSpecError(
+                f"Current worktree does not match Canonical repository {repo_id}"
+            )
+        return repository, binding
+
+    local_remotes = set(repository_remotes(resolved_root))
+    if not local_remotes:
+        raise EasyDevSpecError(
+            "Current worktree has no Git remote; configure a matching remote before "
+            "Canonical manifest routing"
+        )
+    matches = [
+        repository
+        for repository in repositories
+        if local_remotes.intersection(
+            normalize_remote(remote) for remote in repository["remote_urls"]
+        )
+    ]
+    if len(matches) != 1:
+        candidates = ", ".join(str(item["repo_id"]) for item in matches) or "none"
+        raise EasyDevSpecError(
+            "Current worktree must match exactly one Canonical repository; "
+            f"matched: {candidates}. Pass --repo-path <repo-id>=<current-worktree>."
+        )
+    repository = matches[0]
+    return repository, {
+        "path": resolved_root,
+        "binding_source": "current-root-remote",
+        "path_hint_status": _path_hint_status(root, repository, resolved_root),
+    }
+
+
+def _dependency_execution_summary(
+    dependency: dict[str, Any],
+    source_snapshot: dict[str, Any],
+    execution_by_task: dict[str, dict[str, Any]],
+    manifest_status: str,
+    execution_available: bool,
+) -> dict[str, Any]:
+    dependency_id = str(dependency["task_id"])
+    shared_dependency = next(
+        (
+            item
+            for item in source_snapshot.get("dependencies", [])
+            if isinstance(item, dict) and item.get("task_id") == dependency_id
+        ),
+        None,
+    )
+    shared_status = (
+        shared_dependency.get("status")
+        if execution_available and isinstance(shared_dependency, dict)
+        else "pending"
+        if execution_available
+        else None
+    )
+    dependency_task_status = (
+        execution_by_task.get(dependency_id, {}).get("status", "not_started")
+        if execution_available
+        else None
+    )
+    dependency_type = str(dependency.get("type"))
+    if dependency_type == "contract":
+        status = "satisfied" if manifest_status == "READY" else "pending"
+        basis = "design-ready" if status == "satisfied" else "design-not-ready"
+    elif shared_status == "satisfied":
+        status = "satisfied"
+        basis = "recorded-evidence"
+    elif dependency_type == "hard" and dependency_task_status == "completed":
+        status = "satisfied"
+        basis = "dependency-task-completed"
+    else:
+        status = "pending"
+        basis = "pending-integration" if dependency_type == "integration" else "pending"
+    return {
+        "shared_status": shared_status,
+        "dependency_task_status": dependency_task_status,
+        "status": status,
+        "basis": basis,
+    }
+
+
+def inspect_manifest(
+    spec_path: Path,
+    root: Path,
+    repo_paths: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    """Return the current-repository task catalog without resolving unrelated checkouts."""
+
+    resolved_spec_path = spec_path.resolve()
+    if not resolved_spec_path.is_file():
+        raise EasyDevSpecError(f"Spec file does not exist: {resolved_spec_path}")
+    try:
+        text = resolved_spec_path.read_text(encoding="utf-8")
+        report = validate_spec(text)
+    except (OSError, UnicodeError) as exc:
+        raise EasyDevSpecError(
+            f"Cannot read Spec as UTF-8: {resolved_spec_path}: {exc}"
+        ) from exc
+    if report.protocol == "legacy":
+        return {
+            "inspection_mode": "manifest-only",
+            "protocol": "legacy",
+            "source_path": str(resolved_spec_path),
+            "source_sha256": hashlib.sha256(text.encode("utf-8")).hexdigest(),
+            "design_sha256": report.design_sha256,
+            "document_sha256": report.document_sha256,
+            "execution_revision": None,
+            "execution": None,
+            "selection_required": False,
+            "selected_task_ids": [],
+            "task_catalog": [],
+            "matched_repo_paths": {},
+            "unresolved_repositories": [],
+            "baseline_status": {},
+            "repository_bindings": [],
+        }
+    if report.protocol != "canonical-v1" or report.manifest is None or not report.ok:
+        details = "; ".join(
+            f"{issue.code}: {issue.message}" for issue in report.issues
+        ) or "unknown validation failure"
+        raise EasyDevSpecError(f"Canonical Spec validation failed: {details}")
+    manifest = report.manifest
+    repositories = manifest["repositories"]
+    tasks = manifest["tasks"]
+    repository, binding = _current_repository_match(
+        root, repositories, repo_paths or {}
+    )
+    current_repo_id = str(repository["repo_id"])
+    repository_names = {
+        str(item["repo_id"]): str(item["name"]) for item in repositories
+    }
+    execution = report.execution
+    execution_by_task = {
+        str(snapshot.get("task_id")): snapshot
+        for snapshot in execution.get("tasks", [])
+        if isinstance(execution, dict)
+        and isinstance(snapshot, dict)
+        and isinstance(snapshot.get("task_id"), str)
+    } if isinstance(execution, dict) else {}
+    task_catalog: list[dict[str, Any]] = []
+    for task in tasks:
+        task_id = str(task["task_id"])
+        source_snapshot = execution_by_task.get(task_id, {})
+        dependencies = [
+            {
+                **dependency,
+                **_dependency_execution_summary(
+                    dependency,
+                    source_snapshot,
+                    execution_by_task,
+                    str(manifest["status"]),
+                    isinstance(execution, dict),
+                ),
+            }
+            for dependency in task.get("depends_on", [])
+        ]
+        task_catalog.append(
+            {
+                "task_id": task_id,
+                "repo_id": task["repo_id"],
+                "repository_name": repository_names[str(task["repo_id"])],
+                "title": task["title"],
+                "status": task["status"],
+                "execution_status": (
+                    execution_by_task.get(task_id, {}).get("status", "not_started")
+                    if isinstance(execution, dict)
+                    else None
+                ),
+                "depends_on": dependencies,
+                "baseline_status": "not-inspected",
+            }
+        )
+    try:
+        source_path = portable_path(root, resolved_spec_path)
+    except EasyDevSpecError:
+        source_path = str(resolved_spec_path)
+    return {
+        "inspection_mode": "manifest-only",
+        "protocol": "canonical-v1",
+        "schema": SCHEMA,
+        "spec_id": manifest["spec_id"],
+        "revision": manifest["revision"],
+        "status": manifest["status"],
+        "title": manifest["title"],
+        "source_path": source_path,
+        "source_sha256": hashlib.sha256(text.encode("utf-8")).hexdigest(),
+        "design_sha256": report.design_sha256,
+        "document_sha256": report.document_sha256,
+        "execution_revision": (
+            execution.get("execution_revision") if isinstance(execution, dict) else None
+        ),
+        "execution": execution,
+        "repository_match": {
+            "repo_id": current_repo_id,
+            "name": repository["name"],
+            "path": portable_path(root, binding["path"]),
+            "binding_source": binding["binding_source"],
+            "path_hint_status": binding["path_hint_status"],
+        },
+        "task_catalog": task_catalog,
+        "selection_required": True,
+        "selected_task_ids": [],
+        "matched_repo_paths": {},
+        "unresolved_repositories": [],
+        "baseline_status": {},
+        "repository_bindings": [],
+    }
+
+
 def inspect_spec(
     spec_path: Path,
     root: Path,
@@ -168,6 +437,14 @@ def inspect_spec(
     task_by_id = {task["task_id"]: task for task in tasks}
     explicit_paths = repo_paths or {}
     selected_task_set = set(selected_task_ids or [])
+    unknown_tasks = selected_task_set - set(task_by_id)
+    if unknown_tasks:
+        raise EasyDevSpecError(
+            "Unknown Canonical Spec tasks: " + ", ".join(sorted(unknown_tasks))
+        )
+    selected_repo_ids = {
+        str(task_by_id[task_id]["repo_id"]) for task_id in selected_task_set
+    }
     matched_repo_paths: dict[str, str] = {}
     unresolved_repositories: list[str] = []
     baseline_status: dict[str, str] = {}
@@ -175,18 +452,15 @@ def inspect_spec(
 
     for repository in repositories:
         repo_id = str(repository["repo_id"])
-        expected_remotes = {normalize_remote(remote) for remote in repository["remote_urls"]}
-        matches = [
-            candidate
-            for candidate in _candidate_repository_paths(root, repository, explicit_paths)
-            if candidate.is_dir() and expected_remotes.intersection(repository_remotes(candidate))
-        ]
-        matches = list(dict.fromkeys(matches))
-        if len(matches) != 1:
+        # task 已选定后只解析其所属仓库，未选仓库不得制造路径或 baseline 阻塞。
+        if selected_repo_ids and repo_id not in selected_repo_ids:
+            continue
+        binding = _resolve_repository_binding(root, repository, explicit_paths)
+        if binding is None:
             unresolved_repositories.append(repo_id)
             baseline_status[repo_id] = "baseline-unavailable"
             continue
-        repository_path = matches[0]
+        repository_path = binding["path"]
         selected_paths = [
             str(change["path"])
             for change in changes
@@ -214,6 +488,8 @@ def inspect_spec(
                 "path": stored_path,
                 "baseline_commit": repository["baseline"]["commit"],
                 "baseline_status": status,
+                "binding_source": binding["binding_source"],
+                "path_hint_status": binding["path_hint_status"],
             }
         )
 
@@ -234,6 +510,7 @@ def inspect_spec(
         source_path = str(resolved_spec_path)
     execution = report.execution
     return {
+        "inspection_mode": "selected" if selected_task_set else "full",
         "protocol": "canonical-v1",
         "schema": SCHEMA,
         "spec_id": manifest["spec_id"],
@@ -255,6 +532,7 @@ def inspect_spec(
         "tests": manifest["tests"],
         "contracts": manifest["contracts"],
         "dependency_edges": dependency_edges,
+        "selected_task_ids": sorted(selected_task_set),
         "matched_repo_paths": matched_repo_paths,
         "unresolved_repositories": unresolved_repositories,
         "baseline_status": baseline_status,
@@ -376,29 +654,31 @@ def select_tasks(
             if evidence is None and dependency_target_counts[dependency_id] == 1:
                 evidence = evidence_by_dependency.get(dependency_id)
             source_snapshot = execution_by_task.get(source_task_id, {})
-            shared_dependency = next(
-                (
-                    item
-                    for item in source_snapshot.get("dependencies", [])
-                    if isinstance(item, dict) and item.get("task_id") == dependency_id
-                ),
-                None,
+            execution_fact = _dependency_execution_summary(
+                dependency,
+                source_snapshot,
+                execution_by_task,
+                str(inspection.get("status")),
+                isinstance(execution, dict),
             )
-            dependency_snapshot = execution_by_task.get(dependency_id, {})
-            shared_satisfied = bool(
-                isinstance(shared_dependency, dict)
-                and shared_dependency.get("status") == "satisfied"
+            shared_satisfied = execution_fact["shared_status"] == "satisfied"
+            dependency_completed = (
+                execution_fact["dependency_task_status"] == "completed"
             )
-            dependency_completed = dependency_snapshot.get("status") == "completed"
+            basis = execution_fact.get("basis")
             if dependency_type == "hard":
                 satisfied = shared_satisfied or dependency_completed or bool(evidence)
+                if execution_fact["status"] != "satisfied" and evidence:
+                    basis = "manual-evidence"
                 if dependency_id not in selected_set and not satisfied:
                     missing_hard.append(f"{source_task_id}->{dependency_id}")
             elif dependency_type == "contract":
-                satisfied = shared_satisfied or inspection.get("status") == "READY"
+                satisfied = execution_fact["status"] == "satisfied"
                 evidence = evidence or "canonical-spec-ready-contract"
             else:
                 satisfied = shared_satisfied or bool(evidence)
+                if execution_fact["status"] != "satisfied" and evidence:
+                    basis = "manual-evidence"
             dependency_records.append(
                 {
                     "source_task_id": source_task_id,
@@ -406,11 +686,11 @@ def select_tasks(
                     "dependency_type": dependency_type,
                     "required_evidence": dependency["required_evidence"],
                     "status": "satisfied" if satisfied else "pending",
-                    "shared_status": (
-                        shared_dependency.get("status")
-                        if isinstance(shared_dependency, dict)
-                        else "pending"
-                    ),
+                    "shared_status": execution_fact["shared_status"],
+                    "dependency_task_status": execution_fact[
+                        "dependency_task_status"
+                    ],
+                    "basis": basis,
                     **({"evidence": evidence} if evidence else {}),
                 }
             )
@@ -453,6 +733,7 @@ def inspection_summary(inspection: dict[str, Any]) -> dict[str, Any]:
     """Return the discovery surface without unrelated implementation routing objects."""
 
     keys = (
+        "inspection_mode",
         "protocol",
         "schema",
         "spec_id",
@@ -467,26 +748,84 @@ def inspection_summary(inspection: dict[str, Any]) -> dict[str, Any]:
         "repositories",
         "tasks",
         "dependency_edges",
+        "selected_task_ids",
+        "repository_match",
+        "task_catalog",
+        "selection_required",
         "matched_repo_paths",
         "unresolved_repositories",
         "baseline_status",
         "repository_bindings",
     )
-    summary = {key: inspection[key] for key in keys}
+    summary = {key: inspection[key] for key in keys if key in inspection}
     execution = inspection.get("execution")
+    relevant_execution_task_ids: set[str] | None = None
+    if inspection.get("inspection_mode") == "selected":
+        selected_task_ids = set(inspection.get("selected_task_ids", []))
+        selected_tasks = [
+            task
+            for task in inspection.get("tasks", [])
+            if str(task.get("task_id")) in selected_task_ids
+        ]
+        selected_repo_ids = {str(task.get("repo_id")) for task in selected_tasks}
+        execution_by_task = {
+            str(task.get("task_id")): task
+            for task in execution.get("tasks", [])
+            if isinstance(execution, dict)
+            and isinstance(task, dict)
+            and isinstance(task.get("task_id"), str)
+        } if isinstance(execution, dict) else {}
+        selected_edges: list[dict[str, Any]] = []
+        for edge in inspection.get("dependency_edges", []):
+            source_task_id = str(edge.get("source_task_id"))
+            if source_task_id not in selected_task_ids:
+                continue
+            selected_edges.append(
+                {
+                    **edge,
+                    **_dependency_execution_summary(
+                        {
+                            "task_id": edge.get("task_id"),
+                            "type": edge.get("dependency_type"),
+                        },
+                        execution_by_task.get(source_task_id, {}),
+                        execution_by_task,
+                        str(inspection.get("status")),
+                        isinstance(execution, dict),
+                    ),
+                }
+            )
+        summary["repositories"] = [
+            repository
+            for repository in inspection.get("repositories", [])
+            if str(repository.get("repo_id")) in selected_repo_ids
+        ]
+        summary["tasks"] = selected_tasks
+        summary["dependency_edges"] = selected_edges
+        relevant_execution_task_ids = selected_task_ids | {
+            str(edge.get("task_id")) for edge in selected_edges
+        }
     if isinstance(execution, dict):
+        execution_keys = [
+            "schema",
+            "spec_id",
+            "design_revision",
+            "design_sha256",
+            "execution_revision",
+            "updated_at",
+        ]
+        if inspection.get("inspection_mode") != "manifest-only":
+            execution_keys.append("tasks")
         summary["execution"] = {
             key: execution.get(key)
-            for key in (
-                "schema",
-                "spec_id",
-                "design_revision",
-                "design_sha256",
-                "execution_revision",
-                "updated_at",
-                "tasks",
-            )
+            for key in execution_keys
         }
+        if relevant_execution_task_ids is not None:
+            summary["execution"]["tasks"] = [
+                task
+                for task in execution.get("tasks", [])
+                if str(task.get("task_id")) in relevant_execution_task_ids
+            ]
     else:
         summary["execution"] = None
     return summary