project-tiny-context-harness 0.6.1 → 0.7.0

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-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>;

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

@@ -0,0 +1,141 @@
+import path from "node:path";
+import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
+import { projectAuthorityRevisionDecision } from "./long-task-authority-revision-summary.js";
+import { activeAuthorityIdentityMatches, loadActiveLongTaskAuthority, } from "./long-task-state.js";
+import { allCompiledChecks, runDeliveryChecks, selectChecks, } from "./long-task-verifier-v2.js";
+import { createWorkspaceSnapshot, repositoryRoot, } from "./long-task-workspace.js";
+export async function diagnoseAuthorityRevision(workdirInput, selection = {}) {
+    const repository = await repositoryRoot(process.cwd());
+    const loaded = await loadActiveLongTaskAuthority(repository, {
+        migrate_legacy: true,
+    });
+    const active = loaded.authority;
+    if (!active)
+        throw new Error("active_task_missing");
+    const workdir = path.resolve(workdirInput);
+    if (active.workdir !== workdir)
+        throw new Error("active_task_workdir_mismatch");
+    const revisionCapture = {
+        proposal: null,
+    };
+    const candidate = await compileDeliveryContract(workdir, repository, {
+        revise: true,
+        previous_authority: active.authority_snapshot,
+        authority_revision_mode: "diagnose",
+        on_authority_revision(value) {
+            revisionCapture.proposal = value;
+        },
+    });
+    if (candidate.task.id !== active.task_id)
+        throw new Error("active_task_id_mismatch");
+    if (!(await activeIdentityStillMatches(repository, active)))
+        throw new Error("active_authority_changed_during_revision_diagnosis");
+    const proposal = revisionCapture.proposal;
+    if (!proposal)
+        return result({
+            status: "no_authority_change",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: null,
+            selection,
+        });
+    const decision = projectAuthorityRevisionDecision(proposal);
+    if (proposal.change_class === "monotonic_evidence_strengthening")
+        return result({
+            status: "monotonic_revision_available",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: decision,
+            selection,
+        });
+    if (proposal.change_class !== "scope_only_expansion")
+        return result({
+            status: "protected_change_previewed",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: decision,
+            selection,
+        });
+    const selected = selectChecks(candidate, selection);
+    const activeCheckIds = new Set(allCompiledChecks(active.authority_snapshot).map((check) => check.internal_id));
+    const runnable = selected.filter((check) => activeCheckIds.has(check.internal_id));
+    const skipped = selected
+        .filter((check) => !activeCheckIds.has(check.internal_id))
+        .map((check) => check.internal_id)
+        .sort();
+    if (!runnable.length)
+        return result({
+            status: "scope_candidate_previewed",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: decision,
+            selection,
+            skipped,
+        });
+    const snapshot = await createWorkspaceSnapshot(candidate.repository_root, candidate.workdir, `revision-diagnosis-${candidate.task.id}`);
+    try {
+        const run = await runDeliveryChecks(candidate, snapshot, runnable, true);
+        const unchanged = await activeIdentityStillMatches(repository, active);
+        if (!unchanged)
+            run.findings.push(activeAuthorityChangedFinding());
+        return result({
+            status: unchanged ? "scope_candidate_exercised" : "candidate_stale",
+            activeIdentity: active.active_authority_identity,
+            candidateIdentity: candidate.compiled_identity,
+            revision: decision,
+            selection,
+            skipped,
+            diagnosticsExecuted: true,
+            snapshotSha256: snapshot.manifest.snapshot_sha256,
+            checkResults: run.check_results,
+            findings: run.findings,
+        });
+    }
+    finally {
+        await snapshot.dispose();
+    }
+}
+async function activeIdentityStillMatches(repository, active) {
+    try {
+        const current = (await loadActiveLongTaskAuthority(repository)).authority;
+        return (current !== null &&
+            activeAuthorityIdentityMatches(current, {
+                task_id: active.task_id,
+                authority_revision: active.authority_revision,
+                compiled_identity: active.active_authority_identity,
+                worktree_identity: active.worktree_identity,
+            }));
+    }
+    catch {
+        return false;
+    }
+}
+function activeAuthorityChangedFinding() {
+    return {
+        code: "active_authority_changed_during_revision_diagnosis",
+        outcome_key: null,
+        check_key: null,
+        message: "Active Authority changed while candidate diagnosis was running.",
+        next_action: "Discard these transient results and diagnose the current Contract against the new Active Authority.",
+    };
+}
+function result(input) {
+    return {
+        schema_version: "long-task-authority-revision-diagnosis-v2",
+        status: input.status,
+        active_compiled_identity: input.activeIdentity,
+        candidate_compiled_identity: input.candidateIdentity,
+        revision: input.revision,
+        acceptance_authorized: false,
+        progress_written: false,
+        pending_revision_written: false,
+        diagnostics_executed: input.diagnosticsExecuted ?? false,
+        selected_outcome: input.selection.outcome ?? null,
+        selected_check: input.selection.check ?? null,
+        skipped_candidate_checks: input.skipped ?? [],
+        snapshot_sha256: input.snapshotSha256 ?? null,
+        check_results: input.checkResults ?? [],
+        findings: input.findings ?? [],
+        completed_at: new Date().toISOString(),
+    };
+}

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

@@ -1,3 +1,5 @@
+import type { AuthorityRevisionProposalV2 } from "./long-task-authority-revision-types.js";
 import type { AuthorityHashesV2, CompiledDeliveryContractV2, CompiledOutcomeV2, DeliveryContractV2, NextAuthorityMaterialsV2, VerifierIdentityV2 } from "./long-task-delivery-types.js";
 export declare function assertRiskNotDowngraded(previous: CompiledDeliveryContractV2, nextLevel: "standard" | "strict", nextReasons: string[]): void;
-export declare function enforceAuthorityRevision(previous: CompiledDeliveryContractV2, nextContract: DeliveryContractV2, nextHashes: AuthorityHashesV2, nextMaterials: NextAuthorityMaterialsV2, nextGlobalChecks: CompiledDeliveryContractV2["global"]["acceptance"]["checks"], nextOutcomes: CompiledOutcomeV2[], nextVerifier: VerifierIdentityV2, workdir: string, riskFloor: "standard" | "strict"): Promise<void>;
+export declare function buildAuthorityRevisionProposal(previous: CompiledDeliveryContractV2, nextContract: DeliveryContractV2, nextHashes: AuthorityHashesV2, nextMaterials: NextAuthorityMaterialsV2, nextGlobalChecks: CompiledDeliveryContractV2["global"]["acceptance"]["checks"], nextOutcomes: CompiledOutcomeV2[], nextVerifier: VerifierIdentityV2, riskFloor: "standard" | "strict"): AuthorityRevisionProposalV2;
+export declare function enforceAuthorityRevision(proposal: AuthorityRevisionProposalV2, workdir: string): Promise<void>;

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

@@ -1,6 +1,7 @@
 import { changedAuthoritySections } from "./long-task-authority.js";
 import { authorityMaterialHashes, compiledAuthorityMaterials, } from "./long-task-authority-materials.js";
-import { authorityRevisionDiff, } from "./long-task-authority-revision.js";
+import { authorityRevisionDiff } from "./long-task-authority-revision.js";
+import { classifyAuthorityRevision, summarizeAuthorityRevision, } from "./long-task-authority-revision-summary.js";
 import { authorityRevisionApproved, writePendingAuthorityRevision, } from "./long-task-state.js";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 export function assertRiskNotDowngraded(previous, nextLevel, nextReasons) {
@@ -11,11 +12,11 @@ export function assertRiskNotDowngraded(previous, nextLevel, nextReasons) {
     if (removed.length)
         throw new Error(`authority_risk_downgrade_rejected:${removed.join(",")}`);
 }
-export async function enforceAuthorityRevision(previous, nextContract, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier, workdir, riskFloor) {
+export function buildAuthorityRevisionProposal(previous, nextContract, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier, riskFloor) {
     const previousMaterials = compiledAuthorityMaterials(previous);
     const diff = authorityRevisionDiff(previous, nextContract, nextHashes, nextMaterials, nextGlobalChecks, nextOutcomes, nextVerifier);
-    if (!diff.reduction_reasons.length)
-        return;
+    const changeClass = classifyAuthorityRevision(diff);
+    const approvalSummary = summarizeAuthorityRevision(diff, nextContract.outcomes.map((outcome) => outcome.key));
     const unsignedRevision = {
         previous_hashes: previous.authority_hashes,
         next_hashes: nextHashes,
@@ -26,16 +27,23 @@ export async function enforceAuthorityRevision(previous, nextContract, nextHashe
         changed_authority_sections: changedAuthoritySections(previous.authority_hashes, nextHashes),
         revision_diff: diff,
         new_risk_floor: riskFloor,
-        affected_outcomes_or_contracts: nextContract.outcomes.map((outcome) => outcome.key),
+        affected_outcomes_or_contracts: approvalSummary.affected_outcomes,
+        change_class: changeClass,
+        approval_required: diff.reduction_reasons.length > 0,
+        approval_summary: approvalSummary,
     };
     const revisionIdentity = sha256Hex(canonicalValueJson(unsignedRevision));
-    if (!(await authorityRevisionApproved(workdir, revisionIdentity))) {
+    return { ...unsignedRevision, revision_identity: revisionIdentity };
+}
+export async function enforceAuthorityRevision(proposal, workdir) {
+    if (!proposal.approval_required)
+        return;
+    if (!(await authorityRevisionApproved(workdir, proposal.revision_identity))) {
         await writePendingAuthorityRevision(workdir, {
             schema_version: "long-task-authority-revision-pending-v2",
-            ...unsignedRevision,
-            revision_identity: revisionIdentity,
+            ...proposal,
             created_at: new Date().toISOString(),
         });
-        throw new Error(`authority_change_requires_user_decision:${revisionIdentity}`);
+        throw new Error(`authority_change_requires_user_decision:${proposal.revision_identity}`);
     }
 }

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

@@ -0,0 +1,11 @@
+import type { AuthorityRevisionApprovalSummaryV2, AuthorityRevisionChangeClassV2, AuthorityRevisionDecisionV2, AuthorityRevisionDiffV2 } from "./long-task-authority-revision-types.js";
+export declare function classifyAuthorityRevision(diff: AuthorityRevisionDiffV2): AuthorityRevisionChangeClassV2;
+export declare function summarizeAuthorityRevision(diff: AuthorityRevisionDiffV2, outcomeKeys: string[]): AuthorityRevisionApprovalSummaryV2;
+export declare function projectAuthorityRevisionDecision(value: {
+    revision_identity: string;
+    revision_diff: AuthorityRevisionDiffV2;
+    affected_outcomes_or_contracts: string[];
+    change_class?: AuthorityRevisionChangeClassV2;
+    approval_required?: boolean;
+    approval_summary?: AuthorityRevisionApprovalSummaryV2;
+}): AuthorityRevisionDecisionV2;