project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,216 +0,0 @@
-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
-semantic_fact_manifest: {key: replace-semantic-facts, source_path: plans/replace-me.md, sha256: "1111111111111111111111111111111111111111111111111111111111111111"}
-task:
-  id: replace-me
-  title: Replace me
-  goal: Describe the complete observable delivery goal.
-  target_profile:
-    key: replace-target
-    description: The declared product target is usable from its root entrypoint.
-    required_state: target_profile_usable
-    required_target_refs: [replace-runtime]
-  execution_targets:
-    - key: replace-runtime
-      description: The product runtime used by the acceptance oracle.
-      role: product
-      runtime_family: process
-      root_entrypoint: tests/replace-oracle.mjs
-      capabilities: [process-runtime, cold-start, production-root]
-  source_paths: [plans/replace-me.md]
-  context_refs: [project_context/areas/replace-me.md]
-  context_snapshot_mode: full
-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]
-  - key: replace-architecture
-    source_ref: plans/replace-me.md#replace-architecture
-    statement: Preserve the declared owner, dependency direction, verifier boundary and architecture conformance.
-    disposition:
-      type: claim
-      refs: [replace-outcome.obligation.architecture]
-stages:
-  - key: delivery
-    title: Delivery
-    depends_on: []
-    gate_outcome: replace-outcome
-risk:
-  facts: {}
-global:
-  applicability: []
-outcomes:
-  - key: replace-outcome
-    title: Replace outcome
-    stage: delivery
-    applicability:
-      - key: root-success
-        target_ref: replace-runtime
-        journey_role: success
-        dimensions: [{key: delivery-state, value: ready}]
-        given_refs: [source-ready]
-        when_refs: [inspect-result]
-    semantic_fact_bindings:
-      manifest_ref: replace-semantic-facts
-      facts:
-        - fact_ref: replace.result.observable
-          claim_ref: semantic_fact.replace.result.observable
-          applicability_ref: root-success
-      proofs:
-        - proof_ref: replace.result.observable.runtime
-          fact_ref: replace.result.observable
-          method: exact_value
-          proof_surface: runtime_behavior
-          evidence_capabilities: [semantic_fact]
-          authority: machine
-          check_ref: replace-check
-          assertion_ref: replace-semantic-fact
-    product:
-      observable_result: Describe what a user or system can observe.
-      result_applicability_refs: [root-success]
-      success_path_required: true
-      degradation_path_required: false
-      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]
-          applicability_refs: [root-success]
-      control_relation_closure:
-        state: not_applicable
-        statement: This Outcome declares no user-visible Controls.
-        applicability_refs: [root-success]
-    technical:
-      obligations:
-        - key: architecture
-          statement: Preserve the declared owner, dependency direction, verifier boundary and architecture conformance.
-          required_proof_surfaces: [runtime_behavior]
-          applicability_refs: [root-success]
-      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
-          journey_roles: [success, stage_gate]
-          execution_target: {target_ref: replace-runtime, entrypoint: root}
-          scenario:
-            given: [{key: source-ready, statement: The planned source carrier is available.}]
-            when: [{key: inspect-result, statement: Inspect the product result through the declared runtime.}]
-          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]
-          artifact_globs: [artifacts/replace-semantic-fact.json]
-          positive_assertions:
-            - key: replace-result
-              criterion: The declared outcome is observable.
-              claims: [result]
-              applicability_ref: root-success
-              observation: result
-              evidence_capabilities: [state_delta, target_runtime]
-              operator: equals
-              expected: true
-            - key: replace-semantic-fact
-              criterion: The exact Source-indexed semantic Fact passes its frozen comparison on the current target.
-              claims: [semantic_fact.replace.result.observable]
-              applicability_ref: root-success
-              observation: semantic_fact_replace_result_observable
-              evidence_capabilities: [semantic_fact]
-              operator: equals
-              expected: true
-            - key: replace-requirement
-              criterion: The atomic Source requirement is observable.
-              claims: [requirement.replace-requirement]
-              applicability_ref: root-success
-              observation: requirement_result
-              evidence_capabilities: [state_delta, target_runtime]
-              operator: equals
-              expected: true
-            - key: replace-architecture
-              criterion: The declared architecture obligation remains conformant.
-              claims: [obligation.architecture]
-              applicability_ref: root-success
-              observation: architecture_result
-              evidence_capabilities: [state_delta, target_runtime]
-              operator: equals
-              expected: true
-            - key: replace-liveness
-              criterion: The declared target remains live under semantic mutation.
-              claims: []
-              observation: target_live
-              evidence_capabilities: [target_runtime]
-              operator: equals
-              expected: true
-          negative_assertions:
-            - key: replace-relations-na
-              criterion: Cross-Control relations remain inapplicable when no Controls are declared.
-              claims: [control_relation_closure]
-              applicability_ref: root-success
-              observation: relations_applicable
-              evidence_capabilities: [state_delta, target_runtime]
-              operator: equals
-              expected: false
-      counterfactual_controls:
-        - key: replace-semantic-carrier
-          binding_key: replace-carrier
-          claims: [result, requirement.replace-requirement, obligation.architecture, semantic_fact.replace.result.observable]
-          check_key: replace-check
-          mutation:
-            type: replace_text
-            path: src/replace-me.ts
-            match: IMPLEMENTED_STATE
-            replacement: SEMANTIC_FAILURE_STATE
-          expected_assertion_failures: [replace-result, replace-requirement, replace-architecture, replace-semantic-fact]
-          preserved_assertions: [replace-liveness]
-        - key: replace-relation-applicability
-          binding_key: replace-carrier
-          claims: [control_relation_closure]
-          check_key: replace-check
-          mutation:
-            type: replace_text
-            path: src/replace-me.ts
-            match: NO_CROSS_CONTROL_RELATIONS
-            replacement: CROSS_CONTROL_RELATIONS_APPLY
-          expected_assertion_failures: [replace-relations-na]
-          preserved_assertions: [replace-liveness]
-`;
-}

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

@@ -1,4 +0,0 @@
-export declare function option(args: string[], name: string): string | undefined;
-export declare function flag(args: string[], name: string): boolean;
-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

@@ -1,26 +0,0 @@
-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 flag(args, name) {
-    const count = args.filter((value) => value === name).length;
-    if (count > 1)
-        throw new Error(`duplicate option: ${name}`);
-    return count === 1;
-}
-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-explain.d.ts

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

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

@@ -1,52 +0,0 @@
-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-revision.d.ts

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

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

@@ -1,177 +0,0 @@
-import path from "node:path";
-import { diagnoseAuthorityRevision } from "../lib/long-task-authority-revision-diagnosis.js";
-import { authorityRevisionDecisionNextAction } from "../lib/long-task-authority-revision-brief.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);
-    printCompileResult(compiled, previous, preserveProgress, revisionCapture.proposal);
-}
-function printCompileResult(compiled, previous, preserveProgress, revisionProposal) {
-    const firstAuthorityLock = previous === null;
-    const authorityChanged = previous !== null &&
-        previous.compiled_identity !== compiled.compiled_identity;
-    console.log(JSON.stringify({
-        status: "compiled",
-        lifecycle_event: firstAuthorityLock
-            ? "authority_locked"
-            : authorityChanged
-                ? "authority_revision_adopted"
-                : "authority_recompiled_unchanged",
-        delivery_completed_by_this_event: false,
-        native_goal_effect: "none",
-        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: revisionProposal
-            ? 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, 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.",
-        execution_model_checkpoint: executionModelCheckpoint(firstAuthorityLock),
-    }));
-}
-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");
-    const decision = projectAuthorityRevisionDecision(pending);
-    console.log(JSON.stringify({
-        status: "authority_revision_pending",
-        acceptance_authorized: false,
-        delivery_completed_by_this_event: false,
-        native_goal_effect: "none",
-        active_compiled_identity: previous?.compiled_identity ?? null,
-        pending_authority_revision: decision,
-        next_action: authorityRevisionDecisionNextAction(decision),
-    }));
-}
-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,
-        delivery_completed_by_this_event: false,
-        native_goal_effect: "none",
-        next_action: "Run compile --revise to atomically adopt the approved revision, then return to rolling implementation or repair.",
-    }));
-}
-function executionModelCheckpoint(firstAuthorityLock) {
-    if (!firstAuthorityLock)
-        return { required: false };
-    return {
-        required: true,
-        phase: "post_authority_lock_pre_implementation",
-        action: "change_model_in_host_then_continue",
-        resume_token: "model checkpoint cleared, continue",
-        turn_boundary: "end_current_turn",
-        blocked_until_resume: [
-            "product_implementation",
-            "file_edits",
-            "build",
-            "test_execution",
-        ],
-        model_change_owner: "host_or_user",
-        model_change_observable_by_harness: false,
-        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) {
-    return error instanceof Error ? error.message : String(error);
-}

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

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

package/dist/commands/long-task.js

@@ -1,143 +0,0 @@
-import path from "node:path";
-import { runDeliveryFinalGate } from "../lib/long-task-final-v2.js";
-import { closeDeliveryTask, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "../lib/long-task-status-v2.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 { flag, option, rejectOptions, rejectUnknown, } from "./long-task-command-args.js";
-import { explainLongTask } from "./long-task-explain.js";
-import { handleLongTaskRevisionCommand } from "./long-task-revision.js";
-import { previewVerificationExecution } from "../lib/long-task-verification-preview.js";
-export async function longTask(args) {
-    const subcommand = args[0] ?? "help";
-    if (subcommand === "help")
-        return help();
-    const workdirArgument = args[1];
-    if (!workdirArgument)
-        throw new Error(`${subcommand} requires <workdir>`);
-    const workdir = path.resolve(process.cwd(), workdirArgument);
-    if (subcommand === "init") {
-        rejectUnknown(args.slice(2), []);
-        await initializeLongTask(workdir);
-        console.log(JSON.stringify({ status: "initialized", workdir }));
-        return;
-    }
-    if (subcommand === "preflight") {
-        rejectUnknown(args.slice(2), []);
-        return preflightLongTask(workdir);
-    }
-    if (await handleLongTaskRevisionCommand(subcommand, workdir, args.slice(2)))
-        return;
-    if (subcommand === "explain") {
-        rejectUnknown(args.slice(2), []);
-        return explainLongTask(workdir);
-    }
-    if (subcommand === "verify")
-        return verify(workdir, args.slice(2));
-    if (subcommand === "status") {
-        rejectUnknown(args.slice(2), []);
-        console.log(JSON.stringify(await readDeliveryStatus(workdir), null, 2));
-        return;
-    }
-    if (subcommand === "resume") {
-        rejectUnknown(args.slice(2), []);
-        console.log(JSON.stringify(await resumeDeliveryTask(workdir), null, 2));
-        return;
-    }
-    if (subcommand === "doctor") {
-        rejectUnknown(args.slice(2), []);
-        console.log(JSON.stringify(await doctorDeliveryTask(workdir), null, 2));
-        return;
-    }
-    if (subcommand === "final-gate")
-        return finalGate(workdir, args.slice(2));
-    if (subcommand === "stop-check") {
-        const message = option(args.slice(2), "--message") ?? "";
-        rejectOptions(args.slice(2), ["--message"]);
-        const result = await stopCheckDeliveryTask(workdir, message);
-        console.log(JSON.stringify(result));
-        if (!result.continue)
-            process.exitCode = 1;
-        return;
-    }
-    if (subcommand === "close") {
-        rejectUnknown(args.slice(2), []);
-        const result = await closeDeliveryTask(workdir);
-        console.log(JSON.stringify({
-            status: result.status,
-            workdir,
-            workflow_status: result.workflow_status,
-            external_confirmations: result.external_confirmations,
-            target_profile: result.target_profile,
-            target_state: result.target_state,
-            stage_results: result.stage_results,
-            acceptance_scope: result.acceptance_scope,
-            closed_scope: result.closed_scope,
-            native_goal_effect: result.native_goal_effect,
-        }));
-        return;
-    }
-    if (subcommand === "abandon") {
-        const forceCorruptState = args.length === 3 && args[2] === "--force-corrupt-state";
-        if (args.length > 2 && !forceCorruptState)
-            throw new Error(`Unknown or injected arguments: ${args.slice(2).join(" ")}`);
-        const root = await repositoryRoot(process.cwd());
-        if (forceCorruptState)
-            await forceClearCorruptActiveState(root, workdir);
-        else
-            await abandonLongTaskState(root, workdir);
-        console.log(JSON.stringify({
-            status: "abandoned",
-            workdir,
-            force_corrupt_state: forceCorruptState,
-        }));
-        return;
-    }
-    throw new Error(`Unknown long-task subcommand: ${subcommand}`);
-}
-async function verify(workdir, args) {
-    const explain = flag(args, "--explain");
-    const optionArgs = args.filter((value) => value !== "--explain");
-    const outcome = option(optionArgs, "--outcome");
-    const check = option(optionArgs, "--check");
-    rejectOptions(optionArgs, ["--outcome", "--check"]);
-    if (explain) {
-        console.log(JSON.stringify(await previewVerificationExecution(workdir, { outcome, check })));
-        return;
-    }
-    const result = await verifyDeliveryContract(workdir, { outcome, check });
-    console.log(JSON.stringify(result));
-    if (result.findings.length)
-        process.exitCode = 1;
-}
-async function finalGate(workdir, args) {
-    rejectUnknown(args, []);
-    const result = await runDeliveryFinalGate(workdir);
-    console.log(JSON.stringify({
-        ...result,
-        acceptance_scope: "declared_machine_authority",
-        native_goal_effect: "none",
-    }));
-    if (result.workflow_status !== "machine_accepted" &&
-        result.workflow_status !== "machine_accepted_external_pending")
-        process.exitCode = 1;
-}
-function help() {
-    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>] [--explain]
-  status <workdir>
-  resume <workdir>
-  doctor <workdir>
-  final-gate <workdir>
-  stop-check <workdir> [--message <text>]
-  close <workdir>
-  abandon <workdir> [--force-corrupt-state]`);
-}

package/dist/lib/compact-authoring-support.d.ts

@@ -1,22 +0,0 @@
-export declare function compactCommonFields<T extends Record<string, unknown>>(rows: T[], excluded: string[]): Record<string, unknown>;
-export declare function compactWithoutFields<T extends Record<string, unknown>>(value: T, fields: string[]): Record<string, unknown>;
-export declare function compactAuthoringTable<T extends object>(input: T[], excludedDefaults?: string[]): {
-    defaults: Record<string, unknown>;
-    columns: string[];
-    rows: unknown[][];
-};
-export declare function applyCompactAuthoringSelectors(base: Record<string, unknown>): {
-    value: Record<string, unknown>;
-    selectors: Array<{
-        key: string;
-        members: string[];
-    }>;
-};
-export declare function compactCapacityBudget(name: string, measured: number): number;
-export declare function compactDeterministicTemplates(records: Record<string, unknown>[], excludedFields: string[], keyPrefix: string): {
-    templates: Array<{
-        key: string;
-        value: Record<string, unknown>;
-    }>;
-    template_refs: string[];
-};