project-tiny-context-harness 0.2.85 → 0.6.1

package/dist/commands/composite-long-task.js

@@ -1,164 +1,8 @@
-import path from "node:path";
-import { applySliceDelta, initializeSuperpowersTask } from "../lib/superpowers-task-state.js";
-import { compileSuperpowersTask } from "../lib/superpowers-task-compile.js";
-import { startAndSaveSuperpowersAttempt } from "../lib/superpowers-task-attempt.js";
-import { recordSuperpowersEvidence, runSuperpowersAssertion } from "../lib/superpowers-task-evidence.js";
-import { deriveSuperpowersArtifacts } from "../lib/superpowers-task-derive.js";
-import { runEpochGate, runFinalGate, runSliceGate } from "../lib/superpowers-task-gates.js";
-import { nextSuperpowersSlices } from "../lib/superpowers-task-next-slices.js";
-import { renderCompositeLongTaskGoal } from "../lib/composite-long-task-renderer.js";
-export async function compositeLongTask(args) {
-    await runCompositeLongTaskCommand(args, {
-        commandName: "ty-context composite-long-task",
-        label: "composite long-task",
-        showHelp: true
-    });
-}
-export async function runCompositeLongTaskCommand(args, options) {
-    const subcommand = args[0] ?? "help";
-    const workdirArg = args[1];
-    if (!workdirArg || subcommand === "help") {
-        help(options.commandName, options.showHelp);
-        return;
-    }
-    const workdir = path.resolve(process.cwd(), workdirArg);
-    if (subcommand === "init") {
-        await initializeSuperpowersTask(workdir, { planSlug: path.basename(workdir) });
-        console.log(`initialized ${options.label} state at ${workdirArg}/task-state.json`);
-        return;
-    }
-    if (subcommand === "compile") {
-        const state = await compileSuperpowersTask(workdir, { mode: attemptMode(args) });
-        console.log(`compiled ${options.label} graph plan_items=${Object.keys(state.graph.plan_items).length} acs=${Object.keys(state.graph.acceptance_criteria).length}`);
-        return;
-    }
-    if (subcommand === "start-attempt") {
-        const attempt = await startAndSaveSuperpowersAttempt(workdir, attemptMode(args));
-        console.log(`started attempt ${attempt.task_attempt_id}`);
-        return;
-    }
-    if (subcommand === "run-assertion") {
-        const separator = args.indexOf("--");
-        const commandArgs = separator >= 0 ? args.slice(separator + 1) : [];
-        const run = await runSuperpowersAssertion(workdir, {
-            acId: optionValue(args, "--ac") ?? "",
-            proofLayer: optionValue(args, "--proof-layer") ?? "",
-            commandArgs
-        });
-        console.log(`recorded assertion command_run_id=${run.command_run_id} exit_code=${run.exit_code}`);
-        if (run.exit_code !== 0) {
-            process.exitCode = 1;
-        }
-        return;
-    }
-    if (subcommand === "record-evidence") {
-        const evidence = await recordSuperpowersEvidence(workdir, {
-            artifactPath: path.resolve(process.cwd(), optionValue(args, "--from") ?? ""),
-            commandRunId: optionValue(args, "--command-run-id") ?? ""
-        });
-        console.log(`registered evidence ${evidence.evidence_id}`);
-        return;
-    }
-    if (subcommand === "apply-slice-delta") {
-        const delta = args[2];
-        if (!delta) {
-            throw new Error("apply-slice-delta requires <slice-delta.json>");
-        }
-        await applySliceDelta(workdir, path.resolve(process.cwd(), delta));
-        const result = await deriveSuperpowersArtifacts(workdir);
-        console.log(`applied ${options.label} slice delta and derived files=${result.files.length}`);
-        return;
-    }
-    if (subcommand === "derive") {
-        const result = await deriveSuperpowersArtifacts(workdir);
-        console.log(`derived ${options.label} artifacts files=${result.files.length}`);
-        return;
-    }
-    if (subcommand === "slice-gate") {
-        const sliceId = optionValue(args, "--slice") ?? "";
-        const result = await runSliceGate(workdir, sliceId);
-        console.log(result.passed ? `slice gate passed ${sliceId}` : `slice gate blocked ${result.messages.join("; ")}`);
-        if (!result.passed) {
-            process.exitCode = 1;
-        }
-        return;
-    }
-    if (subcommand === "epoch-gate") {
-        const epochId = optionValue(args, "--epoch") ?? "";
-        const result = await runEpochGate(workdir, epochId);
-        console.log(result.passed ? `epoch gate passed ${epochId}` : `epoch gate blocked ${result.messages.join("; ")}`);
-        return;
-    }
-    if (subcommand === "final-gate") {
-        const result = await runFinalGate(workdir);
-        console.log(`final gate product_goal_complete=${result.product_goal_complete}`);
-        console.log(`acceptance_target_status=${result.acceptance_target_status}`);
-        console.log(`completion_output_status=${result.completion_output_status}`);
-        console.log(`final_answer_allowed=${result.final_answer_allowed}`);
-        console.log(`required_user_visible_status=${result.required_user_visible_status}`);
-        console.log(`exit_code=${result.exit_code}`);
-        console.log(`audit_task_complete=${result.audit_task_complete}`);
-        if (result.blocker_triage) {
-            console.log(`blocker_triage_category=${result.blocker_triage.category}`);
-            console.log(`blocker_triage_self_recoverable=${result.blocker_triage.self_recoverable}`);
-            console.log(`blocker_triage_recovery_attempted=${result.blocker_triage.recovery_attempted}`);
-            console.log(`blocker_triage_next_action=${result.blocker_triage.next_action}`);
-        }
-        if (result.blocked_reasons.length > 0) {
-            console.log(`blocked_reasons=${result.blocked_reasons.join("; ")}`);
-        }
-        if (result.rejection_reasons.length > 0) {
-            console.log(`rejection_reasons=${result.rejection_reasons.join("; ")}`);
-        }
-        if (!result.final_answer_allowed) {
-            process.exitCode = result.exit_code;
-            for (const error of result.errors) {
-                console.error(`error: ${error}`);
-            }
-        }
-        return;
-    }
-    if (subcommand === "next-slices") {
-        const limit = Number.parseInt(optionValue(args, "--limit") ?? "5", 10);
-        const slices = await nextSuperpowersSlices(workdir, Number.isFinite(limit) ? limit : 5);
-        console.log(`Next ${Math.min(Number.isFinite(limit) ? limit : 5, 5)} high-value clusters:`);
-        console.log(slices.join("\n"));
-        return;
-    }
-    if (subcommand === "render-goal") {
-        const result = await renderCompositeLongTaskGoal(workdir);
-        console.log(`rendered ${options.label} goal artifacts: ${path.basename(result.goalObjectivePath)} ${path.basename(result.protocolPath)} ${path.basename(result.executionBindingPath)} length=${result.goalObjectiveLength}`);
-        return;
-    }
-    help(options.commandName, options.showHelp);
-}
-function help(commandName, showRenderGoal) {
-    const renderGoal = showRenderGoal ? "\n  render-goal <workdir>                  Render workflow-protocol.md, execution-binding.md and goal-objective.txt" : "";
-    console.log(`${commandName} commands:
-  init <workdir>                         Initialize task-state.json and events.ndjson
-  compile <workdir> [--mode product_task|harness_task]
-                                         Compile sources into task graph
-  start-attempt <workdir> [--mode product_task|harness_task]
-                                         Start a fresh current attempt
-  run-assertion <workdir> --ac <id> --proof-layer <layer> -- <command>
-                                         Run and record an assertion command
-  record-evidence <workdir> --from <artifact> --command-run-id <id>
-                                         Register current-attempt EvidenceRecordV2
-  apply-slice-delta <workdir> <delta>    Apply structured slice delta, evidence and derived views
-  derive <workdir>                       Generate derived/** views
-  slice-gate <workdir> --slice <id>      Validate one slice has real progress
-  epoch-gate <workdir> --epoch <id>      Refresh shared epoch evidence views
-  final-gate <workdir>                   Compute product_goal_complete and completion_output_status
-  next-slices <workdir> --limit 5        Recommend next proof clusters${renderGoal}`);
-}
-function optionValue(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] : undefined;
-}
-function attemptMode(args) {
-    const value = optionValue(args, "--mode");
-    if (value === "harness_task") {
-        return "harness_task";
-    }
-    return "product_task";
+export function compositeLongTask(_args) {
+    console.log(JSON.stringify({
+        status: "retired",
+        command: "composite-long-task",
+        next_command: "ty-context long-task",
+        historical_state_executed: false,
+    }));
 }

package/dist/commands/delivery-set.d.ts

@@ -0,0 +1 @@
+export declare function deliverySet(_args: string[]): void;

package/dist/commands/delivery-set.js

@@ -0,0 +1,8 @@
+const TOMBSTONE = {
+    status: "retired",
+    reason: "Delivery Set orchestration is outside the minimal Single-Goal core.",
+    replacement: "Use one complete Delivery Contract with semantic Outcomes and one Final Gate.",
+};
+export function deliverySet(_args) {
+    console.log(JSON.stringify(TOMBSTONE));
+}

package/dist/commands/disable.d.ts

@@ -0,0 +1 @@
+export declare function disable(args: string[]): Promise<void>;

package/dist/commands/disable.js

@@ -0,0 +1,15 @@
+import { disableHarnessProfile } from "../lib/profiles.js";
+import { runSync } from "../lib/sync-engine.js";
+export async function disable(args) {
+    const profile = args[0];
+    if (profile !== "long-task" || args.length !== 1) {
+        throw new Error("usage: ty-context disable long-task");
+    }
+    const root = process.cwd();
+    const result = await disableHarnessProfile(root, profile);
+    const sync = await runSync(root);
+    console.log(`${result.changed ? "disabled" : "kept disabled"} profile ${profile}`);
+    console.log(`sync changed=${sync.changed.length} skipped=${sync.skipped.length} blocked=${sync.blocked.length}`);
+    if (sync.blocked.length)
+        throw new Error(sync.blocked.join("\n"));
+}

package/dist/commands/enable.d.ts

@@ -0,0 +1 @@
+export declare function enable(args: string[]): Promise<void>;

package/dist/commands/enable.js

@@ -0,0 +1,14 @@
+import { enableHarnessProfile } from "../lib/profiles.js";
+import { runSync } from "../lib/sync-engine.js";
+export async function enable(args) {
+    const profile = args[0];
+    if (!profile || args.length !== 1)
+        throw new Error("usage: ty-context enable long-task");
+    const root = process.cwd();
+    const result = await enableHarnessProfile(root, profile);
+    const sync = await runSync(root);
+    console.log(`${result.changed ? "enabled" : "kept enabled"} profile ${profile}`);
+    console.log(`sync changed=${sync.changed.length} skipped=${sync.skipped.length} blocked=${sync.blocked.length}`);
+    if (sync.blocked.length)
+        throw new Error(sync.blocked.join("\n"));
+}

package/dist/commands/export-context-args.js

@@ -7,7 +7,7 @@ export function parseArgs(args) {
         includeContext: [],
         includeCode: [],
         redactionStrict: false,
-        help: false
+        help: false,
     };
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
@@ -97,7 +97,10 @@ Secret redaction is always enabled; --redaction-strict fails if redaction was re
 The artifact must stay under tmp/ty-context/context-exports/** and must not be referenced from project_context/context.toml.`;
 }
 function validateParsedArgs(parsed) {
-    const modeCount = Number(parsed.full) + Number(parsed.code) + Number(parsed.all) + Number(parsed.sourceMode !== undefined);
+    const modeCount = Number(parsed.full) +
+        Number(parsed.code) +
+        Number(parsed.all) +
+        Number(parsed.sourceMode !== undefined);
     if (modeCount > 1) {
         throw new Error("export-context accepts exactly one mode: --full, --code, --all, --code-index, --source-pack, --code-bundles or --task-context");
     }
@@ -126,13 +129,19 @@ function inlineValue(arg, flag, message) {
     return value;
 }
 function parseBundleStrategy(value) {
-    if (value === "auto" || value === "area" || value === "topdir" || value === "config")
+    if (value === "auto" ||
+        value === "area" ||
+        value === "topdir" ||
+        value === "config")
         return value;
     throw new Error("export-context --bundle-strategy must be one of auto, area, topdir or config");
 }
 function parseInteger(value, flag, allowZero) {
     const parsed = Number.parseInt(value, 10);
-    if (!Number.isInteger(parsed) || String(parsed) !== value.trim() || parsed < 0 || (!allowZero && parsed === 0)) {
+    if (!Number.isInteger(parsed) ||
+        String(parsed) !== value.trim() ||
+        parsed < 0 ||
+        (!allowZero && parsed === 0)) {
         throw new Error(`export-context ${flag} requires ${allowZero ? "a non-negative" : "a positive"} integer`);
     }
     return parsed;

package/dist/commands/export-context.js

@@ -11,7 +11,8 @@ export async function exportContext(args) {
         process.exitCode = 1;
         return;
     }
-    if (parsed.help || (!parsed.full && !parsed.code && !parsed.all && !parsed.sourceMode)) {
+    if (parsed.help ||
+        (!parsed.full && !parsed.code && !parsed.all && !parsed.sourceMode)) {
         console.log(helpText());
         if (!parsed.help) {
             process.exitCode = 1;
@@ -32,7 +33,7 @@ export async function exportContext(args) {
                 maxBundleCharacters: parsed.maxBundleCharacters,
                 redactionStrict: parsed.redactionStrict,
                 prune: parsed.prune,
-                taskName: parsed.taskName
+                taskName: parsed.taskName,
             }), parsed.check);
             return;
         }
@@ -44,9 +45,11 @@ export async function exportContext(args) {
             full: parsed.full,
             code: parsed.code,
             check: parsed.check,
-            output: parsed.output
+            output: parsed.output,
         });
-        console.log(parsed.check ? "export-context check OK" : "export-context wrote artifact");
+        console.log(parsed.check
+            ? "export-context check OK"
+            : "export-context wrote artifact");
         console.log(`mode: ${report.mode}`);
         console.log(`output: ${report.outputRelativePath}`);
         if (report.mode === "code") {
@@ -71,8 +74,16 @@ export async function exportContext(args) {
 }
 async function runLegacyAll(check) {
     const now = new Date();
-    const fullReport = await runExportContext(process.cwd(), { full: true, check, now });
-    const codeReport = await runExportContext(process.cwd(), { code: true, check, now });
+    const fullReport = await runExportContext(process.cwd(), {
+        full: true,
+        check,
+        now,
+    });
+    const codeReport = await runExportContext(process.cwd(), {
+        code: true,
+        check,
+        now,
+    });
     console.log(check ? "export-context check OK" : "export-context wrote artifacts");
     console.log("mode: all");
     console.log("outputs:");
@@ -85,7 +96,7 @@ async function runLegacyAll(check) {
     console.log("warnings:");
     printWarnings([
         ...fullReport.warnings.map((warning) => `full: ${warning}`),
-        ...codeReport.warnings.map((warning) => `code: ${warning}`)
+        ...codeReport.warnings.map((warning) => `code: ${warning}`),
     ]);
 }
 function printSourcePackReport(report, check) {

package/dist/commands/index.js

@@ -1,16 +1,23 @@
 import { checkModularity } from "./check-modularity.js";
 import { compositeLongTask } from "./composite-long-task.js";
+import { compositeCampaign } from "./composite-campaign.js";
+import { longTask } from "./long-task.js";
+import { deliverySet } from "./delivery-set.js";
 import { doctor } from "./doctor.js";
 import { exportContext } from "./export-context.js";
+import { enable } from "./enable.js";
+import { disable } from "./disable.js";
 import { init } from "./init.js";
 import { packageSource } from "./package-source.js";
-import { superpowers } from "./superpowers.js";
 import { sync } from "./sync.js";
 import { upgrade } from "./upgrade.js";
 import { validate } from "./validate.js";
+import { assertHarnessProfileEnabled } from "../lib/profiles.js";
 export const commands = {
     help,
     init,
+    enable,
+    disable,
     sync,
     upgrade,
     doctor,
@@ -20,37 +27,42 @@ export const commands = {
     "validate-context": (args) => validate(["validate-context", ...args]),
     "validate-code-modularity": (args) => validate(["validate-code-modularity", ...args]),
     "validate-harness": (args) => validate(["validate-harness", ...args]),
-    "validate-plan-contract": (args) => validate(["validate-plan-contract", ...args]),
-    "validate-plan-acceptance": (args) => validate(["validate-plan-acceptance", ...args]),
-    "validate-superpowers-state": (args) => validate(["validate-superpowers-state", ...args]),
+    "long-task": (args) => withLongTaskProfile(args, longTask),
+    "delivery-set": deliverySet,
     "composite-long-task": compositeLongTask,
-    superpowers,
-    package: packageSource
+    "composite-campaign": compositeCampaign,
+    package: packageSource,
 };
 export function help() {
-    console.log(`ty-context commands:
-  init [--adopt] [--harness-folder <path>]
-                       Initialize/adopt a project; without --harness-folder, choose target agent first
-  sync                 Refresh managed assets; does not run migrations
-  upgrade [--check] [--json]
-                       Run safe migrations, sync managed assets and doctor
-  doctor               Diagnose project configuration and drift
-  check-modularity --touched|--file <path>|--base <ref> [--limit 300] [--fail-on-warning]
-                       Warn when selected handwritten source files exceed a line-count limit
-  export-context --full|--code|--all|--source-pack|--code-index|--task-context
-                       Export temporary Context, code snapshot or bounded Source Pack artifacts
-  validate <gate>      Run a Harness validation gate
-  validate-context     Validate Minimal Context fact-source recoverability
-  validate-code-modularity
-                       Enforce touched handwritten source file modularity
-  validate-harness     Run validate-context and validate-code-modularity
-  validate-plan-contract <plan.md|dir>
-                       Validate workflow-contract plan surface consistency
-  validate-plan-acceptance <dir>
-                       Validate plan-conformance matrix and final verdict consistency
-  validate-superpowers-state <dir>
-                       Validate canonical Superpowers-backed task-state.json
-  composite-long-task <subcommand>
-                       Manage explicit composite long-task workflow workdirs
+    console.log(`ty-context commands:
+  init [--adopt] [--harness-folder <path>]
+                       Initialize/adopt a project; without --harness-folder, choose target agent first
+  enable long-task     Install Source Plan/Long-Task Skills, Stop Hook and templates
+  disable long-task    Remove only package-owned long-task profile assets
+  sync                 Refresh managed assets; does not run migrations
+  upgrade [--check] [--json]
+                       Run safe migrations, sync managed assets and doctor
+  doctor               Diagnose project configuration and drift
+  check-modularity --touched|--file <path>|--base <ref> [--limit 300] [--fail-on-warning]
+                       Warn when selected handwritten source files exceed a line-count limit
+  export-context --full|--code|--all|--source-pack|--code-index|--task-context
+                       Export temporary Context, code snapshot or bounded Source Pack artifacts
+  validate <gate>      Run a Harness validation gate
+  validate-context     Validate Minimal Context fact-source recoverability
+  validate-code-modularity
+                       Enforce touched handwritten source file modularity
+  validate-harness     Run validate-context and validate-code-modularity
+  long-task <subcommand>
+                       Manage one Canonical Delivery Contract in the current workspace
+  delivery-set <subcommand>
+                       Retired; use one complete Contract with semantic Outcomes
+  composite-long-task Retired command; use ty-context long-task
+  composite-campaign  Retired command; use ty-context long-task
   package <subcommand> Maintain package canonical source`);
 }
+async function withLongTaskProfile(args, handler) {
+    const subcommand = args[0] ?? "help";
+    if (subcommand !== "help")
+        await assertHarnessProfileEnabled(process.cwd(), "long-task");
+    await handler(args);
+}

package/dist/commands/init.js

@@ -1,7 +1,7 @@
 import { stdin as input, stdout as output } from "node:process";
 import * as readline from "node:readline/promises";
 import { runInit } from "../lib/init.js";
-import { normalizeHarnessFolderName, readHarnessRootConfig } from "../lib/harness-root.js";
+import { normalizeHarnessFolderName, readHarnessRootConfig, } from "../lib/harness-root.js";
 import { writePackageHarnessRoot } from "../lib/package-json-config.js";
 import { DEFAULT_HARNESS_ROOT } from "../lib/paths.js";
 const AGENT_HARNESS_OPTIONS = [
@@ -11,7 +11,7 @@ const AGENT_HARNESS_OPTIONS = [
     { key: "cline", label: "Cline", harnessFolderName: ".cline" },
     { key: "roo", label: "Roo Code", harnessFolderName: ".roo" },
     { key: "gemini", label: "Gemini CLI", harnessFolderName: ".gemini" },
-    { key: "other", label: "Other" }
+    { key: "other", label: "Other" },
 ];
 export async function init(args) {
     const adopt = args.includes("--adopt");
@@ -28,7 +28,8 @@ export async function init(args) {
     }
 }
 export async function resolveInitHarnessRoot(projectRoot, args) {
-    const argRoot = valueForArg(args, "--harness-folder") ?? valueForArg(args, "--harnessFolderName");
+    const argRoot = valueForArg(args, "--harness-folder") ??
+        valueForArg(args, "--harnessFolderName");
     if (argRoot) {
         return normalizeHarnessFolderName(argRoot);
     }
@@ -68,7 +69,9 @@ async function questionUntilValid(rl, query) {
 function formatAgentChoices() {
     const lines = ["Choose target agent:"];
     AGENT_HARNESS_OPTIONS.forEach((option, index) => {
-        const folder = option.harnessFolderName ? ` -> ${option.harnessFolderName}` : "";
+        const folder = option.harnessFolderName
+            ? ` -> ${option.harnessFolderName}`
+            : "";
         lines.push(`${index + 1}) ${option.label}${folder}`);
     });
     return lines.join("\n");
@@ -78,7 +81,8 @@ export function resolveAgentHarnessFolderName(agentAnswer, customFolderAnswer =
     if (!option) {
         throw new Error("Unknown agent choice");
     }
-    return normalizeHarnessFolderName(option.harnessFolderName ?? (customFolderAnswer.trim() || DEFAULT_HARNESS_ROOT));
+    return normalizeHarnessFolderName(option.harnessFolderName ??
+        (customFolderAnswer.trim() || DEFAULT_HARNESS_ROOT));
 }
 function agentOptionForAnswer(answer) {
     const normalized = answer.trim().toLowerCase();
@@ -91,7 +95,9 @@ function agentOptionForAnswer(answer) {
     }
     return AGENT_HARNESS_OPTIONS.find((option) => {
         const label = option.label.toLowerCase();
-        return option.key === normalized || label === normalized || label.replace(/\s+/g, "-") === normalized;
+        return (option.key === normalized ||
+            label === normalized ||
+            label.replace(/\s+/g, "-") === normalized);
     });
 }
 function valueForArg(args, name) {

package/dist/commands/long-task-authoring.d.ts

@@ -0,0 +1,3 @@
+export declare function initializeLongTask(workdir: string): Promise<void>;
+export declare function preflightLongTask(workdir: string): Promise<void>;
+export declare function compactLongTaskTemplate(): string;

package/dist/commands/long-task-authoring.js

@@ -0,0 +1,92 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { preflightDeliveryContract } from "../lib/long-task-authoring-preflight.js";
+export async function initializeLongTask(workdir) {
+    await mkdir(workdir, { recursive: true });
+    try {
+        await writeFile(path.join(workdir, "delivery-contract.yaml"), template(), {
+            flag: "wx",
+        });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+}
+export async function preflightLongTask(workdir) {
+    const result = await preflightDeliveryContract(workdir, process.cwd());
+    console.log(JSON.stringify(result, null, 2));
+    if (result.status !== "ready")
+        process.exitCode = 1;
+}
+export function compactLongTaskTemplate() {
+    return template();
+}
+function template() {
+    return `schema_version: long-task-delivery-v2
+task:
+  id: replace-me
+  title: Replace me
+  goal: Describe the complete observable delivery goal.
+  source_paths: [plans/replace-me.md]
+  context_refs: [project_context/areas/replace-me.md]
+source_claims:
+  - key: replace-requirement
+    source_ref: plans/replace-me.md#replace-requirement
+    statement: Preserve one atomic source requirement.
+    disposition:
+      type: claim
+      refs: [replace-outcome.requirement.replace-requirement]
+risk:
+  facts: {}
+global: {}
+outcomes:
+  - key: replace-outcome
+    title: Replace outcome
+    product:
+      observable_result: Describe what a user or system can observe.
+      owner:
+        label: replace-owner
+        context_refs: [project_context/areas/replace-me.md]
+        path_globs: ["src/**", "tests/**"]
+      requirements:
+        - key: replace-requirement
+          statement: Preserve one atomic source requirement.
+          required_proof_surfaces: [runtime_behavior]
+    technical:
+      expected_change_paths: ["src/**"]
+      bindings:
+        - key: replace-carrier
+          kind: file
+          target: src/replace-me.ts
+          carrier_paths: [src/replace-me.ts]
+          existence: planned
+    acceptance:
+      checks:
+        - key: replace-check
+          proof_surface: runtime_behavior
+          runner:
+            type: node_oracle
+            target: tests/replace-oracle.mjs
+            effect: read_only
+          verification_inputs: ["tests/replace-oracle.mjs"]
+          input_paths: [src/replace-me.ts]
+          expected_output_paths: [src/replace-me.ts]
+          positive_assertions:
+            - key: replace-success
+              criterion: The declared outcome and requirement are observable.
+              claims: [result, requirement.replace-requirement]
+              observation: result
+              operator: equals
+              expected: true
+      counterfactual_controls:
+        - key: remove-replace-carrier
+          binding_key: replace-carrier
+          claims: [result, requirement.replace-requirement]
+          check_key: replace-check
+          mutation:
+            type: remove_paths
+            paths: [src/replace-me.ts]
+          expected_assertion_failures: [replace-success]
+`;
+}

package/dist/commands/long-task-explain.d.ts

@@ -0,0 +1 @@
+export declare function explainLongTask(workdir: string): Promise<void>;

package/dist/commands/long-task-explain.js

@@ -0,0 +1,52 @@
+import { compileProductClaimCoverage } from "../lib/long-task-claims.js";
+import { sourceCoverage } from "../lib/long-task-authoring-preflight-diagnostics.js";
+import { parseDeliveryContractBundle } from "../lib/long-task-delivery-parser.js";
+import { explainSourceLinks } from "../lib/long-task-explain-source-links.js";
+import { classifyLongTaskRisk } from "../lib/long-task-risk.js";
+import { compileSourceInventory } from "../lib/long-task-source-inventory.js";
+import { validateSourceContinuity } from "../lib/long-task-source-continuity.js";
+import { validateSourceTargetContinuity } from "../lib/long-task-source-target-continuity.js";
+import { repositoryRoot } from "../lib/long-task-workspace.js";
+export async function explainLongTask(workdir) {
+    const parsed = await parseDeliveryContractBundle(workdir);
+    const repository = await repositoryRoot(process.cwd());
+    const sourceInventory = await compileSourceInventory(repository, parsed.contract.task.source_paths);
+    validateSourceContinuity(parsed.contract, sourceInventory);
+    validateSourceTargetContinuity(parsed.contract, sourceInventory);
+    const coverage = compileProductClaimCoverage(parsed.contract);
+    const risk = classifyLongTaskRisk(parsed.contract);
+    const globalClaims = Object.entries(coverage.summary.claims_by_global).map(([claimKey, value]) => ({
+        claim: `GLOBAL.${claimKey}`,
+        covered: value.covered,
+        checks: value.proofs.map((proof) => proof.check_key),
+        assertions: value.proofs.map((proof) => proof.assertion_key),
+        polarity: value.proofs.map((proof) => proof.polarity),
+        proof_surfaces: value.proofs.map((proof) => proof.proof_surface),
+        strict_risk_obligations: [],
+    }));
+    const outcomeClaims = Object.entries(coverage.summary.claims_by_outcome).flatMap(([outcomeKey, rows]) => Object.entries(rows).map(([claimKey, value]) => ({
+        claim: `OUTCOME.${outcomeKey}.${claimKey}`,
+        covered: value.covered,
+        checks: value.proofs.map((proof) => proof.check_key),
+        assertions: value.proofs.map((proof) => proof.assertion_key),
+        polarity: value.proofs.map((proof) => proof.polarity),
+        proof_surfaces: value.proofs.map((proof) => proof.proof_surface),
+        strict_risk_obligations: risk.reasons_by_outcome[outcomeKey],
+    })));
+    console.log(JSON.stringify({
+        schema_version: "long-task-explain-v2",
+        claims: [...globalClaims, ...outcomeClaims],
+        coverage: coverage.summary,
+        source_coverage: sourceCoverage(parsed.contract),
+        source_items: sourceInventory.map((item) => {
+            const source = parsed.contract.source_claims.find((claim) => claim.key === item.key);
+            return {
+                ...item,
+                source_ref: source.source_ref,
+                statement: source.statement,
+                disposition: source.disposition,
+                links: explainSourceLinks(parsed.contract, coverage.summary, source),
+            };
+        }),
+    }, null, 2));
+}

package/dist/commands/long-task.d.ts

@@ -0,0 +1 @@
+export declare function longTask(args: string[]): Promise<void>;