project-tiny-context-harness 0.8.12 → 0.8.16

package/dist/commands/design-resource-recovery.js

@@ -0,0 +1,152 @@
+import { parseDesignResourceRecoveryCreateInput } from "../lib/design-resource-recovery-codec.js";
+import { readRecoveryRepositoryFile } from "../lib/design-resource-recovery-files.js";
+import { applyDesignResourceRecoveryWriteback, createDesignResourceRecoveryCheckpoint, inspectDesignResourceRecovery, previewDesignResourceRecoveryWriteback, reconcileDesignResourceRecovery, removeDesignResourceRecoveryCheckpoint, updateDesignResourceRecoveryCheckpoint, } from "../lib/design-resource-recovery.js";
+import { canonicalJson } from "../lib/strict-codec.js";
+export async function designResourceRecoveryCommand(args) {
+    const [action, sessionId, ...rest] = args;
+    if (!action || !sessionId)
+        throw new Error("usage: ty-context design-resource recovery <create|update|inspect|preview|apply|reconcile|remove> <session> [options]");
+    const options = recoveryOptions(rest);
+    let result;
+    if (action === "create")
+        result = await create(process.cwd(), sessionId, options);
+    else if (action === "update")
+        result = await update(process.cwd(), sessionId, options);
+    else if (action === "inspect") {
+        assertNoValueOptions(options, action);
+        result = await inspectDesignResourceRecovery(process.cwd(), sessionId);
+    }
+    else if (action === "preview") {
+        assertNoValueOptions(options, action);
+        result = await previewDesignResourceRecoveryWriteback(process.cwd(), sessionId);
+    }
+    else if (action === "apply")
+        result = await apply(process.cwd(), sessionId, options);
+    else if (action === "reconcile")
+        result = await reconcile(process.cwd(), sessionId, options);
+    else if (action === "remove")
+        result = await remove(process.cwd(), sessionId, options);
+    else
+        throw new Error(`Unknown design-resource recovery action: ${action}`);
+    if (options.json)
+        process.stdout.write(canonicalJson(result));
+    else
+        printRecoveryResult(action, result);
+    if ((action === "apply" || action === "reconcile") &&
+        result.status === "blocked")
+        process.exitCode = 2;
+    if (action === "remove" &&
+        result.status === "partial")
+        process.exitCode = 2;
+}
+async function create(repository, sessionId, options) {
+    if (!options.input || options.audit || options.expectedSha256)
+        usage("create <session> --input <state.json>");
+    const input = await readCreateInput(repository, options.input);
+    if (input.session_id !== sessionId)
+        throw new Error("design_resource_recovery_invalid:create_session_identity_mismatch");
+    return createDesignResourceRecoveryCheckpoint(repository, input);
+}
+async function apply(repository, sessionId, options) {
+    if (!options.audit || options.input || options.expectedSha256)
+        usage("apply <session> --audit <audit.json>");
+    return applyDesignResourceRecoveryWriteback(repository, sessionId, options.audit);
+}
+async function reconcile(repository, sessionId, options) {
+    if (!options.audit || options.input || options.expectedSha256)
+        usage("reconcile <session> --audit <audit.json>");
+    return reconcileDesignResourceRecovery(repository, sessionId, options.audit);
+}
+async function update(repository, sessionId, options) {
+    if (!options.input || !options.expectedSha256 || options.audit)
+        usage("update <session> --input <state.json> --expected-sha256 <sha256>");
+    const input = await readCreateInput(repository, options.input);
+    if (input.session_id !== sessionId)
+        throw new Error("design_resource_recovery_invalid:update_session_identity_mismatch");
+    return updateDesignResourceRecoveryCheckpoint(repository, input, options.expectedSha256);
+}
+async function remove(repository, sessionId, options) {
+    if (!options.expectedSha256 || options.input || options.audit)
+        usage("remove <session> --expected-sha256 <sha256>");
+    return removeDesignResourceRecoveryCheckpoint(repository, sessionId, options.expectedSha256);
+}
+function recoveryOptions(args) {
+    const result = { json: false };
+    for (let index = 0; index < args.length; index += 1) {
+        const item = args[index];
+        if (item === "--json") {
+            result.json = true;
+            continue;
+        }
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`${item} requires a value`);
+        if (item === "--input")
+            result.input = value;
+        else if (item === "--audit")
+            result.audit = value;
+        else if (item === "--expected-sha256")
+            result.expectedSha256 = value;
+        else
+            throw new Error(`Unknown design-resource recovery option: ${item}`);
+        index += 1;
+    }
+    return result;
+}
+function assertNoValueOptions(options, action) {
+    if (options.input || options.audit || options.expectedSha256)
+        usage(`${action} <session>`);
+}
+function usage(value) {
+    throw new Error(`usage: ty-context design-resource recovery ${value} [--json]`);
+}
+async function readCreateInput(repository, locator) {
+    const inputSnapshot = await readRecoveryRepositoryFile(repository, locator, "design_resource_recovery_create_input");
+    return parseDesignResourceRecoveryCreateInput(inputSnapshot.bytes.toString("utf8"));
+}
+function printRecoveryResult(action, result) {
+    const row = result;
+    if (action === "create" || action === "update") {
+        console.log(`DRA recovery checkpoint: ${row.status}`);
+        console.log(`Path: ${row.checkpoint_path}`);
+        console.log(`SHA-256: ${row.checkpoint_raw_byte_digest}`);
+        return;
+    }
+    if (action === "inspect" || action === "preview") {
+        printInspection(row);
+        if (action === "preview")
+            printPatch(row);
+        return;
+    }
+    if (action === "apply") {
+        console.log(`DRA writeback: ${row.status}`);
+        console.log(`Write transaction: ${row.write_transaction}`);
+        console.log(`Reconciliation: ${JSON.stringify(row.reconciliation)}`);
+        return;
+    }
+    if (action === "reconcile") {
+        console.log(`DRA reconciliation: ${row.status}`);
+        console.log(`Write transaction: ${row.write_transaction}`);
+        console.log(`Reconciliation: ${JSON.stringify(row.reconciliation)}`);
+        return;
+    }
+    console.log(`DRA recovery cleanup: ${row.status}`);
+    console.log(`Path: ${row.path}`);
+    if (row.status === "partial")
+        console.log(`Retained: ${JSON.stringify(row.retained_entries)}`);
+}
+function printInspection(row) {
+    const replay = row.replay;
+    console.log(`Base: ${replay.base.locator}@${replay.base.raw_byte_digest}`);
+    console.log(`Delta: ${replay.ordered_active_accepted_deltas.length} accepted / ${replay.rejected_deltas.length} rejected / ${replay.unresolved_deltas.length} unresolved`);
+    console.log(`Explicitly unchanged: ${replay.explicitly_unchanged_keys.join(", ") || "none"}`);
+    console.log(`Writeback: ${JSON.stringify(row.writeback)}`);
+}
+function printPatch(row) {
+    const patch = row.patch;
+    for (const operation of patch.patch.operations) {
+        console.log(`Patch ${operation.operation_id} [${operation.target_key}]:`);
+        console.log(`- ${operation.before_text}`);
+        console.log(`+ ${operation.after_text}`);
+    }
+}

package/dist/commands/design-resource.js

@@ -1,5 +1,6 @@
 import { publishDesignResourceHandoffBundle } from "../lib/design-resource-handoff-bundle.js";
 import { preflightDesignResourceHandoff } from "../lib/design-resource-handoff-validation.js";
+import { designResourceRecoveryCommand } from "./design-resource-recovery.js";
 import { normalizeRepositoryCwd, normalizeRepositoryFile, } from "../lib/long-task-paths.js";
 import { canonicalJson } from "../lib/strict-codec.js";
 export async function designResource(args) {
@@ -12,6 +13,10 @@ export async function designResource(args) {
         await bundle(rest);
         return;
     }
+    if (subcommand === "recovery") {
+        await designResourceRecoveryCommand(rest);
+        return;
+    }
     if (subcommand !== "preflight")
         throw new Error(`Unknown design-resource subcommand: ${subcommand}`);
     const json = rest.includes("--json");
@@ -95,5 +100,19 @@ function help() {
          --max-handoff-bytes <bytes> [--json]
                        Validate manifest-backed one-target handoffs and
                        atomically publish the complete target set; the
-                       output parent directory must already exist`);
+                       output parent directory must already exist
+  recovery create <session> --input <state.json> [--json]
+                       Create one explicit ignored task-local checkpoint
+  recovery update <session> --input <state.json> --expected-sha256 <sha256> [--json]
+                       CAS-replace one existing task-local checkpoint
+  recovery inspect <session> [--json]
+                       Revalidate Base and derive replay/CAS state
+  recovery preview <session> [--json]
+                       Show the frozen exact writeback patch without writing
+  recovery apply <session> --audit <audit.json> [--json]
+                       CAS-apply and reread only after fresh balanced audit
+  recovery reconcile <session> --audit <audit.json> [--json]
+                       Read-only reconciliation for a no-writeback checkpoint
+  recovery remove <session> --expected-sha256 <sha256> [--json]
+                       Remove only the digest-matched helper-owned checkpoint`);
 }

package/dist/commands/index.js

@@ -55,7 +55,7 @@ export function help() {
                        Enforce touched handwritten source file modularity
   validate-harness     Run validate-context and validate-code-modularity
   design-resource <subcommand>
-                       Validate a selected design-resource implementation handoff
+                       Validate handoffs or operate explicit DRA recovery
   long-task <subcommand>
                        Manage one Canonical Delivery Contract in the current workspace
   delivery-set <subcommand>

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

@@ -90,7 +90,7 @@ function printCompileResult(compiled, previous, preserveProgress, revisionPropos
             ? projectAuthorityRevisionDecision(revisionProposal)
             : null,
         next_action: firstAuthorityLock
-            ? "End this turn now. Do not implement, edit files, build, or test. After the user handles the model change in the host, wait for [continue]. Harness cannot observe or verify the model change."
+            ? "End this turn now. Do not implement, edit files, build, or test. After the user handles the model change in the host, ask them to reply exactly: model checkpoint cleared, continue. This is package-managed prompt guidance; Harness cannot observe the next host message or verify the model change."
             : authorityChanged
                 ? "Run status or resume, then continue rolling implementation or repair under the adopted Authority Revision."
                 : "Continue rolling implementation or repair under the active Authority.",
@@ -158,7 +158,7 @@ function executionModelCheckpoint(firstAuthorityLock) {
         required: true,
         phase: "post_authority_lock_pre_implementation",
         action: "change_model_in_host_then_continue",
-        resume_token: "continue",
+        resume_token: "model checkpoint cleared, continue",
         turn_boundary: "end_current_turn",
         blocked_until_resume: [
             "product_implementation",
@@ -168,8 +168,8 @@ function executionModelCheckpoint(firstAuthorityLock) {
         ],
         model_change_owner: "host_or_user",
         model_change_observable_by_harness: false,
-        generic_continue_satisfies: true,
-        message: "Authority Lock created. End the current turn before product implementation, file edits, builds, or tests. After handling the model change, send [continue]. Harness cannot observe or verify the model change.",
+        generic_continue_satisfies: false,
+        message: "Authority Lock created. End the current turn before product implementation, file edits, builds, or tests. After handling the model change, reply exactly: model checkpoint cleared, continue. This is package-managed prompt guidance; Harness cannot observe the next host message or verify the model change.",
     };
 }
 function message(error) {

package/dist/lib/design-resource-reconciliation-codec.d.ts

@@ -0,0 +1,2 @@
+import type { DesignResourceReconciliationAudit } from "./design-resource-reconciliation-types.js";
+export declare function parseDesignResourceReconciliationAudit(content: string): DesignResourceReconciliationAudit;

package/dist/lib/design-resource-reconciliation-codec.js

@@ -0,0 +1,174 @@
+import { DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA } from "./design-resource-recovery-schema.js";
+import { arrayOf, digest, literal, object, oneOf, optionalArrayOf, parseStrictJsonObject, stringSet, text, } from "./design-resource-recovery-codec-primitives.js";
+import { parseAuthorityIdentity, parseDecisionAuthority, } from "./design-resource-recovery-shape.js";
+import { parseDesignResourceFinalDisposition } from "./design-resource-recovery-final-disposition-shape.js";
+const ORIGINS = [
+    "user-direct",
+    "necessary-derived",
+    "repository-evidence-backed",
+    "provider-suggested",
+];
+const STATUSES = ["accepted", "rejected", "unresolved"];
+const SEMANTIC_KINDS = [
+    "exact-visual",
+    "product",
+    "business",
+    "permission",
+    "data",
+    "algorithm",
+    "commercial",
+    "safety-security",
+    "technical",
+];
+export function parseDesignResourceReconciliationAudit(content) {
+    const row = object(parseStrictJsonObject(content, "reconciliation_audit"), "reconciliation_audit", [
+        "schema_version",
+        "session_id",
+        "base_raw_byte_digest",
+        "design_authority",
+        "provider_run",
+        "resource_identities",
+        "accepted_delta_ids",
+        "rejected_delta_ids",
+        "unresolved_delta_ids",
+        "changed_keys",
+        "explicitly_unchanged",
+        "requirements_to_resource",
+        "resource_to_requirements",
+        "unexpected_blast_radius",
+        "inactive_delta_leakage",
+    ], ["writeback_target_raw_byte_digest"]);
+    literal(row.schema_version, DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA, "reconciliation_audit.schema_version");
+    return {
+        schema_version: DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA,
+        session_id: text(row.session_id, "reconciliation_audit.session_id"),
+        base_raw_byte_digest: digest(row.base_raw_byte_digest, "reconciliation_audit.base_raw_byte_digest"),
+        design_authority: parseAuthorityIdentity(row.design_authority, "reconciliation_audit.design_authority"),
+        provider_run: parseProviderRun(row.provider_run),
+        resource_identities: optionalArrayOf(row.resource_identities, "reconciliation_audit.resource_identities", parseResourceIdentity),
+        ...(row.writeback_target_raw_byte_digest === undefined
+            ? {}
+            : {
+                writeback_target_raw_byte_digest: digest(row.writeback_target_raw_byte_digest, "reconciliation_audit.writeback_target_raw_byte_digest"),
+            }),
+        accepted_delta_ids: stringSet(row.accepted_delta_ids, "reconciliation_audit.accepted_delta_ids", { allowEmpty: true }),
+        rejected_delta_ids: stringSet(row.rejected_delta_ids, "reconciliation_audit.rejected_delta_ids", { allowEmpty: true }),
+        unresolved_delta_ids: stringSet(row.unresolved_delta_ids, "reconciliation_audit.unresolved_delta_ids", { allowEmpty: true }),
+        changed_keys: stringSet(row.changed_keys, "reconciliation_audit.changed_keys", { allowEmpty: true }),
+        explicitly_unchanged: optionalArrayOf(row.explicitly_unchanged, "reconciliation_audit.explicitly_unchanged", parseUnchanged),
+        requirements_to_resource: optionalArrayOf(row.requirements_to_resource, "reconciliation_audit.requirements_to_resource", parseRequirementFinding),
+        resource_to_requirements: optionalArrayOf(row.resource_to_requirements, "reconciliation_audit.resource_to_requirements", parseResourceFinding),
+        unexpected_blast_radius: optionalArrayOf(row.unexpected_blast_radius, "reconciliation_audit.unexpected_blast_radius", parseBlastFinding),
+        inactive_delta_leakage: optionalArrayOf(row.inactive_delta_leakage, "reconciliation_audit.inactive_delta_leakage", parseLeakage),
+    };
+}
+function parseProviderRun(value) {
+    const row = object(value, "reconciliation_audit.provider_run", [
+        "key",
+        "locator",
+        "immutable_identity",
+    ]);
+    return {
+        key: text(row.key, "provider_run.key"),
+        locator: text(row.locator, "provider_run.locator"),
+        immutable_identity: text(row.immutable_identity, "provider_run.immutable_identity"),
+    };
+}
+function parseResourceIdentity(value, label) {
+    const row = object(value, label, ["key", "raw_byte_digest"]);
+    return {
+        key: text(row.key, `${label}.key`),
+        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
+    };
+}
+function parseUnchanged(value, label) {
+    const row = object(value, label, [
+        "key",
+        "verdict",
+        "resource_refs",
+        "condition_refs",
+        "basis_source_refs",
+    ]);
+    return {
+        key: text(row.key, `${label}.key`),
+        verdict: oneOf(row.verdict, ["preserved", "changed", "unresolved"], `${label}.verdict`),
+        resource_refs: stringSet(row.resource_refs, `${label}.resource_refs`),
+        condition_refs: stringSet(row.condition_refs, `${label}.condition_refs`),
+        basis_source_refs: stringSet(row.basis_source_refs, `${label}.basis_source_refs`),
+    };
+}
+function parseRequirementFinding(value, label) {
+    const row = object(value, label, [
+        "key",
+        "verdict",
+        "delta_ids",
+        "resource_refs",
+        "condition_refs",
+    ]);
+    return {
+        key: text(row.key, `${label}.key`),
+        verdict: oneOf(row.verdict, ["covered", "missing", "distorted", "unsupported", "unresolved"], `${label}.verdict`),
+        delta_ids: stringSet(row.delta_ids, `${label}.delta_ids`),
+        resource_refs: stringSet(row.resource_refs, `${label}.resource_refs`),
+        condition_refs: stringSet(row.condition_refs, `${label}.condition_refs`),
+    };
+}
+function parseResourceFinding(value, label) {
+    const row = object(value, label, [
+        "key",
+        "resource_ref",
+        "status",
+        "semantic_kind",
+        "delta_ids",
+        "condition_refs",
+        "requirement_bindings",
+    ]);
+    return {
+        key: text(row.key, `${label}.key`),
+        resource_ref: text(row.resource_ref, `${label}.resource_ref`),
+        status: oneOf(row.status, STATUSES, `${label}.status`),
+        semantic_kind: oneOf(row.semantic_kind, SEMANTIC_KINDS, `${label}.semantic_kind`),
+        delta_ids: stringSet(row.delta_ids, `${label}.delta_ids`),
+        condition_refs: stringSet(row.condition_refs, `${label}.condition_refs`),
+        requirement_bindings: arrayOf(row.requirement_bindings, `${label}.requirement_bindings`, parseRequirementBinding),
+    };
+}
+function parseRequirementBinding(value, label) {
+    const row = object(value, label, [
+        "binding_id",
+        "requirement_key",
+        "delta_id",
+        "origin",
+        "decision_authority",
+        "source_refs",
+        "final_disposition",
+    ]);
+    return {
+        binding_id: text(row.binding_id, `${label}.binding_id`),
+        requirement_key: text(row.requirement_key, `${label}.requirement_key`),
+        delta_id: text(row.delta_id, `${label}.delta_id`),
+        origin: oneOf(row.origin, ORIGINS, `${label}.origin`),
+        decision_authority: parseDecisionAuthority(row.decision_authority, `${label}.decision_authority`),
+        source_refs: stringSet(row.source_refs, `${label}.source_refs`, {
+            allowEmpty: true,
+        }),
+        final_disposition: parseDesignResourceFinalDisposition(row.final_disposition, `${label}.final_disposition`),
+    };
+}
+function parseBlastFinding(value, label) {
+    const row = object(value, label, ["key", "verdict"]);
+    return {
+        key: text(row.key, `${label}.key`),
+        verdict: oneOf(row.verdict, ["expected", "unexpected", "unresolved"], `${label}.verdict`),
+    };
+}
+function parseLeakage(value, label) {
+    const row = object(value, label, ["delta_id", "inactive_reason", "leaked"]);
+    if (typeof row.leaked !== "boolean")
+        throw new Error(`design_resource_recovery_invalid:${label}.leaked:boolean_required`);
+    return {
+        delta_id: text(row.delta_id, `${label}.delta_id`),
+        inactive_reason: oneOf(row.inactive_reason, ["rejected", "unresolved", "superseded"], `${label}.inactive_reason`),
+        leaked: row.leaked,
+    };
+}

package/dist/lib/design-resource-reconciliation-types.d.ts

@@ -0,0 +1,62 @@
+import { DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA } from "./design-resource-recovery-schema.js";
+import type { DesignResourceAuthorityIdentity, DesignResourceDecisionAuthority, DesignResourceDecisionOrigin, DesignResourceDecisionStatus, DesignResourceFinalDisposition, DesignResourceProviderIdentity, DesignResourceSemanticKind } from "./design-resource-recovery-types.js";
+export interface DesignResourceReconciliationAudit {
+    schema_version: typeof DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA;
+    session_id: string;
+    base_raw_byte_digest: string;
+    design_authority: DesignResourceAuthorityIdentity;
+    provider_run: DesignResourceProviderIdentity;
+    resource_identities: Array<{
+        key: string;
+        raw_byte_digest: string;
+    }>;
+    writeback_target_raw_byte_digest?: string;
+    accepted_delta_ids: string[];
+    rejected_delta_ids: string[];
+    unresolved_delta_ids: string[];
+    changed_keys: string[];
+    explicitly_unchanged: Array<{
+        key: string;
+        verdict: "preserved" | "changed" | "unresolved";
+        resource_refs: string[];
+        condition_refs: string[];
+        basis_source_refs: string[];
+    }>;
+    requirements_to_resource: Array<{
+        key: string;
+        verdict: "covered" | "missing" | "distorted" | "unsupported" | "unresolved";
+        delta_ids: string[];
+        resource_refs: string[];
+        condition_refs: string[];
+    }>;
+    resource_to_requirements: Array<{
+        key: string;
+        resource_ref: string;
+        status: DesignResourceDecisionStatus;
+        semantic_kind: DesignResourceSemanticKind;
+        delta_ids: string[];
+        condition_refs: string[];
+        requirement_bindings: Array<{
+            binding_id: string;
+            requirement_key: string;
+            delta_id: string;
+            origin: DesignResourceDecisionOrigin;
+            decision_authority: DesignResourceDecisionAuthority;
+            source_refs: string[];
+            final_disposition: DesignResourceFinalDisposition;
+        }>;
+    }>;
+    unexpected_blast_radius: Array<{
+        key: string;
+        verdict: "expected" | "unexpected" | "unresolved";
+    }>;
+    inactive_delta_leakage: Array<{
+        delta_id: string;
+        inactive_reason: "rejected" | "unresolved" | "superseded";
+        leaked: boolean;
+    }>;
+}
+export interface DesignResourceReconciliationResult {
+    status: "reconciliation-balanced" | "blocked";
+    findings: string[];
+}

package/dist/lib/design-resource-reconciliation-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/design-resource-reconciliation.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceRecoveryCheckpoint } from "./design-resource-recovery-types.js";
+import type { DesignResourceReconciliationAudit, DesignResourceReconciliationResult } from "./design-resource-reconciliation-types.js";
+export declare function reconcileDesignResourceWriteback(checkpoint: DesignResourceRecoveryCheckpoint, audit: DesignResourceReconciliationAudit): DesignResourceReconciliationResult;