project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/commands/design-resource.js

@@ -1,132 +0,0 @@
-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";
-import { designAuthorityDeltaCommand } from "./design-authority-delta.js";
-export async function designResource(args) {
-    const [subcommand = "help", ...rest] = args;
-    if (subcommand === "help") {
-        help();
-        return;
-    }
-    if (subcommand === "bundle") {
-        await bundle(rest);
-        return;
-    }
-    if (subcommand === "recovery") {
-        await designResourceRecoveryCommand(rest);
-        return;
-    }
-    if (subcommand === "authority-delta") {
-        await designAuthorityDeltaCommand(rest);
-        return;
-    }
-    if (subcommand !== "preflight")
-        throw new Error(`Unknown design-resource subcommand: ${subcommand}`);
-    const json = rest.includes("--json");
-    const positional = rest.filter((item) => item !== "--json");
-    if (positional.length !== 1)
-        throw new Error("usage: ty-context design-resource preflight <handoff.md> [--json]");
-    const handoffPath = normalizeRepositoryFile(positional[0], "design_resource_handoff");
-    const result = await preflightDesignResourceHandoff(process.cwd(), handoffPath);
-    if (json) {
-        process.stdout.write(canonicalJson(result));
-        return;
-    }
-    console.log(`Design resource handoff preflight valid: ${result.handoff_path}`);
-    console.log("Input closure: valid");
-    console.log(`Scope: ${result.handoff.scope.key}`);
-    console.log(`Targets: ${result.handoff.targets.map((item) => item.key).join(", ")}`);
-    console.log(`Technical feasibility inputs: ${result.technical_feasibility_identities.length}`);
-    console.log(`Technical feasibility cells: ${result.technical_feasibility_identities.reduce((total, item) => total + item.component_family_cells, 0)}`);
-    console.log(`Technical feasibility blockers: ${result.technical_feasibility_identities.reduce((total, item) => total + item.blockers, 0)}`);
-    console.log(`Limitations: ${result.limitations.length ? result.limitations.join("; ") : "none"}`);
-    console.log("Production conformance: not evaluated");
-    if ("metrics" in result) {
-        console.log(`Coverage: ${result.manifest.subjects.length} subjects x ${result.manifest.properties.length} atomic properties (${result.rule_projections.length} symbolic Rules)`);
-        console.log(`Symbolic: ${result.metrics.semantic_obligations} semantic obligations, ${result.metrics.certificate_obligations} certificates, ${result.metrics.canonical_dag_nodes} DAG nodes, ${result.metrics.canonical_bytes} bytes`);
-        console.log(`Acceptance blockers: ${result.manifest.acceptance_blockers.length}`);
-    }
-    else {
-        console.log(`Coverage: ${result.counts.subjects} subjects x 8 dimensions (${result.counts.coverage} grouped rows)`);
-        console.log(`Acceptance blockers: ${result.counts.acceptance_blockers}`);
-    }
-}
-async function bundle(args) {
-    const positional = [];
-    const manifests = [];
-    let maxHandoffBytes = null;
-    let json = false;
-    for (let index = 0; index < args.length; index += 1) {
-        const item = args[index];
-        if (item === "--json") {
-            json = true;
-            continue;
-        }
-        if (item === "--manifest") {
-            const value = args[index + 1];
-            if (!value)
-                throw new Error("--manifest requires a path");
-            manifests.push(normalizeRepositoryFile(value, "design_resource_bundle_manifest"));
-            index += 1;
-            continue;
-        }
-        if (item === "--max-handoff-bytes") {
-            const value = args[index + 1];
-            if (!value)
-                throw new Error("--max-handoff-bytes requires an integer");
-            maxHandoffBytes = Number(value);
-            index += 1;
-            continue;
-        }
-        if (item.startsWith("--"))
-            throw new Error(`Unknown design-resource bundle option: ${item}`);
-        positional.push(item);
-    }
-    if (positional.length !== 2 ||
-        manifests.length === 0 ||
-        maxHandoffBytes === null)
-        throw new Error("usage: ty-context design-resource bundle <draft-dir> <new-output-dir> --manifest <facts.json> [--manifest <facts.json> ...] --max-handoff-bytes <bytes> [--json]");
-    const result = await publishDesignResourceHandoffBundle({
-        repository: process.cwd(),
-        draft_directory: normalizeRepositoryCwd(positional[0], "design_resource_bundle_draft_directory"),
-        output_directory: normalizeRepositoryCwd(positional[1], "design_resource_bundle_output_directory"),
-        manifest_paths: manifests,
-        max_handoff_bytes: maxHandoffBytes,
-    });
-    if (json) {
-        process.stdout.write(canonicalJson(result));
-        return;
-    }
-    console.log(`Design resource Source bundle published: ${result.output_directory}`);
-    console.log("Production readiness: not evaluated");
-    console.log(`Handoffs: ${result.handoffs.length}`);
-    console.log(`Targets: ${result.handoffs.map((item) => item.target_key).join(", ")}`);
-}
-function help() {
-    console.log(`ty-context design-resource commands:
-  preflight <handoff.md> [--json]
-                       Validate one selected implementation handoff
-  bundle <draft-dir> <new-output-dir> --manifest <facts.json> [...]
-         --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
-  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
-  authority-delta validate <assessment.json> [--json]
-                       Validate one read-only, non-adopting Authority assessment`);
-}

package/dist/commands/disable.d.ts

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

package/dist/commands/disable.js

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

package/dist/commands/enable.d.ts

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

package/dist/commands/enable.js

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

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

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

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

@@ -1,234 +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]
-    completion_authority: machine_only
-  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
-        - {fact_ref: replace.architecture.boundary, claim_ref: semantic_fact.replace.architecture.boundary, 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
-        - proof_ref: replace.architecture.boundary.runtime
-          fact_ref: replace.architecture.boundary
-          method: exact_value
-          proof_surface: runtime_behavior
-          evidence_capabilities: [semantic_fact]
-          authority: machine
-          check_ref: replace-check
-          assertion_ref: replace-architecture-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-architecture-semantic-fact
-              criterion: The exact Source-indexed architecture Fact passes its frozen comparison on the current target.
-              claims: [semantic_fact.replace.architecture.boundary]
-              applicability_ref: root-success
-              observation: semantic_fact_replace_architecture_boundary
-              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, semantic_fact.replace.architecture.boundary]
-          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, replace-architecture-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>;