project-tiny-context-harness 0.2.84 → 0.6.0

package/dist/commands/long-task.js

@@ -0,0 +1,226 @@
+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 { 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 { explainLongTask } from "./long-task-explain.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 (subcommand === "compile")
+        return compile(workdir, args.slice(2));
+    if (subcommand === "approve-authority-revision")
+        return approveRevision(workdir, args.slice(2));
+    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,
+        }));
+        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 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");
+    rejectOptions(args, ["--outcome", "--check"]);
+    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));
+    if (result.workflow_status !== "machine_accepted" &&
+        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>
+  abandon <workdir> [--force-corrupt-state]`);
+}

package/dist/commands/package-source.js

@@ -18,7 +18,7 @@ export async function packageSource(args) {
         console.log("package source OK");
         return;
     }
-    console.log(`ty-context package commands:
-  sync-source    Update package canonical assets from this source workspace
+    console.log(`ty-context package commands:
+  sync-source    Update package canonical assets from this source workspace
   check-source   Verify package canonical assets match this source workspace`);
 }

package/dist/commands/upgrade.js

@@ -1,4 +1,4 @@
-import { createUpgradePlan, formatUpgradePlan, hasUpgradePlanWork, updateModeForPlan } from "../lib/migrations.js";
+import { createUpgradePlan, formatUpgradePlan, hasUpgradePlanWork, updateModeForPlan, } from "../lib/migrations.js";
 import { runUpgradeReport } from "../lib/upgrade.js";
 export async function upgrade(args = []) {
     const options = parseArgs(args);
@@ -55,14 +55,14 @@ function parseArgs(args) {
     return options;
 }
 function printHelp() {
-    console.log(`ty-context upgrade:
-  upgrade              Run safe migrations, sync managed assets and doctor
-  upgrade --check      Print the upgrade plan without writing files
-  upgrade --check --json
-                       Print the upgrade plan as JSON
-
-Update modes:
-  sync-only            No migrations are pending
-  upgrade-required     Safe migrations are pending
+    console.log(`ty-context upgrade:
+  upgrade              Run safe migrations, sync managed assets and doctor
+  upgrade --check      Print the upgrade plan without writing files
+  upgrade --check --json
+                       Print the upgrade plan as JSON
+
+Update modes:
+  sync-only            No migrations are pending
+  upgrade-required     Safe migrations are pending
   manual-required      Manual review or blockers are present`);
 }

package/dist/index.d.ts

@@ -1,2 +1,12 @@
 export { commands } from "./commands/index.js";
-export type { HarnessConfig, ManagedFile, SourceMapping } from "./lib/types.js";
+export { compileDeliveryContract, type CompileDeliveryOptionsV2, } from "./lib/long-task-delivery-compiler.js";
+export { DELIVERY_CONTRACT_FILE, parseDeliveryContract, parseDeliveryContractBundle, } from "./lib/long-task-delivery-parser.js";
+export { evaluateContractBoundary } from "./lib/long-task-boundary-check.js";
+export { classifyLongTaskRisk, validateRiskProof, } from "./lib/long-task-risk.js";
+export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
+export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";
+export { closeDeliveryTask, type DeliveryStatusV2, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "./lib/long-task-status-v2.js";
+export { readActiveLongTaskBinding, readCompiledDeliveryContract, readFinalReceipt, } from "./lib/long-task-state.js";
+export type { HarnessConfig, HarnessProfile, ManagedFile, SourceMapping, } from "./lib/types.js";
+export type { CheckExecutionResultV2, CompiledDeliveryContractV2, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, EffectiveRiskLevel, ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, LongTaskRiskFacts, ProofSurface, ProgressRecordV2, RequestedRiskLevel, RunnerType, SourceClaimV2, TargetedVerificationResultV2, } from "./lib/long-task-delivery-types.js";
+export type { BoundaryCheckDecisionV2, BoundaryCheckInputV2, } from "./lib/long-task-boundary-check.js";

package/dist/index.js

@@ -1 +1,9 @@
 export { commands } from "./commands/index.js";
+export { compileDeliveryContract, } from "./lib/long-task-delivery-compiler.js";
+export { DELIVERY_CONTRACT_FILE, parseDeliveryContract, parseDeliveryContractBundle, } from "./lib/long-task-delivery-parser.js";
+export { evaluateContractBoundary } from "./lib/long-task-boundary-check.js";
+export { classifyLongTaskRisk, validateRiskProof, } from "./lib/long-task-risk.js";
+export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
+export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";
+export { closeDeliveryTask, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "./lib/long-task-status-v2.js";
+export { readActiveLongTaskBinding, readCompiledDeliveryContract, readFinalReceipt, } from "./lib/long-task-state.js";

package/dist/lib/config.js

@@ -7,22 +7,31 @@ export function defaultConfig(root) {
     return {
         core: {
             package: CANONICAL_CORE_PACKAGE,
-            schema_version: CURRENT_SCHEMA_VERSION
+            schema_version: CURRENT_SCHEMA_VERSION,
+        },
+        profiles: {
+            enabled: ["core-portable", "workflow-default"],
         },
         modularity: {
             limit: 300,
-            policy: "strict_except_generated"
+            policy: "strict_except_generated",
         },
         managed_files: [
             { path: "AGENTS.md", strategy: "merge-block" },
             { path: "Makefile", strategy: "merge-block" },
             { path: harnessPath(root, "skills"), strategy: "managed" },
-            { path: harnessPath(root, "ty-context-managed", "context_templates"), strategy: "managed" },
-            { path: harnessPath(root, "ty-context-managed", "make", "ty-context.mk"), strategy: "managed" },
+            {
+                path: harnessPath(root, "ty-context-managed", "context_templates"),
+                strategy: "managed",
+            },
+            {
+                path: harnessPath(root, "ty-context-managed", "make", "ty-context.mk"),
+                strategy: "managed",
+            },
             { path: "tools", strategy: "managed" },
-            { path: ".github/workflows/harness.yml", strategy: "create-if-missing" }
+            { path: ".github/workflows/harness.yml", strategy: "create-if-missing" },
         ],
-        never_overwrite: ["project_context/**", "DESIGN.md", "src/**", "tests/**"]
+        never_overwrite: ["project_context/**", "DESIGN.md", "src/**", "tests/**"],
     };
 }
 export async function readConfig(projectRoot) {
@@ -48,10 +57,27 @@ export function normalizeConfig(value, root = ".agent") {
     return {
         core: {
             package: value.core?.package ?? fallback.core.package,
-            schema_version: value.core?.schema_version ?? fallback.core.schema_version
+            schema_version: value.core?.schema_version ?? fallback.core.schema_version,
+        },
+        profiles: {
+            enabled: normalizeProfiles(value.profiles?.enabled),
         },
         modularity: value.modularity,
         managed_files: value.managed_files ?? fallback.managed_files,
-        never_overwrite: value.never_overwrite ?? fallback.never_overwrite
+        never_overwrite: value.never_overwrite ?? fallback.never_overwrite,
     };
 }
+const VALID_PROFILES = new Set([
+    "core-portable",
+    "workflow-default",
+    "long-task",
+]);
+function normalizeProfiles(value) {
+    const source = value ?? ["core-portable", "workflow-default"];
+    const enabled = source.filter((profile) => VALID_PROFILES.has(profile));
+    for (const required of ["core-portable", "workflow-default"]) {
+        if (!enabled.includes(required))
+            enabled.push(required);
+    }
+    return [...new Set(enabled)];
+}

package/dist/lib/context-default-footprint.d.ts

@@ -0,0 +1,16 @@
+import { type ContextManifest } from "./context-manifest-schema.js";
+export declare const DEFAULT_CONTEXT_TOTAL_SOFT_BUDGET_BYTES: number;
+export declare const DEFAULT_CONTEXT_FILE_SOFT_BUDGET_BYTES: number;
+export type DefaultContextSelectionReason = "core" | "default_area" | "default_role" | "default_child";
+export interface DefaultContextFileFootprint {
+    path: string;
+    bytes: number;
+    reasons: DefaultContextSelectionReason[];
+}
+export interface DefaultContextFootprint {
+    files: DefaultContextFileFootprint[];
+    total_bytes: number;
+    duplicate_groups: string[][];
+}
+export declare function inspectDefaultContextFootprint(projectRootInput: string): Promise<DefaultContextFootprint>;
+export declare function selectDefaultContextPaths(manifest: ContextManifest): Map<string, Set<DefaultContextSelectionReason>>;

package/dist/lib/context-default-footprint.js

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile } from "node:fs/promises";
+import path from "node:path";
+import { parseContextManifest, } from "./context-manifest-schema.js";
+export const DEFAULT_CONTEXT_TOTAL_SOFT_BUDGET_BYTES = 64 * 1024;
+export const DEFAULT_CONTEXT_FILE_SOFT_BUDGET_BYTES = 16 * 1024;
+export async function inspectDefaultContextFootprint(projectRootInput) {
+    const projectRoot = path.resolve(projectRootInput);
+    const manifestPath = "project_context/context.toml";
+    const manifestContent = await readFile(path.join(projectRoot, ...manifestPath.split("/")), "utf8");
+    const parsed = parseContextManifest(manifestContent, manifestPath);
+    if (!parsed.manifest || parsed.errors.length > 0) {
+        throw new Error(`context_manifest_invalid:${parsed.errors.join("|")}`);
+    }
+    const selected = selectDefaultContextPaths(parsed.manifest);
+    const files = [];
+    const hashes = new Map();
+    for (const [relativePath, reasons] of [...selected.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const absolutePath = resolveProjectFile(projectRoot, relativePath);
+        const metadata = await lstat(absolutePath);
+        if (metadata.isSymbolicLink()) {
+            throw new Error(`default_context_path_symlink_not_allowed:${relativePath}`);
+        }
+        if (!metadata.isFile()) {
+            throw new Error(`default_context_path_not_file:${relativePath}`);
+        }
+        const content = await readFile(absolutePath);
+        const digest = createHash("sha256").update(content).digest("hex");
+        const group = hashes.get(digest) ?? [];
+        group.push(relativePath);
+        hashes.set(digest, group);
+        files.push({
+            path: relativePath,
+            bytes: content.byteLength,
+            reasons: [...reasons].sort(),
+        });
+    }
+    return {
+        files,
+        total_bytes: files.reduce((total, file) => total + file.bytes, 0),
+        duplicate_groups: [...hashes.values()]
+            .filter((group) => group.length > 1)
+            .map((group) => [...group].sort())
+            .sort(([left], [right]) => left.localeCompare(right)),
+    };
+}
+export function selectDefaultContextPaths(manifest) {
+    const selected = new Map();
+    const add = (value, reason) => {
+        const normalized = normalizeContextPath(value);
+        const reasons = selected.get(normalized) ?? new Set();
+        const changed = !reasons.has(reason);
+        reasons.add(reason);
+        selected.set(normalized, reasons);
+        return changed;
+    };
+    for (const core of [
+        "project_context/context.toml",
+        "project_context/global.md",
+        "project_context/architecture.md",
+    ])
+        add(core, "core");
+    for (const area of manifest.areas) {
+        if (area.default)
+            add(area.context, "default_area");
+    }
+    const children = new Map(manifest.contexts.map((context) => [
+        normalizeContextPath(context.path),
+        context.default_children.map(normalizeContextPath),
+    ]));
+    const queue = [];
+    const queued = new Set();
+    const enqueue = (contextPath) => {
+        if (queued.has(contextPath))
+            return;
+        queued.add(contextPath);
+        queue.push(contextPath);
+    };
+    for (const context of manifest.contexts) {
+        if (context.read_policy !== "default")
+            continue;
+        const normalized = normalizeContextPath(context.path);
+        add(normalized, "default_role");
+        enqueue(normalized);
+    }
+    while (queue.length > 0) {
+        const parent = queue.shift();
+        for (const child of children.get(parent) ?? []) {
+            add(child, "default_child");
+            enqueue(child);
+        }
+    }
+    return selected;
+}
+function resolveProjectFile(projectRoot, relativePath) {
+    const absolutePath = path.resolve(projectRoot, ...normalizeContextPath(relativePath).split("/"));
+    const relative = path.relative(projectRoot, absolutePath);
+    if (relative.startsWith(`..${path.sep}`) ||
+        relative === ".." ||
+        path.isAbsolute(relative)) {
+        throw new Error(`default_context_path_outside_project:${relativePath}`);
+    }
+    return absolutePath;
+}
+function normalizeContextPath(value) {
+    return value.replace(/\\/gu, "/").replace(/^\.\//u, "");
+}