project-tiny-context-harness 0.8.10 → 0.8.12

package/dist/lib/design-resource-v1-capacity-header.js

@@ -0,0 +1,231 @@
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+import { DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY } from "./design-resource-symbolic-fact-policy.js";
+const V1_SCHEMA = "design-resource-observable-fact-manifest-v1";
+export const DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE = "regenerate_as=design-resource-handoff-v2:fact_model=symbolic_rules_v2";
+export function parseDesignResourceV1CapacityHeader(prefix) {
+    try {
+        const reader = new BoundedJsonReader(prefix);
+        const header = reader.readRootHeader();
+        if (header.first_key !== "schema_version")
+            invalid("v1_manifest_capacity_header_order_invalid", `first_key=${header.first_key ?? "missing"}:required=schema_version`);
+        if (header.schema_version !== V1_SCHEMA)
+            invalid("v1_manifest_capacity_header_schema_invalid", `schema_version=${String(header.schema_version)}`);
+        if (!header.generation)
+            invalid("v1_manifest_capacity_header_missing_or_late", `prefix_limit=${DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY.v1_capacity.capacity_header_prefix_max_bytes}:${DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE}`);
+        const collections = objectValue(header.generation, "v1_manifest_capacity_header_generation_invalid").collections;
+        if (!Array.isArray(collections))
+            invalid("v1_manifest_capacity_header_collections_invalid", "not_array");
+        const collectionCounts = new Map();
+        for (const value of collections) {
+            const collection = objectValue(value, "v1_manifest_capacity_header_collection_invalid");
+            if (typeof collection.name !== "string" || !collection.name)
+                invalid("v1_manifest_capacity_header_collection_name_invalid", "");
+            if (typeof collection.expected_count !== "number" ||
+                !Number.isSafeInteger(collection.expected_count) ||
+                collection.expected_count < 0)
+                invalid("v1_manifest_capacity_header_expected_count_invalid", collection.name);
+            if (collectionCounts.has(collection.name))
+                invalid("v1_manifest_capacity_header_collection_duplicate", collection.name);
+            collectionCounts.set(collection.name, collection.expected_count);
+        }
+        return {
+            schema_version: V1_SCHEMA,
+            collection_counts: collectionCounts,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message.startsWith("design_resource_handoff_invalid:"))
+            throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        invalid("v1_manifest_capacity_header_missing_or_late", `prefix_limit=${DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY.v1_capacity.capacity_header_prefix_max_bytes}:reason=${message}:${DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE}`);
+    }
+}
+class BoundedJsonReader {
+    input;
+    offset = 0;
+    depth = 0;
+    constructor(input) {
+        this.input = input;
+    }
+    readRootHeader() {
+        this.whitespace();
+        this.character("{");
+        const result = {
+            first_key: null,
+            schema_version: undefined,
+            generation: undefined,
+        };
+        this.whitespace();
+        if (this.peek() === "}")
+            throw new Error("root_empty");
+        for (;;) {
+            const key = this.string();
+            result.first_key ??= key;
+            this.whitespace();
+            this.character(":");
+            this.whitespace();
+            const value = this.value();
+            if (key === "schema_version")
+                result.schema_version = value;
+            if (key === "generation") {
+                result.generation = value;
+                return result;
+            }
+            this.whitespace();
+            const delimiter = this.peek();
+            if (delimiter === "}")
+                return result;
+            this.character(",");
+            this.whitespace();
+        }
+    }
+    value() {
+        if (++this.depth > 64)
+            throw new Error("depth_limit");
+        try {
+            const next = this.peek();
+            if (next === '"')
+                return this.string();
+            if (next === "{")
+                return this.object();
+            if (next === "[")
+                return this.array();
+            if (next === "t")
+                return this.literal("true", true);
+            if (next === "f")
+                return this.literal("false", false);
+            if (next === "n")
+                return this.literal("null", null);
+            return this.number();
+        }
+        finally {
+            this.depth -= 1;
+        }
+    }
+    object() {
+        const value = {};
+        this.character("{");
+        this.whitespace();
+        if (this.peek() === "}") {
+            this.offset += 1;
+            return value;
+        }
+        for (;;) {
+            const key = this.string();
+            if (Object.hasOwn(value, key))
+                throw new Error(`duplicate_key:${key}`);
+            this.whitespace();
+            this.character(":");
+            this.whitespace();
+            value[key] = this.value();
+            this.whitespace();
+            if (this.peek() === "}") {
+                this.offset += 1;
+                return value;
+            }
+            this.character(",");
+            this.whitespace();
+        }
+    }
+    array() {
+        const value = [];
+        this.character("[");
+        this.whitespace();
+        if (this.peek() === "]") {
+            this.offset += 1;
+            return value;
+        }
+        for (;;) {
+            value.push(this.value());
+            this.whitespace();
+            if (this.peek() === "]") {
+                this.offset += 1;
+                return value;
+            }
+            this.character(",");
+            this.whitespace();
+        }
+    }
+    string() {
+        this.character('"');
+        let value = "";
+        for (;;) {
+            if (this.offset >= this.input.length)
+                throw new Error("prefix_ended");
+            const character = this.input[this.offset++];
+            if (character === '"')
+                return value;
+            if (character === "\\") {
+                if (this.offset >= this.input.length)
+                    throw new Error("prefix_ended");
+                const escaped = this.input[this.offset++];
+                const simple = {
+                    '"': '"',
+                    "\\": "\\",
+                    "/": "/",
+                    b: "\b",
+                    f: "\f",
+                    n: "\n",
+                    r: "\r",
+                    t: "\t",
+                };
+                if (escaped in simple)
+                    value += simple[escaped];
+                else if (escaped === "u") {
+                    const hex = this.input.slice(this.offset, this.offset + 4);
+                    if (!/^[0-9a-fA-F]{4}$/u.test(hex))
+                        throw new Error("unicode_escape_invalid");
+                    value += String.fromCharCode(Number.parseInt(hex, 16));
+                    this.offset += 4;
+                }
+                else
+                    throw new Error("escape_invalid");
+            }
+            else {
+                if (character.charCodeAt(0) < 0x20)
+                    throw new Error("string_control_character");
+                value += character;
+            }
+        }
+    }
+    number() {
+        const remaining = this.input.slice(this.offset);
+        const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(remaining);
+        if (!match)
+            throw new Error("number_invalid");
+        this.offset += match[0].length;
+        const value = Number(match[0]);
+        if (!Number.isFinite(value))
+            throw new Error("number_non_finite");
+        return value;
+    }
+    literal(token, value) {
+        if (this.input.slice(this.offset, this.offset + token.length) !== token)
+            throw new Error(`literal_invalid:${token}`);
+        this.offset += token.length;
+        return value;
+    }
+    whitespace() {
+        while (/\s/u.test(this.input[this.offset] ?? ""))
+            this.offset += 1;
+    }
+    character(expected) {
+        if (this.input[this.offset] !== expected)
+            throw new Error(`expected:${expected}:at=${this.offset}`);
+        this.offset += 1;
+    }
+    peek() {
+        if (this.offset >= this.input.length)
+            throw new Error("prefix_ended");
+        return this.input[this.offset];
+    }
+}
+function objectValue(value, code) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        invalid(code, "not_object");
+    return value;
+}
+function invalid(code, detail) {
+    invalidDesignResourceHandoff(code, detail);
+}

package/dist/lib/design-resource-v1-capacity.d.ts

@@ -0,0 +1,5 @@
+import { type DesignResourceV1CapacityHeader } from "./design-resource-v1-capacity-header.js";
+export { parseDesignResourceV1CapacityHeader } from "./design-resource-v1-capacity-header.js";
+export type { DesignResourceV1CapacityHeader } from "./design-resource-v1-capacity-header.js";
+export declare function assertDesignResourceV1HandoffCapacity(file: string): Promise<void>;
+export declare function assertDesignResourceV1ManifestCapacity(file: string): Promise<DesignResourceV1CapacityHeader>;

package/dist/lib/design-resource-v1-capacity.js

@@ -0,0 +1,45 @@
+import { open, stat } from "node:fs/promises";
+import { invalidDesignResourceHandoff } from "./design-resource-handoff-validation-primitives.js";
+import { DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY } from "./design-resource-symbolic-fact-policy.js";
+import { DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE, parseDesignResourceV1CapacityHeader, } from "./design-resource-v1-capacity-header.js";
+export { parseDesignResourceV1CapacityHeader } from "./design-resource-v1-capacity-header.js";
+export async function assertDesignResourceV1HandoffCapacity(file) {
+    const bytes = (await stat(file)).size;
+    const limit = DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY.v1_capacity.embedded_handoff_max_bytes;
+    if (bytes > limit)
+        invalid("v1_handoff_capacity_exceeded", `bytes=${bytes}:limit=${limit}:${DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE}`);
+}
+export async function assertDesignResourceV1ManifestCapacity(file) {
+    const bytes = (await stat(file)).size;
+    const policy = DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY.v1_capacity;
+    if (bytes > policy.canonical_manifest_max_bytes)
+        invalid("v1_manifest_capacity_exceeded", `bytes=${bytes}:limit=${policy.canonical_manifest_max_bytes}:${DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE}`);
+    const prefixBytes = Math.min(bytes, policy.capacity_header_prefix_max_bytes);
+    const buffer = Buffer.alloc(prefixBytes);
+    const handle = await open(file, "r");
+    try {
+        let offset = 0;
+        while (offset < prefixBytes) {
+            const result = await handle.read(buffer, offset, prefixBytes - offset, offset);
+            if (result.bytesRead === 0)
+                break;
+            offset += result.bytesRead;
+        }
+        if (offset !== prefixBytes)
+            invalid("v1_manifest_capacity_header_read_incomplete", `bytes_read=${offset}:expected=${prefixBytes}`);
+    }
+    finally {
+        await handle.close();
+    }
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+    const header = parseDesignResourceV1CapacityHeader(text);
+    const expectedFactCells = header.collection_counts.get("fact_cells");
+    if (expectedFactCells === undefined)
+        invalid("v1_manifest_capacity_header_fact_cells_missing", DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE);
+    if (expectedFactCells > policy.expected_fact_cells_max)
+        invalid("v1_fact_cell_capacity_exceeded", `expected_count=${expectedFactCells}:limit=${policy.expected_fact_cells_max}:${DESIGN_RESOURCE_V1_REGENERATION_GUIDANCE}`);
+    return header;
+}
+function invalid(code, detail) {
+    invalidDesignResourceHandoff(code, detail);
+}

package/dist/lib/init.js

@@ -25,6 +25,7 @@ export async function runInit(projectRoot, options) {
     await createDesignMd(projectRoot, report);
     const syncReport = await runSync(projectRoot);
     report.push(`sync changed=${syncReport.changed.length} skipped=${syncReport.skipped.length} blocked=${syncReport.blocked.length}`);
+    report.push(...(syncReport.notices ?? []));
     report.push(options.adopt ? "adopt mode complete" : "init complete");
     return report;
 }

package/dist/lib/long-task-activation-validation.js

@@ -66,7 +66,7 @@ export async function validateContractForActivation(options) {
         const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
         if (!executionTarget)
             continue;
-        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets, [], []), null, check.key);
+        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets, [], [], context?.files ?? []), null, check.key);
         if (frozen)
             globalChecks.push(frozen);
     }
@@ -77,7 +77,7 @@ export async function validateContractForActivation(options) {
             const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
             if (!executionTarget)
                 continue;
-            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key), semanticFactClosure?.expectations_by_check.get(check.key) ?? []), outcome.key, check.key);
+            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key), semanticFactClosure?.expectations_by_check.get(check.key) ?? [], context?.files ?? []), outcome.key, check.key);
             if (frozen)
                 checks.push(frozen);
         }

package/dist/lib/long-task-authority-policy.d.ts

@@ -161,6 +161,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
     };
     readonly design_target: {
         key: "identity";
+        fact_model: "semantic_user_review";
         interpretation: "semantic_user_review";
         source_paths: "scope";
         condition_keys: "semantic_user_review";
@@ -168,6 +169,8 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         conformance_check_ref: "proof_additive";
         conformance_assertion_ref: "proof_additive";
         verification_method_bindings: "proof_additive";
+        symbolic_method_bindings: "proof_additive";
+        symbolic_certificate_binding: "proof_additive";
         actual_artifact_path: "output_requirement";
         comparison_artifact_path: "output_requirement";
     };

package/dist/lib/long-task-authority-policy.js

@@ -144,6 +144,7 @@ const SURFACE_BINDING_AUTHORITY_POLICY = {
 };
 const DESIGN_TARGET_AUTHORITY_POLICY = {
     key: "identity",
+    fact_model: "semantic_user_review",
     interpretation: "semantic_user_review",
     source_paths: "scope",
     condition_keys: "semantic_user_review",
@@ -151,6 +152,8 @@ const DESIGN_TARGET_AUTHORITY_POLICY = {
     conformance_check_ref: "proof_additive",
     conformance_assertion_ref: "proof_additive",
     verification_method_bindings: "proof_additive",
+    symbolic_method_bindings: "proof_additive",
+    symbolic_certificate_binding: "proof_additive",
     actual_artifact_path: "output_requirement",
     comparison_artifact_path: "output_requirement",
 };

package/dist/lib/long-task-codex-agent-profile.d.ts

@@ -0,0 +1,42 @@
+import { type Stats } from "node:fs";
+import type { SyncReport } from "./sync-engine.js";
+export declare const LONG_TASK_CODEX_AGENT_PROFILE_RELATIVE_PATH = ".codex/agents/long-task-implementation.toml";
+export declare const LONG_TASK_CODEX_AGENT_PROFILE_MANAGED_MARKER = "# ty-context:managed:long-task-implementation-worker";
+export interface LongTaskCodexAgentProfile {
+    name: "long_task_implementation";
+    description: string;
+    developer_instructions: string;
+    model: string;
+    model_reasoning_effort: string;
+    agents: {
+        enabled: false;
+    };
+}
+export type LongTaskCodexAgentProfileValidation = {
+    valid: true;
+    profile: LongTaskCodexAgentProfile;
+} | {
+    valid: false;
+    errors: string[];
+};
+export interface LongTaskCodexAgentProfileFileOperations {
+    lstat(target: string): Promise<Stats>;
+    realpath(target: string): Promise<string>;
+    readFile(target: string, encoding: "utf8"): Promise<string>;
+    mkdir(target: string, options: {
+        recursive: true;
+    }): Promise<unknown>;
+    writeFile(target: string, content: string, options: {
+        flag: "wx";
+    }): Promise<void>;
+    rename(source: string, destination: string): Promise<void>;
+    rm(target: string, options: {
+        force: true;
+    }): Promise<void>;
+    randomId(): string;
+}
+export declare function parseAndValidateLongTaskCodexAgentProfile(content: string): LongTaskCodexAgentProfileValidation;
+export declare function syncLongTaskCodexAgentProfile(projectRoot: string, resolvedHarnessRoot: string, enabled: boolean, report: SyncReport, fileOperations?: Partial<LongTaskCodexAgentProfileFileOperations>): Promise<void>;
+export declare function longTaskCodexAgentProfileBootstrapPaths(projectRoot: string, resolvedHarnessRoot: string, enabled: boolean, fileOperations?: Partial<LongTaskCodexAgentProfileFileOperations>): Promise<string[]>;
+export declare function isManagedLongTaskCodexAgentProfile(content: string): boolean;
+export declare function atomicWriteLongTaskCodexAgentProfile(destination: string, content: string, operations?: LongTaskCodexAgentProfileFileOperations, beforeRename?: () => Promise<void>): Promise<void>;

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

@@ -0,0 +1,276 @@
+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);
+}