project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-codex-agent-profile.js

@@ -1,276 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { parse as parseToml } from "smol-toml";
-import { packageAssetPath } from "./paths.js";
-export const LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH = ".codex/agents/long-task-implementation.toml";
-export const LONG_TASK_CODEX_AGENT_PROFILE_MANAGED_MARKER = "# ty-context:managed:long-task-implementation-worker";
-const ASSET_SEGMENTS = ["agents", "long-task-implementation.toml"];
-const PROFILE_ROOT_FIELDS = new Set([
-    "name",
-    "description",
-    "developer_instructions",
-    "model",
-    "model_reasoning_effort",
-    "agents",
-]);
-const PROFILE_AGENT_FIELDS = new Set(["enabled"]);
-const DEFAULT_FILE_OPERATIONS = {
-    lstat: (target) => fs.lstat(target),
-    realpath: (target) => fs.realpath(target),
-    readFile: (target, encoding) => fs.readFile(target, encoding),
-    mkdir: (target, options) => fs.mkdir(target, options),
-    writeFile: (target, content, options) => fs.writeFile(target, content, options),
-    rename: (source, destination) => fs.rename(source, destination),
-    rm: (target, options) => fs.rm(target, options),
-    randomId: () => randomUUID(),
-};
-export function parseAndValidateLongTaskCodexAgentProfile(content) {
-    const errors = [];
-    const normalized = content.replace(/\r\n/gu, "\n");
-    if (!hasManagedMarker(normalized))
-        errors.push("managed_marker_missing_or_invalid");
-    let decoded;
-    try {
-        decoded = parseToml(normalized);
-    }
-    catch {
-        return { valid: false, errors: [...errors, "toml_invalid"] };
-    }
-    const root = record(decoded);
-    if (!root)
-        return { valid: false, errors: [...errors, "profile_not_table"] };
-    for (const key of Object.keys(root).sort())
-        if (!PROFILE_ROOT_FIELDS.has(key))
-            errors.push(`unsupported_field:${key}`);
-    if (root.name !== "long_task_implementation")
-        errors.push("name_must_be_long_task_implementation");
-    if (!nonEmptyString(root.description))
-        errors.push("description_required");
-    if (!nonEmptyString(root.developer_instructions))
-        errors.push("developer_instructions_required");
-    if (!staticString(root.model))
-        errors.push("model_must_be_static_nonempty");
-    if (!staticString(root.model_reasoning_effort))
-        errors.push("model_reasoning_effort_must_be_static_nonempty");
-    const agents = record(root.agents);
-    if (!agents)
-        errors.push("agents_table_required");
-    else {
-        for (const key of Object.keys(agents).sort())
-            if (!PROFILE_AGENT_FIELDS.has(key))
-                errors.push(`unsupported_agents_field:${key}`);
-        if (agents.enabled !== false)
-            errors.push("agents_enabled_must_be_false");
-    }
-    if (errors.length)
-        return { valid: false, errors };
-    return {
-        valid: true,
-        profile: {
-            name: "long_task_implementation",
-            description: root.description,
-            developer_instructions: root.developer_instructions,
-            model: root.model,
-            model_reasoning_effort: root.model_reasoning_effort,
-            agents: { enabled: false },
-        },
-    };
-}
-export async function syncLongTaskCodexAgentProfile(projectRoot, resolvedHarnessRoot, enabled, report, fileOperations = {}) {
-    if (resolvedHarnessRoot !== ".codex")
-        return;
-    const operations = operationsWith(fileOperations);
-    const asset = await readValidPackageProfile(operations);
-    if (!asset.valid) {
-        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: optional package asset ${asset.reason}`);
-        return;
-    }
-    const destination = path.join(projectRoot, LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH);
-    if (!enabled) {
-        await removeManagedProfile(projectRoot, destination, report, operations);
-        return;
-    }
-    const inspected = await inspectProfileDestination(projectRoot, destination, operations);
-    if (inspected.kind === "conflict") {
-        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: optional adapter conflict (${inspected.reason})`);
-        return;
-    }
-    let previous = null;
-    if (inspected.kind === "regular") {
-        previous = await operations.readFile(destination, "utf8");
-        if (!hasManagedMarker(previous)) {
-            report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: user-owned (managed marker absent)`);
-            return;
-        }
-        if (previous === asset.content) {
-            report.skipped.push(LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH);
-            return;
-        }
-    }
-    try {
-        await atomicWriteLongTaskCodexAgentProfile(destination, asset.content, operations, async () => {
-            const current = await inspectProfileDestination(projectRoot, destination, operations);
-            if (previous === null && current.kind !== "absent")
-                throw new Error("destination_changed_before_rename");
-            if (previous !== null) {
-                if (current.kind !== "regular")
-                    throw new Error("destination_changed_before_rename");
-                if ((await operations.readFile(destination, "utf8")) !== previous)
-                    throw new Error("destination_content_changed_before_rename");
-            }
-        });
-        report.changed.push(LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH);
-    }
-    catch (error) {
-        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: optional adapter write failed (${message(error)})`);
-    }
-}
-export async function longTaskCodexAgentProfileBootstrapPaths(projectRoot, resolvedHarnessRoot, enabled, fileOperations = {}) {
-    if (!enabled || resolvedHarnessRoot !== ".codex")
-        return [];
-    const operations = operationsWith(fileOperations);
-    const asset = await readValidPackageProfile(operations);
-    if (!asset.valid)
-        return [];
-    const destination = path.join(projectRoot, LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH);
-    const inspected = await inspectProfileDestination(projectRoot, destination, operations);
-    if (inspected.kind !== "regular")
-        return [];
-    const existing = await operations.readFile(destination, "utf8");
-    return existing === asset.content &&
-        parseAndValidateLongTaskCodexAgentProfile(existing).valid
-        ? [LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH]
-        : [];
-}
-export function isManagedLongTaskCodexAgentProfile(content) {
-    return parseAndValidateLongTaskCodexAgentProfile(content).valid;
-}
-export async function atomicWriteLongTaskCodexAgentProfile(destination, content, operations = DEFAULT_FILE_OPERATIONS, beforeRename = async () => undefined) {
-    await operations.mkdir(path.dirname(destination), { recursive: true });
-    const temp = `${destination}.tmp-${process.pid}-${operations.randomId()}`;
-    let renamed = false;
-    try {
-        await operations.writeFile(temp, content, { flag: "wx" });
-        await beforeRename();
-        await operations.rename(temp, destination);
-        renamed = true;
-    }
-    finally {
-        if (!renamed)
-            await operations.rm(temp, { force: true }).catch(() => { });
-    }
-}
-async function removeManagedProfile(projectRoot, destination, report, operations) {
-    const inspected = await inspectProfileDestination(projectRoot, destination, operations);
-    if (inspected.kind === "absent")
-        return;
-    if (inspected.kind === "conflict") {
-        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: optional adapter conflict (${inspected.reason})`);
-        return;
-    }
-    const existing = await operations.readFile(destination, "utf8");
-    if (!hasManagedMarker(existing)) {
-        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: user-owned (managed marker absent)`);
-        return;
-    }
-    const current = await inspectProfileDestination(projectRoot, destination, operations);
-    if (current.kind !== "regular" ||
-        (await operations.readFile(destination, "utf8")) !== existing) {
-        report.skipped.push(`${LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH}: optional adapter changed before disable`);
-        return;
-    }
-    await operations.rm(destination, { force: true });
-    report.changed.push(LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH);
-}
-async function readValidPackageProfile(operations) {
-    const source = packageAssetPath(...ASSET_SEGMENTS);
-    const sourceStat = await lstatOrNull(source, operations);
-    if (!sourceStat)
-        return { valid: false, reason: "unavailable" };
-    if (sourceStat.isSymbolicLink() || !sourceStat.isFile())
-        return { valid: false, reason: "is not a regular file" };
-    const content = await operations.readFile(source, "utf8");
-    const validation = parseAndValidateLongTaskCodexAgentProfile(content);
-    if (!validation.valid)
-        return {
-            valid: false,
-            reason: `is invalid (${validation.errors.join(",")})`,
-        };
-    return { valid: true, content };
-}
-async function inspectProfileDestination(projectRoot, destination, operations) {
-    const lexicalRoot = path.resolve(projectRoot);
-    const canonicalRoot = await operations.realpath(lexicalRoot);
-    let cursor = lexicalRoot;
-    for (const segment of [".codex", "agents"]) {
-        cursor = path.join(cursor, segment);
-        const status = await lstatOrNull(cursor, operations);
-        if (!status)
-            continue;
-        if (status.isSymbolicLink())
-            return { kind: "conflict", reason: `parent_symlink:${segment}` };
-        if (!status.isDirectory())
-            return { kind: "conflict", reason: `parent_not_directory:${segment}` };
-        if (!inside(canonicalRoot, await operations.realpath(cursor)))
-            return {
-                kind: "conflict",
-                reason: `parent_outside_repository:${segment}`,
-            };
-    }
-    const status = await lstatOrNull(destination, operations);
-    if (!status)
-        return { kind: "absent" };
-    if (status.isSymbolicLink())
-        return { kind: "conflict", reason: "destination_symlink" };
-    if (!status.isFile())
-        return { kind: "conflict", reason: "destination_not_regular_file" };
-    if (!inside(canonicalRoot, await operations.realpath(destination)))
-        return { kind: "conflict", reason: "destination_outside_repository" };
-    return { kind: "regular" };
-}
-function operationsWith(overrides) {
-    return { ...DEFAULT_FILE_OPERATIONS, ...overrides };
-}
-async function lstatOrNull(target, operations) {
-    try {
-        return await operations.lstat(target);
-    }
-    catch (error) {
-        if (code(error) === "ENOENT")
-            return null;
-        throw error;
-    }
-}
-function inside(root, candidate) {
-    const relative = path.relative(root, candidate);
-    return (relative === "" ||
-        (!relative.startsWith(`..${path.sep}`) &&
-            relative !== ".." &&
-            !path.isAbsolute(relative)));
-}
-function record(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function nonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function staticString(value) {
-    return (nonEmptyString(value) &&
-        value === value.trim() &&
-        !/[\r\n$%{}]/u.test(value));
-}
-function hasManagedMarker(content) {
-    return (content.replace(/\r\n/gu, "\n").split("\n", 1)[0] ===
-        LONG_TASK_CODEX_AGENT_PROFILE_MANAGED_MARKER);
-}
-function code(error) {
-    return typeof error === "object" && error !== null && "code" in error
-        ? String(error.code)
-        : "";
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/lib/long-task-command-process.d.ts

@@ -1,9 +0,0 @@
-export interface SpawnedCommandExecution {
-    exit_code: number;
-    stdout: Buffer;
-    stderr: Buffer;
-    pid: number;
-    started_at: string;
-    completed_at: string;
-}
-export declare function spawnCommandOnce(executable: string, argv: string[], cwd: string, timeoutMs: number, environment: NodeJS.ProcessEnv, containProcessTree: boolean): Promise<SpawnedCommandExecution>;

package/dist/lib/long-task-command-process.js

@@ -1,175 +0,0 @@
-import { spawn } from "node:child_process";
-import { createProcessTreeObserver, } from "./long-task-process-tree.js";
-const OUTPUT_LIMIT = 2 * 1024 * 1024;
-const PROCESS_TREE_GRACE_MS = 1_000;
-export function spawnCommandOnce(executable, argv, cwd, timeoutMs, environment, containProcessTree) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(executable, argv, {
-            cwd,
-            shell: false,
-            windowsHide: true,
-            env: environment,
-            detached: containProcessTree && process.platform !== "win32",
-        });
-        const pid = child.pid ?? -1;
-        const processTree = containProcessTree && pid > 0 ? createProcessTreeObserver(pid) : null;
-        const state = {
-            child,
-            pid,
-            processTree,
-            treeMonitor: Promise.resolve(),
-            treeMonitorError: null,
-            stdout: [],
-            stderr: [],
-            size: 0,
-            settled: false,
-            terminationReason: null,
-            terminationTask: null,
-            timer: null,
-            forceTimer: null,
-            abandonTimer: null,
-            startedAt: new Date().toISOString(),
-            resolve,
-            reject,
-        };
-        if (processTree)
-            state.treeMonitor = processTree.wait().catch((error) => {
-                state.treeMonitorError = error;
-            });
-        child.stdout.on("data", captureOutput(state, state.stdout));
-        child.stderr.on("data", captureOutput(state, state.stderr));
-        child.on("error", (error) => handleSpawnError(state, error));
-        child.on("close", (code) => void handleClose(state, code));
-        state.timer = setTimeout(() => terminateExecution(state, "command_timeout"), timeoutMs);
-        if (pid < 0)
-            terminateExecution(state, "command_spawn_pid_unavailable");
-    });
-}
-function captureOutput(state, target) {
-    return (chunk) => {
-        state.size += chunk.length;
-        if (state.size > OUTPUT_LIMIT) {
-            terminateExecution(state, "command_output_limit_exceeded");
-            return;
-        }
-        target.push(Buffer.from(chunk));
-    };
-}
-function handleSpawnError(state, error) {
-    if (state.settled)
-        return;
-    state.settled = true;
-    state.processTree?.stop();
-    clearExecutionTimers(state);
-    const spawnError = new Error(`command_spawn_error:${message(error)}`);
-    if (!state.processTree) {
-        state.reject(spawnError);
-        return;
-    }
-    void state.processTree
-        .terminate(true)
-        .catch(() => undefined)
-        .finally(() => state.reject(spawnError));
-}
-async function handleClose(state, code) {
-    state.processTree?.stop();
-    clearExecutionTimers(state);
-    if (state.settled)
-        return;
-    state.settled = true;
-    if (state.terminationReason) {
-        await finishBoundedTermination(state);
-        state.reject(state.terminationReason);
-        return;
-    }
-    if (!(await assertTreeClosure(state)))
-        return;
-    state.resolve({
-        exit_code: code ?? -1,
-        stdout: Buffer.concat(state.stdout),
-        stderr: Buffer.concat(state.stderr),
-        pid: state.pid,
-        started_at: state.startedAt,
-        completed_at: new Date().toISOString(),
-    });
-}
-async function finishBoundedTermination(state) {
-    try {
-        await state.terminationTask;
-        await state.treeMonitor;
-        if (state.processTree)
-            await state.processTree.forceQuiescence();
-    }
-    catch {
-        // Preserve the original bounded termination reason after the hard cleanup.
-    }
-}
-async function assertTreeClosure(state) {
-    if (!state.processTree)
-        return true;
-    try {
-        await state.treeMonitor;
-        if (state.treeMonitorError)
-            throw state.treeMonitorError;
-        await state.processTree.assertQuiescent();
-        return true;
-    }
-    catch (error) {
-        await state.processTree.terminate(true).catch(() => undefined);
-        state.reject(error);
-        return false;
-    }
-}
-function terminateExecution(state, reason) {
-    if (state.settled || state.terminationReason)
-        return;
-    state.terminationReason = new Error(reason);
-    state.processTree?.stop();
-    startGracefulTermination(state);
-    state.forceTimer = setTimeout(() => startForcedTermination(state), PROCESS_TREE_GRACE_MS);
-    state.forceTimer.unref();
-    state.abandonTimer = setTimeout(() => abandonExecution(state), PROCESS_TREE_GRACE_MS * 2);
-    state.abandonTimer.unref();
-}
-function startGracefulTermination(state) {
-    if (state.processTree)
-        state.terminationTask = state.processTree
-            .terminate(false)
-            .catch((error) => {
-            state.treeMonitorError ??= error;
-        });
-    else {
-        state.child.kill();
-        state.terminationTask = Promise.resolve();
-    }
-}
-function startForcedTermination(state) {
-    if (state.processTree)
-        state.terminationTask = state.processTree.terminate(true).catch((error) => {
-            state.treeMonitorError ??= error;
-        });
-    else
-        state.child.kill("SIGKILL");
-}
-function abandonExecution(state) {
-    if (state.settled)
-        return;
-    state.settled = true;
-    state.child.stdout.destroy();
-    state.child.stderr.destroy();
-    const cleanup = state.processTree
-        ? state.processTree.forceQuiescence().catch(() => undefined)
-        : Promise.resolve();
-    void cleanup.finally(() => state.reject(state.terminationReason));
-}
-function clearExecutionTimers(state) {
-    if (state.timer)
-        clearTimeout(state.timer);
-    if (state.forceTimer)
-        clearTimeout(state.forceTimer);
-    if (state.abandonTimer)
-        clearTimeout(state.abandonTimer);
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/lib/long-task-compact-authoring-projections.d.ts

@@ -1,12 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { SemanticFactRevisionIdentityV1 } from "./semantic-fact-compact-carrier.js";
-export declare function compactClaimProjection(outcomeRef: string, kind: "requirement" | "obligation" | "forbidden_shortcut" | "non_completing_outcome", row: {
-    key: string;
-    statement: string;
-    applicability_refs: string[];
-    required_proof_surfaces?: string[];
-}, claimsByStatement: Map<string, string>): Record<string, unknown>;
-export declare function compactAssertionProjection(outcomeRef: string, checkRef: string, position: number, assertion: Record<string, unknown>, claimsByStatement: Map<string, string>, facts: Map<string, string>): Record<string, unknown> | null;
-export declare function compactRevisionMap(rows: SemanticFactRevisionIdentityV1[], label: string): Map<string, string>;
-export declare function compactUniqueClaimStatements(claims: DeliveryContractV2["source_claims"]): Map<string, string>;
-export declare function assertSameCompactKeys(left: string[], right: string[], label: string): void;

package/dist/lib/long-task-compact-authoring-projections.js

@@ -1,67 +0,0 @@
-import { canonicalValueJson } from "./strict-codec.js";
-import { compactWithoutFields } from "./compact-authoring-support.js";
-export function compactClaimProjection(outcomeRef, kind, row, claimsByStatement) {
-    const claimKey = claimsByStatement.get(row.statement) ?? null;
-    return {
-        outcome_ref: outcomeRef,
-        projection_kind: kind,
-        projection_key: row.key,
-        claim_key: claimKey,
-        statement: claimKey ? null : row.statement,
-        required_proof_surfaces: row.required_proof_surfaces ?? null,
-        applicability_refs: row.applicability_refs,
-    };
-}
-export function compactAssertionProjection(outcomeRef, checkRef, position, assertion, claimsByStatement, facts) {
-    const criterion = String(assertion.criterion ?? "");
-    const claimRef = claimsByStatement.get(criterion);
-    let criterionKind;
-    let criterionRef;
-    if (claimRef) {
-        criterionKind = "claim_statement";
-        criterionRef = claimRef;
-    }
-    else {
-        const match = /^The current candidate satisfies the exact Source Fact (fact\.[a-z0-9._:-]+)\.$/u.exec(criterion);
-        if (!match || !facts.has(match[1]))
-            return null;
-        criterionKind = "semantic_fact";
-        criterionRef = match[1];
-    }
-    return {
-        outcome_ref: outcomeRef,
-        check_ref: checkRef,
-        position,
-        criterion_kind: criterionKind,
-        criterion_ref: criterionRef,
-        ...compactWithoutFields(assertion, ["criterion"]),
-    };
-}
-export function compactRevisionMap(rows, label) {
-    const result = new Map();
-    for (const row of rows) {
-        if (result.has(row.key))
-            throw new Error(`long_task_compact_authoring_invalid:${label}_revision_duplicate:${row.key}`);
-        result.set(row.key, row.revision_digest);
-    }
-    return result;
-}
-export function compactUniqueClaimStatements(claims) {
-    const result = new Map();
-    const duplicates = new Set();
-    for (const claim of claims) {
-        if (result.has(claim.statement)) {
-            result.delete(claim.statement);
-            duplicates.add(claim.statement);
-        }
-        else if (!duplicates.has(claim.statement))
-            result.set(claim.statement, claim.key);
-    }
-    return result;
-}
-export function assertSameCompactKeys(left, right, label) {
-    const a = [...new Set(left)].sort();
-    const b = [...new Set(right)].sort();
-    if (canonicalValueJson(a) !== canonicalValueJson(b))
-        throw new Error(`long_task_compact_authoring_invalid:${label}:${a.length}:${b.length}`);
-}

package/dist/lib/long-task-compact-authoring.d.ts

@@ -1,3 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { SemanticFactRevisionIdentityV1 } from "./semantic-fact-compact-carrier.js";
-export declare function createLongTaskCompactContract(contractInput: DeliveryContractV2, factRevisions: SemanticFactRevisionIdentityV1[], obligationRevisions: SemanticFactRevisionIdentityV1[]): Record<string, unknown>;