project-tiny-context-harness 0.6.2 → 0.7.1

package/dist/commands/check-modularity.js

@@ -154,15 +154,15 @@ function parseLimit(value) {
     return limit;
 }
 function helpText() {
-    return `ty-context check-modularity:
-  check-modularity --touched [--limit 300] [--fail-on-warning]
-  check-modularity --file <path> [--file <path> ...] [--limit 300] [--fail-on-warning]
-  check-modularity --base <ref> [--limit 300] [--fail-on-warning]
-  check-modularity --config-only
-
-Audits physical lines, per-function statements and branch complexity, exports, state transitions and module responsibilities.
-For --touched and --base, existing findings are reported but only new or worsened non-line complexity is a warning; physical lines remain a risk signal and new files are audited in full.
-The default is warning-only; --fail-on-warning lets projects opt into CI enforcement.
-Generated configs default to modularity.policy: strict_except_generated; omitted policy is treated as scoped_waivers for compatibility.
+    return `ty-context check-modularity:
+  check-modularity --touched [--limit 300] [--fail-on-warning]
+  check-modularity --file <path> [--file <path> ...] [--limit 300] [--fail-on-warning]
+  check-modularity --base <ref> [--limit 300] [--fail-on-warning]
+  check-modularity --config-only
+
+Audits physical lines, per-function statements and branch complexity, exports, state transitions and module responsibilities.
+For --touched and --base, existing findings are reported but only new or worsened non-line complexity is a warning; physical lines remain a risk signal and new files are audited in full.
+The default is warning-only; --fail-on-warning lets projects opt into CI enforcement.
+Generated configs default to modularity.policy: strict_except_generated; omitted policy is treated as scoped_waivers for compatibility.
 Risks can be waived only through lifecycle-complete <harnessRoot>/config.yaml modularity.waivers when policy is scoped_waivers.`;
 }

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

@@ -23,70 +23,70 @@ 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]
+    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-command-args.d.ts

@@ -0,0 +1,3 @@
+export declare function option(args: string[], name: string): string | undefined;
+export declare function rejectOptions(args: string[], allowed: string[]): void;
+export declare function rejectUnknown(actual: string[], allowed: string[]): void;

package/dist/commands/long-task-command-args.js

@@ -0,0 +1,20 @@
+export function option(args, name) {
+    const indexes = args.flatMap((value, index) => value === name ? [index] : []);
+    if (indexes.length > 1)
+        throw new Error(`duplicate option: ${name}`);
+    if (!indexes.length)
+        return undefined;
+    const value = args[indexes[0] + 1];
+    if (!value || value.startsWith("--"))
+        throw new Error(`${name} requires a value`);
+    return value;
+}
+export function rejectOptions(args, allowed) {
+    for (let index = 0; index < args.length; index += 2)
+        if (!allowed.includes(args[index]) || !args[index + 1])
+            throw new Error(`Unknown or injected arguments: ${args.join(" ")}`);
+}
+export function rejectUnknown(actual, allowed) {
+    if (actual.join("\0") !== allowed.join("\0"))
+        throw new Error(`Unknown or injected arguments: ${actual.join(" ")}`);
+}

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

@@ -0,0 +1 @@
+export declare function handleLongTaskRevisionCommand(subcommand: string, workdir: string, args: string[]): Promise<boolean>;

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

@@ -0,0 +1,137 @@
+import path from "node:path";
+import { diagnoseAuthorityRevision } from "../lib/long-task-authority-revision-diagnosis.js";
+import { projectAuthorityRevisionDecision } from "../lib/long-task-authority-revision-summary.js";
+import { canRetainProgressForSupportingContextRevision } from "../lib/long-task-context-authority.js";
+import { compileDeliveryContract } from "../lib/long-task-delivery-compiler.js";
+import { approvePendingAuthorityRevision, clearFinalReceipt, clearAuthorityRevision, commitActiveAuthority, invalidateDerivedProgress, loadActiveLongTaskAuthority, readPendingAuthorityRevision, stageCompiledDeliveryContract, } from "../lib/long-task-state.js";
+import { repositoryRoot } from "../lib/long-task-workspace.js";
+import { option, rejectOptions } from "./long-task-command-args.js";
+export async function handleLongTaskRevisionCommand(subcommand, workdir, args) {
+    if (subcommand === "compile")
+        await compile(workdir, args);
+    else if (subcommand === "diagnose-revision")
+        await diagnoseRevision(workdir, args);
+    else if (subcommand === "approve-authority-revision")
+        await approveRevision(workdir, args);
+    else
+        return false;
+    return true;
+}
+async function compile(workdir, args) {
+    const revise = args.length === 1 && args[0] === "--revise";
+    if (args.length && !revise)
+        throw new Error(`Unknown or injected arguments: ${args.join(" ")}`);
+    const root = await repositoryRoot(process.cwd());
+    const loaded = await loadActiveLongTaskAuthority(root, {
+        migrate_legacy: true,
+    });
+    const previous = loaded.authority?.authority_snapshot ?? null;
+    if (loaded.authority && loaded.authority.workdir !== path.resolve(workdir))
+        throw new Error(`active_task_exists:${loaded.authority.workdir}`);
+    const revisionCapture = {
+        proposal: null,
+    };
+    const compiled = await compileForCommand(workdir, revise, previous, revisionCapture);
+    if (loaded.authority && loaded.authority.task_id !== compiled.task.id)
+        throw new Error(`active_task_exists:${loaded.authority.workdir}`);
+    const preserveProgress = previous !== null &&
+        canRetainProgressForSupportingContextRevision(previous, compiled);
+    const stagedCache = await stageCompiledDeliveryContract(compiled);
+    let authorityCommitted = false;
+    try {
+        await commitActiveAuthority({
+            candidate: compiled,
+            expected_previous_identity: loaded.authority?.active_authority_identity ?? null,
+        });
+        authorityCommitted = true;
+        try {
+            await stagedCache.publish();
+        }
+        catch (error) {
+            await stagedCache.discard();
+            throw new Error(`compiled_cache_projection_publish_failed:${message(error)}`);
+        }
+    }
+    catch (error) {
+        if (!authorityCommitted)
+            await stagedCache.discard();
+        throw error;
+    }
+    if (!previous || previous.compiled_identity !== compiled.compiled_identity) {
+        if (!preserveProgress)
+            await invalidateDerivedProgress(workdir);
+        await clearFinalReceipt(compiled.repository_root, workdir);
+    }
+    await clearAuthorityRevision(workdir);
+    console.log(JSON.stringify({
+        status: "compiled",
+        task_id: compiled.task.id,
+        compiled_identity: compiled.compiled_identity,
+        authority_revision: compiled.authority_revision,
+        effective_risk: compiled.effective_risk,
+        outcomes: compiled.outcomes.map((outcome) => outcome.key),
+        claim_coverage: compiled.claim_coverage,
+        progress_preserved: preserveProgress,
+        authority_revision_change: revisionCapture.proposal
+            ? projectAuthorityRevisionDecision(revisionCapture.proposal)
+            : null,
+        execution_model_checkpoint: executionModelCheckpoint(previous === null),
+    }));
+}
+async function compileForCommand(workdir, revise, previous, capture) {
+    try {
+        return await compileDeliveryContract(workdir, process.cwd(), {
+            revise,
+            previous_authority: previous,
+            on_authority_revision(value) {
+                capture.proposal = value;
+            },
+        });
+    }
+    catch (error) {
+        if (message(error).startsWith("authority_change_requires_user_decision:"))
+            await printPendingDecision(workdir, previous);
+        throw error;
+    }
+}
+async function printPendingDecision(workdir, previous) {
+    const pending = await readPendingAuthorityRevision(workdir);
+    if (!pending)
+        throw new Error("authority_revision_pending_state_missing");
+    console.log(JSON.stringify({
+        status: "authority_revision_pending",
+        acceptance_authorized: false,
+        active_compiled_identity: previous?.compiled_identity ?? null,
+        pending_authority_revision: projectAuthorityRevisionDecision(pending),
+    }));
+}
+async function diagnoseRevision(workdir, args) {
+    const outcome = option(args, "--outcome");
+    const check = option(args, "--check");
+    rejectOptions(args, ["--outcome", "--check"]);
+    const result = await diagnoseAuthorityRevision(workdir, { outcome, check });
+    console.log(JSON.stringify(result));
+    if (result.findings.length)
+        process.exitCode = 1;
+}
+async function approveRevision(workdir, args) {
+    const revision = option(args, "--revision");
+    rejectOptions(args, ["--revision"]);
+    if (!revision)
+        throw new Error("--revision requires a value");
+    await approvePendingAuthorityRevision(workdir, revision);
+    console.log(JSON.stringify({ status: "authority_revision_approved", revision }));
+}
+function executionModelCheckpoint(firstAuthorityLock) {
+    if (!firstAuthorityLock)
+        return { required: false };
+    return {
+        required: true,
+        phase: "post_authority_lock_pre_implementation",
+        options: ["continue_current_model", "switch_model_then_resume"],
+        message: "Authority Lock created. Pause before implementation and ask the user whether to continue with the current model or switch models, then resume this active Long-Task.",
+    };
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/long-task.js

@@ -1,13 +1,13 @@
 import path from "node:path";
-import { canRetainProgressForSupportingContextRevision } from "../lib/long-task-context-authority.js";
-import { compileDeliveryContract } from "../lib/long-task-delivery-compiler.js";
 import { runDeliveryFinalGate } from "../lib/long-task-final-v2.js";
 import { closeDeliveryTask, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "../lib/long-task-status-v2.js";
-import { abandonLongTaskState, approvePendingAuthorityRevision, clearFinalReceipt, clearAuthorityRevision, commitActiveAuthority, forceClearCorruptActiveState, invalidateDerivedProgress, loadActiveLongTaskAuthority, stageCompiledDeliveryContract, } from "../lib/long-task-state.js";
+import { abandonLongTaskState, forceClearCorruptActiveState, } from "../lib/long-task-state.js";
 import { verifyDeliveryContract } from "../lib/long-task-verifier-v2.js";
 import { repositoryRoot } from "../lib/long-task-workspace.js";
 import { initializeLongTask, preflightLongTask, } from "./long-task-authoring.js";
+import { option, rejectOptions, rejectUnknown, } from "./long-task-command-args.js";
 import { explainLongTask } from "./long-task-explain.js";
+import { handleLongTaskRevisionCommand } from "./long-task-revision.js";
 export async function longTask(args) {
     const subcommand = args[0] ?? "help";
     if (subcommand === "help")
@@ -26,10 +26,8 @@ export async function longTask(args) {
         rejectUnknown(args.slice(2), []);
         return preflightLongTask(workdir);
     }
-    if (subcommand === "compile")
-        return compile(workdir, args.slice(2));
-    if (subcommand === "approve-authority-revision")
-        return approveRevision(workdir, args.slice(2));
+    if (await handleLongTaskRevisionCommand(subcommand, workdir, args.slice(2)))
+        return;
     if (subcommand === "explain") {
         rejectUnknown(args.slice(2), []);
         return explainLongTask(workdir);
@@ -91,85 +89,6 @@ export async function longTask(args) {
     }
     throw new Error(`Unknown long-task subcommand: ${subcommand}`);
 }
-async function compile(workdir, args) {
-    const revise = args.length === 1 && args[0] === "--revise";
-    if (args.length && !revise)
-        throw new Error(`Unknown or injected arguments: ${args.join(" ")}`);
-    const root = await repositoryRoot(process.cwd());
-    const loaded = await loadActiveLongTaskAuthority(root, {
-        migrate_legacy: true,
-    });
-    const previous = loaded.authority?.authority_snapshot ?? null;
-    if (loaded.authority && loaded.authority.workdir !== path.resolve(workdir))
-        throw new Error(`active_task_exists:${loaded.authority.workdir}`);
-    const compiled = await compileDeliveryContract(workdir, process.cwd(), {
-        revise,
-        previous_authority: previous,
-    });
-    if (loaded.authority && loaded.authority.task_id !== compiled.task.id)
-        throw new Error(`active_task_exists:${loaded.authority.workdir}`);
-    const preserveProgress = previous !== null &&
-        canRetainProgressForSupportingContextRevision(previous, compiled);
-    const stagedCache = await stageCompiledDeliveryContract(compiled);
-    let authorityCommitted = false;
-    try {
-        await commitActiveAuthority({
-            candidate: compiled,
-            expected_previous_identity: loaded.authority?.active_authority_identity ?? null,
-        });
-        authorityCommitted = true;
-        try {
-            await stagedCache.publish();
-        }
-        catch (error) {
-            await stagedCache.discard();
-            throw new Error(`compiled_cache_projection_publish_failed:${message(error)}`);
-        }
-    }
-    catch (error) {
-        if (!authorityCommitted)
-            await stagedCache.discard();
-        throw error;
-    }
-    if (!previous || previous.compiled_identity !== compiled.compiled_identity) {
-        if (!preserveProgress)
-            await invalidateDerivedProgress(workdir);
-        await clearFinalReceipt(compiled.repository_root, workdir);
-    }
-    await clearAuthorityRevision(workdir);
-    console.log(JSON.stringify({
-        status: "compiled",
-        task_id: compiled.task.id,
-        compiled_identity: compiled.compiled_identity,
-        authority_revision: compiled.authority_revision,
-        effective_risk: compiled.effective_risk,
-        outcomes: compiled.outcomes.map((outcome) => outcome.key),
-        claim_coverage: compiled.claim_coverage,
-        progress_preserved: preserveProgress,
-        execution_model_checkpoint: executionModelCheckpoint(previous === null),
-    }));
-}
-function executionModelCheckpoint(firstAuthorityLock) {
-    if (!firstAuthorityLock)
-        return { required: false };
-    return {
-        required: true,
-        phase: "post_authority_lock_pre_implementation",
-        options: ["continue_current_model", "switch_model_then_resume"],
-        message: "Authority Lock created. Pause before implementation and ask the user whether to continue with the current model or switch models, then resume this active Long-Task.",
-    };
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-async function approveRevision(workdir, args) {
-    const revision = option(args, "--revision");
-    rejectOptions(args, ["--revision"]);
-    if (!revision)
-        throw new Error("--revision requires a value");
-    await approvePendingAuthorityRevision(workdir, revision);
-    console.log(JSON.stringify({ status: "authority_revision_approved", revision }));
-}
 async function verify(workdir, args) {
     const outcome = option(args, "--outcome");
     const check = option(args, "--check");
@@ -187,40 +106,21 @@ async function finalGate(workdir, args) {
         result.workflow_status !== "machine_accepted_external_pending")
         process.exitCode = 1;
 }
-function option(args, name) {
-    const indexes = args.flatMap((value, index) => value === name ? [index] : []);
-    if (indexes.length > 1)
-        throw new Error(`duplicate option: ${name}`);
-    if (!indexes.length)
-        return undefined;
-    const value = args[indexes[0] + 1];
-    if (!value || value.startsWith("--"))
-        throw new Error(`${name} requires a value`);
-    return value;
-}
-function rejectOptions(args, allowed) {
-    for (let index = 0; index < args.length; index += 2)
-        if (!allowed.includes(args[index]) || !args[index + 1])
-            throw new Error(`Unknown or injected arguments: ${args.join(" ")}`);
-}
-function rejectUnknown(actual, allowed) {
-    if (actual.join("\0") !== allowed.join("\0"))
-        throw new Error(`Unknown or injected arguments: ${actual.join(" ")}`);
-}
 function help() {
-    console.log(`ty-context long-task commands:
-  init <workdir>
-  preflight <workdir>
-  compile <workdir>
-  compile <workdir> --revise
-  approve-authority-revision <workdir> --revision <sha>
-  explain <workdir>
-  verify <workdir> [--outcome <key>] [--check <key>]
-  status <workdir>
-  resume <workdir>
-  doctor <workdir>
-  final-gate <workdir>
-  stop-check <workdir> [--message <text>]
-  close <workdir>
+    console.log(`ty-context long-task commands:
+  init <workdir>
+  preflight <workdir>
+  compile <workdir>
+  compile <workdir> --revise
+  diagnose-revision <workdir> [--outcome <key>] [--check <key>]
+  approve-authority-revision <workdir> --revision <sha>
+  explain <workdir>
+  verify <workdir> [--outcome <key>] [--check <key>]
+  status <workdir>
+  resume <workdir>
+  doctor <workdir>
+  final-gate <workdir>
+  stop-check <workdir> [--message <text>]
+  close <workdir>
   abandon <workdir> [--force-corrupt-state]`);
 }

package/dist/lib/long-task-authority-revision-details.d.ts

@@ -2,6 +2,8 @@ import type { CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, De
 export declare function checkIndex(globalChecks: CompiledCheckV2[], outcomes: CompiledOutcomeV2[]): Map<string, CompiledCheckV2>;
 export declare function changedRunnerFields(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
 export declare function removedOrReplacedVerificationInputs(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
+export declare function addedVerificationInputs(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
+export declare function addedInputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
 export declare function removedOrNarrowedInputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
 export declare function removedOrWeakenedExpectedOutputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
 export declare function sourceClaimReductions(beforeClaims: SourceClaimV2[], afterClaims: SourceClaimV2[]): string[];

package/dist/lib/long-task-authority-revision-details.js

@@ -25,6 +25,16 @@ export function removedOrReplacedVerificationInputs(identity, before, after) {
         .filter(([file, hash]) => after.verification_input_hashes[file] !== hash)
         .map(([file]) => `${identity}:${file}`);
 }
+export function addedVerificationInputs(identity, before, after) {
+    return Object.keys(after.verification_input_hashes)
+        .filter((file) => before.verification_input_hashes[file] === undefined)
+        .map((file) => `${identity}:${file}`);
+}
+export function addedInputPaths(identity, before, after) {
+    return after.input_paths
+        .filter((pattern) => !before.input_paths.includes(pattern))
+        .map((pattern) => `${identity}:${pattern}`);
+}
 export function removedOrNarrowedInputPaths(identity, before, after) {
     return before.input_paths
         .filter((oldPattern) => !after.input_paths.some((newPattern) => proveRepositoryPatternSubset(oldPattern, newPattern).status ===

package/dist/lib/long-task-authority-revision-diagnosis.d.ts

@@ -0,0 +1,24 @@
+import type { CheckExecutionResultV2, LongTaskFindingV2 } from "./long-task-delivery-types.js";
+import type { AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
+export interface AuthorityRevisionDiagnosisV2 {
+    schema_version: "long-task-authority-revision-diagnosis-v2";
+    status: "no_authority_change" | "monotonic_revision_available" | "scope_candidate_exercised" | "scope_candidate_previewed" | "protected_change_previewed" | "candidate_stale";
+    active_compiled_identity: string;
+    candidate_compiled_identity: string;
+    revision: AuthorityRevisionDecisionV2 | null;
+    acceptance_authorized: false;
+    progress_written: false;
+    pending_revision_written: false;
+    diagnostics_executed: boolean;
+    selected_outcome: string | null;
+    selected_check: string | null;
+    skipped_candidate_checks: string[];
+    snapshot_sha256: string | null;
+    check_results: CheckExecutionResultV2[];
+    findings: LongTaskFindingV2[];
+    completed_at: string;
+}
+export declare function diagnoseAuthorityRevision(workdirInput: string, selection?: {
+    outcome?: string;
+    check?: string;
+}): Promise<AuthorityRevisionDiagnosisV2>;