easy-coding-harness 1.0.0 → 1.0.1-beta.0

package/package.json

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

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

@@ -28,21 +28,16 @@ shows the compound high-risk and complexity signals required for Strict. Do not
 repositories, the full Spec, broad Git history, or every architecture section merely to prove
 that a bounded task might be complicated.
 
-For a task with `task.json.spec_source`, re-run `inspect-dev-spec` against the stored source, exact
+For a task with `task.json.spec_source`, use `resume-spec-context` 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/QUALITY
-evidence. An execution revision rollback is blocking. Then call the selector once for the exact
-selection:
+evidence. An execution revision rollback is blocking. Reuse the ready consumption returned by
+creation/claim in this session; otherwise load it once with:
 
 ```bash
-{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py inspect-dev-spec \
-  --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>]...
+{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py resume-spec-context \
+  --task-id <task-id> --agent <agent-id> --session-file <P>
 ```
 
 Load only the returned per-repository consumption closures: manifest/global context, selected
@@ -186,8 +181,9 @@ When TDD is enabled for a Java code task, make `test-strategy.md` record:
   status are non-blocking and never require an intermediate commit or push. Include these exact,
   language-independent contract markers: `local_test_gate: required` and
   `remote_ci_acceptance: non-blocking`.
-- current `tdd_readiness_status=ready`; if missing or drifted, stop before IMPLEMENT and route to
-  `ec-tdd-init`. Never plan to initialize CI inside an already-enabled TDD feature task.
+- current `tdd_readiness_status=ready`; a missing receipt requires `ec-tdd-init`, while
+  `needs_repair` requires fixing the reported entry without resetting TDD configuration.
+  Build-file content changes use current task tests and coverage; they do not require reinit.
 
 The state API mechanically freezes current Git `HEAD` per repository into `task.tdd_baselines`
 when ANALYSIS advances to IMPLEMENT. Plan the local command with that exact SHA and the frozen
@@ -306,6 +302,9 @@ waiting; it never changes the selected execution depth.
   incomplete selected-task coverage, or an open Unit/Step/File/Symbol/Test traceability gap.
 
 If evidence requires changing Canonical task boundaries, contracts, files, symbols, Steps, Tests,
-or dependencies, remain/return to ANALYSIS, update the original static design with revision +1,
+or dependencies, obtain confirmation and run `begin-spec-change --affected-task <id> --summary
+<confirmed-change> --agent <agent-id> --session-file <P>` before editing. This persists the
+intent across handoffs and blocks implementation/acceptance until synchronization. Update the original static design with revision +1,
 restore READY, and call `sync-spec-design --affected-task ...`. This invalidates the old local
-plan. Never substitute edits to the derived `dev-spec.md`, and never edit `EDS:EXECUTION` by hand.
+plan. Run `resume-spec-context` after synchronization, then refresh derived artifacts. Never
+substitute edits to the derived `dev-spec.md`, and never edit `EDS:EXECUTION` by hand.

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

@@ -71,6 +71,8 @@ still generates the GitLab TEST-stage job, but Harness does not wait for or reco
 results as acceptance evidence.
 
 Before any project/session enable action, require `tdd_readiness_status=ready`. If it is not ready,
-offer only `ec-tdd-init` or cancellation; never offer or persist "enable now, initialize later".
+route `needs_init` to `ec-tdd-init` and `needs_repair` to the reported repair. Preserve existing
+settings on failure; never offer or persist "enable now, initialize later". Normal build-file
+changes do not require initialization, and a CLI upgrade must preserve project/session TDD values.
 Readiness means infrastructure can measure future changed production lines. It does not certify
 repository-wide coverage and does not require tests for unchanged historical code.

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

@@ -9,6 +9,12 @@ Use only after ANALYSIS has frozen `task.json.workflow_mode` to `fast`, `standar
 `strict`. Read `dev-spec.md`, the latest `plan` record in `execution.jsonl`, relevant RULES
 and ABSTRACT sections, and `test-strategy.md` for code tasks.
 
+For a Canonical-backed task, consume the ready `spec_context.consumption` returned on creation
+or claim. On session resume or after design sync, call `resume-spec-context --agent <agent-id>
+--session-file <P>`. The bound source and selected changes/steps/tests govern the implementation;
+handoff summaries and derived plans cannot substitute for this context. A blocked context or
+pending `spec_change` stops implementation until the original source is repaired/synchronized.
+
 If frozen `task.tdd_enabled` is not `true`, IMPLEMENT writes production and planned test code but
 does not run lint, typecheck, test, build, or coverage commands. Deterministic execution belongs
 to QUALITY's Verification Gate. TDD is the only exception because RED/GREEN/REFACTOR commands are
@@ -167,8 +173,11 @@ checks:[], issues:[], needs_attention:[]
 6. For parallel units, detect overlapping writes before advancing.
 7. If implementation needs a file, symbol, repository, or source step outside the mapped
    Canonical change set, stop and return to ANALYSIS instead of expanding scope implicitly.
-8. If a static Canonical change is confirmed, revise the original design by exactly one revision
-   and use `sync-spec-design`; never edit the machine-owned execution block. If a writeback was
+8. If a static Canonical change is confirmed, first persist it with `begin-spec-change
+   --affected-task <id> --summary <confirmed-change> --agent <agent-id> --session-file <P>`.
+   Revise the original design by exactly one revision, validate READY and use `sync-spec-design`;
+   then `resume-spec-context` and rebuild the local plan in ANALYSIS. Never edit the
+   machine-owned execution block. If a writeback was
    interrupted, run `reconcile-spec-execution` with the stored idempotent pending action.
    Reconciliation only consumes dispatch/result evidence created after the current `in_progress`
    acknowledgment; it never opens a new repair attempt or reuses an earlier attempt's result.

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

@@ -10,6 +10,11 @@ does not modify source, tests, configuration, plans, or task scope.
 
 ## Candidate freeze
 
+For Canonical-backed tasks, load the current session's bound selection through `resume-spec-context`
+when resuming. Pass that original consumption closure to both gates and compare selected contracts,
+changes, Steps and Tests against the candidate. Pending `spec_change` blocks QUALITY acceptance
+until source revision synchronization and ANALYSIS replanning have completed.
+
 Call `evidence-fingerprints` once and use the returned implementation/config fingerprints for
 the whole attempt. It also returns the runtime-owned `quality_attempt` number, start time, evidence
 boundary, and repair count. Every Review and Verification record in this attempt must carry that

package/templates/common/skills/ec-task-management/SKILL.md

@@ -18,7 +18,8 @@ Call the state API snapshot and show:
 - active and resumable tasks.
 - for Canonical-backed tasks: source locator/path mode, Spec ID/design revision/design digest,
   document digest, execution revision, writeback status, selected task IDs, repository
-  bindings/baseline status, and pending dependency evidence.
+  bindings/baseline status, pending dependency evidence, loaded context version/session, and
+  pending confirmed Spec change.
 
 Mode inspection and configuration belongs to `ec-config`. If the user asks to change Approval,
 Workflow, TDD, or the TDD coverage threshold, route there and do not mutate those fields here.
@@ -36,9 +37,15 @@ selection or creation to `ec-lite` so the user can exit it first.
 When creating from a Canonical Spec, call `inspect-dev-spec --manifest-only`, display the complete
 task and dependency selection, then call `create-task-from-spec` only after explicit user
 selection. Multiple selected Spec tasks still create one Harness task. Do not call
-`select-dev-spec-scope` during routing; ANALYSIS owns the single consumption-closure read.
+`select-dev-spec-scope` during discovery. Creation and claim return the selected consumption
+closure; consume it before stage work. On a resumed session, use `resume-spec-context` with
+the current agent/session. A blocked context allows repair/rebind/sync, but blocks advancement.
 Initialize missing shared execution before creation. Support `rebind-spec-source` only when the
 new file matches schema + spec_id + design revision + design_sha256 and does not roll execution
 revision backward. A pending writeback is repaired with `reconcile-spec-execution`, never by
 editing the execution JSON block or starting a different writeback. A deterministic rejected
 action is cleared with `status:error`; correct its input instead of replaying it.
+
+Confirmed requirement changes use `begin-spec-change` before editing the original source.
+Its summary and affected tasks survive handoff. Finish revision + READY + `sync-spec-design`,
+then reload context and refresh the plan in ANALYSIS. Do not clear a pending change manually.

package/templates/common/skills/ec-tdd-init/SKILL.md

@@ -27,13 +27,14 @@ initialization.
 First run:
 
 ```bash
-python3 .easy-coding/tools/easy_coding_tdd_readiness.py --cwd . check
+python3 .easy-coding/tools/easy_coding_tdd_readiness.py --cwd . check --include-ci
 ```
 
 If it returns `ready`, report the recorded build/CI contract and stop without creating a task.
 The user may then use `ec-config` or `easy-coding config` to enable TDD.
 
-If it returns `needs_init`, inspect only the infrastructure needed to form a confirmed plan:
+If it returns `needs_init` or `needs_repair`, inspect only the reported infrastructure needed
+to form a confirmed initialization or repair plan:
 
 - Maven/Gradle files and the existing JUnit runner;
 - JaCoCo XML generation configuration;
@@ -90,13 +91,16 @@ frozen Workflow Mode's applicable build/test/CI syntax checks, then performs onl
 readiness check:
 
 ```bash
-python3 .easy-coding/tools/easy_coding_tdd_readiness.py --cwd . check
+python3 .easy-coding/tools/easy_coding_tdd_readiness.py --cwd . check --include-ci
 ```
 
-The `QUALITY -> MEMORY` gate requires the final check to return `ready`. If any recorded
-build or CI file changes after the receipt was created, readiness becomes `needs_init`; return to
-IMPLEMENT, refresh the receipt, and repeat QUALITY. Rerun this skill when
-the same drift occurs after task completion.
+The `QUALITY -> MEMORY` gate requires the full initialization check to return `ready`.
+Recorded SHA-256 values are historical snapshots, not freshness gates. Ordinary POM versions,
+dependencies, build plugins, formatting, CI changes, and managed tool upgrades do not require
+reinitialization. Daily `check` validates local entry points and task-variable contracts;
+`--include-ci` additionally validates the initialization build/CI contract. Missing receipts
+return `needs_init`; damaged receipts or required entries return `needs_repair`. Repair the
+reported entry, repeat applicable tests, and preserve the user's TDD settings.
 
-After completion, tell the user that TDD remains off and provide the explicit project/session
-enable route. Do not treat readiness as consent to enable it.
+After completion, report the unchanged TDD setting and provide the explicit project/session
+enable route when it is off. Do not treat readiness as consent to change it.

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

@@ -82,8 +82,8 @@ or `qoder`. Never use a display or source-author attribution such as `Codex with
    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
+   `select-dev-spec-scope` during discovery; creation returns the selected consumption closure
+   for `ec-analysis` to use directly. 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
@@ -118,7 +118,9 @@ or `qoder`. Never use a display or source-author attribution such as `Codex with
    `<source-task-id>-><dependency-task-id>=<evidence>`.
    Explicit project-external Spec files are supported and stored as absolute locators. If that
    locator moves, use `rebind-spec-source`; never guess by basename. Shared execution progress is
-   written only through state API writer commands. Static design edits require revision + READY +
+   written only through state API writer commands. Confirmed static design edits first require
+   `begin-spec-change --affected-task <id> --summary <confirmed-change> --agent <agent-id>
+   --session-file <P>`, then revision + READY +
    `sync-spec-design`; never hand-edit the `EDS:EXECUTION` region.
 4. When the user explicitly invokes `ec-tdd-init`, let that skill own preflight and create a
    `type=tdd-init` code task only after scope confirmation. Do not reinterpret it as an ordinary
@@ -155,6 +157,13 @@ writeback remains pending or conflicted. A deterministic writer rejection report
 clears the pending action so the corrected action can proceed; never overwrite a different
 pending action.
 
+Creation and claim return `spec_context.consumption` for the stored selection. Consume it before
+dispatching a stage. After session resume or design sync, call `resume-spec-context --agent
+<agent-id> --session-file <P>` and consume its returned closure. A blocked context requires
+source repair or design sync; never continue from a handoff summary alone. If `spec_change` is
+pending, resume that confirmed change on the bound original file before implementation/QUALITY.
+Recovery preserves the original event author/idempotency key and the current task owner separately.
+
 ## Boundary handling
 
 Use `request-transition` for a boundary that requires approval, then present the complete

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

@@ -54,6 +54,8 @@ First run `ec-init`; daily work goes through `ec-workflow`.
 - TDD is session override > project `behavior.tdd_enabled` > `false`; its changed-line threshold
   is session override > project `behavior.tdd_coverage_threshold` > `90`. ANALYSIS -> IMPLEMENT
   freezes both. TDD may be enabled only after `ec-tdd-init` records valid infrastructure readiness;
+  build version/content changes require fresh task evidence, not reinitialization. Repair missing
+  local entries without resetting TDD; CLI upgrades preserve project/session/frozen task settings;
   there is no enable-now/init-later state. The dedicated `tdd-init` task always freezes TDD off and
   initializes only changed-line coverage infrastructure, never historical business-test coverage.
   Disabled TDD adds no CI scan, JaCoCo work, commands, artifacts, or stronger gates. Enabled TDD
@@ -108,7 +110,11 @@ First run `ec-init`; daily work goes through `ec-workflow`.
   `document_sha256` and `execution_revision` may advance through shared writer commands. Project-
   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`.
+  confirmed design changes first use `begin-spec-change`, then revision + READY + `sync-spec-design`.
+  Creation/claim returns selected source context; session resume and design sync require
+  `resume-spec-context` before work. Pending changes block implementation/acceptance across agents.
+  Preserve the original writer actor while retaining the current owner during reconciliation.
+  Never hand-edit `EDS:EXECUTION`.
   Selected source tasks remain `implemented` through local QUALITY and become `verified`
   only when the accepted QUALITY -> MEMORY boundary is actually applied.
 - Canonical routing is two-pass: first use manifest-only discovery for the current worktree, then

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

@@ -52,6 +52,8 @@ First run `/ec-init`; daily work goes through `/ec-workflow`.
 - TDD is session override > project `behavior.tdd_enabled` > `false`; its changed-line threshold
   is session override > project `behavior.tdd_coverage_threshold` > `90`. ANALYSIS -> IMPLEMENT
   freezes both. TDD may be enabled only after `ec-tdd-init` records valid infrastructure readiness;
+  build version/content changes require fresh task evidence, not reinitialization. Repair missing
+  local entries without resetting TDD; CLI upgrades preserve project/session/frozen task settings;
   there is no enable-now/init-later state. The dedicated `tdd-init` task always freezes TDD off and
   initializes only changed-line coverage infrastructure, never historical business-test coverage.
   Disabled TDD adds no CI scan, JaCoCo work, commands, artifacts, or stronger gates. Enabled TDD
@@ -106,7 +108,11 @@ First run `/ec-init`; daily work goes through `/ec-workflow`.
   `document_sha256` and `execution_revision` may advance through shared writer commands. Project-
   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`.
+  confirmed design changes first use `begin-spec-change`, then revision + READY + `sync-spec-design`.
+  Creation/claim returns selected source context; session resume and design sync require
+  `resume-spec-context` before work. Pending changes block implementation/acceptance across agents.
+  Preserve the original writer actor while retaining the current owner during reconciliation.
+  Never hand-edit `EDS:EXECUTION`.
   Selected source tasks remain `implemented` through local QUALITY and become `verified`
   only when the accepted QUALITY -> MEMORY boundary is actually applied.
 - Canonical routing is two-pass: first use manifest-only discovery for the current worktree, then

package/templates/runtime/tools/easy_coding_tdd_readiness.py

@@ -118,21 +118,18 @@ def parse_records(root: Path, value: object, field: str, reasons: list[str]) ->
             reasons.append(f"{field} contains an invalid record")
             continue
         file_name = item.get("path")
-        expected = item.get("sha256")
-        if not isinstance(file_name, str) or not isinstance(expected, str):
-            reasons.append(f"{field} contains an invalid path or SHA-256")
+        if not isinstance(file_name, str) or not file_name.strip() or Path(file_name).is_absolute():
+            reasons.append(f"{field} contains an invalid path")
             continue
         try:
             _, resolved = project_file(root, file_name)
-            if sha256(resolved) != expected:
-                reasons.append(f"readiness file changed: {file_name}")
             contents.append(resolved.read_text(encoding="utf-8"))
         except (OSError, UnicodeError, ReadinessError) as error:
             reasons.append(str(error))
     return contents
 
 
-def inspect(root: Path) -> dict[str, object]:
+def inspect(root: Path, include_ci: bool = False) -> dict[str, object]:
     receipt = root / RECEIPT
     if not receipt.is_file():
         return {
@@ -145,7 +142,7 @@ def inspect(root: Path) -> dict[str, object]:
         manifest = json.loads(receipt.read_text(encoding="utf-8"))
     except (OSError, UnicodeError, json.JSONDecodeError):
         return {
-            "status": "needs_init",
+            "status": "needs_repair",
             "coverage_scope": COVERAGE_SCOPE,
             "reasons": ["TDD readiness receipt is invalid"],
             "receipt": RECEIPT.as_posix(),
@@ -182,7 +179,6 @@ def inspect(root: Path) -> dict[str, object]:
     manifest_ci_files = manifest.get("ci_files")
     manifest_tool_files = manifest.get("tool_files")
     build_contents = parse_records(root, manifest_build_files, "build_files", reasons)
-    ci_contents = parse_records(root, manifest_ci_files, "ci_files", reasons)
     parse_records(root, manifest_tool_files, "tool_files", reasons)
     build_paths = {
         Path(item.get("path", "")).name
@@ -196,8 +192,6 @@ def inspect(root: Path) -> dict[str, object]:
     } if isinstance(manifest_ci_files, list) else set()
     if not build_paths.intersection(JAVA_BUILD_FILE_NAMES):
         reasons.append("build_files must include a Maven or Gradle Java build file")
-    if not ci_paths.intersection(GITLAB_CI_ENTRY_FILES):
-        reasons.append("ci_files must include the project-root GitLab CI entry file")
     tool_paths = {
         item.get("path", "").replace("\\", "/")
         for item in manifest_tool_files
@@ -205,12 +199,16 @@ def inspect(root: Path) -> dict[str, object]:
     } if isinstance(manifest_tool_files, list) else set()
     if COVERAGE_TOOL_PATH not in tool_paths:
         reasons.append(f"tool_files must include {COVERAGE_TOOL_PATH}")
-    if not any("jacoco" in content.lower() for content in build_contents):
-        reasons.append("build files do not configure JaCoCo")
-    reasons.extend(ci_contract_reasons(ci_contents))
+    if include_ci:
+        ci_contents = parse_records(root, manifest_ci_files, "ci_files", reasons)
+        if not ci_paths.intersection(GITLAB_CI_ENTRY_FILES):
+            reasons.append("ci_files must include the project-root GitLab CI entry file")
+        if not any("jacoco" in content.lower() for content in build_contents):
+            reasons.append("build files do not configure JaCoCo")
+        reasons.extend(ci_contract_reasons(ci_contents))
 
     return {
-        "status": "ready" if not reasons else "needs_init",
+        "status": "ready" if not reasons else "needs_repair",
         "coverage_scope": COVERAGE_SCOPE,
         "reasons": list(dict.fromkeys(reasons)),
         "receipt": RECEIPT.as_posix(),
@@ -274,7 +272,7 @@ def record(args: argparse.Namespace, root: Path) -> dict[str, object]:
     temporary = receipt.with_suffix(f".tmp-{os.getpid()}")
     temporary.write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
     temporary.replace(receipt)
-    result = inspect(root)
+    result = inspect(root, include_ci=True)
     if result["status"] != "ready":
         raise ReadinessError("Recorded readiness receipt did not pass validation.")
     return result
@@ -284,7 +282,8 @@ def main() -> int:
     parser = argparse.ArgumentParser(description="Easy Coding Java TDD readiness tool")
     parser.add_argument("--cwd", default=".")
     subcommands = parser.add_subparsers(dest="command", required=True)
-    subcommands.add_parser("check")
+    check_parser = subcommands.add_parser("check")
+    check_parser.add_argument("--include-ci", action="store_true")
     record_parser = subcommands.add_parser("record")
     record_parser.add_argument("--build-file", action="append", default=[])
     record_parser.add_argument("--ci-file", action="append", default=[])
@@ -294,9 +293,10 @@ def main() -> int:
     args = parser.parse_args()
     root = Path(args.cwd).resolve()
     try:
-        result = inspect(root) if args.command == "check" else record(args, root)
+        result = inspect(root, args.include_ci) if args.command == "check" else record(args, root)
     except (OSError, UnicodeError, ReadinessError) as error:
-        print(json.dumps({"status": "needs_init", "reasons": [str(error)]}, ensure_ascii=False))
+        status = "needs_repair" if (root / RECEIPT).exists() else "needs_init"
+        print(json.dumps({"status": status, "reasons": [str(error)]}, ensure_ascii=False))
         return 2
     print(json.dumps(result, ensure_ascii=False))
     return 0 if result["status"] == "ready" else 1