@sireai/optimus 0.1.1

package/dist/task-environment/orchestration/triage-runner.js

@@ -0,0 +1,655 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Codex } from "@openai/codex-sdk";
+import { CodexAuthResolver } from "../../problem-solving-core/codex/codex-auth-resolver.js";
+import { classifyCodexFailureCategory } from "../../problem-solving-core/codex/codex-failure-classifier.js";
+import { renderRuntimeCodexHomeConfig, resolveConfiguredCodexModelProvider, resolveEffectiveCodexModel } from "../../problem-solving-core/codex/codex-provider-profile.js";
+import { OptimusLogger } from "../observability/logger.js";
+import { HarnessRegistry } from "./harness-registry.js";
+class TriageRunnerError extends Error {
+    failureCategory;
+    constructor(message, failureCategory) {
+        super(message);
+        this.name = "TriageRunnerError";
+        this.failureCategory = failureCategory;
+    }
+}
+// TriageRunner owns the resident triage thread and all task admission semantics.
+// Runtime only sees one stable triage interface, while this class handles acceptance-contract loading,
+// resident session reuse, Codex prompting, and task-package materialization.
+export class TriageRunner {
+    config;
+    harnessRegistry;
+    logger;
+    dependencies;
+    initialized = false;
+    harnessContracts = [];
+    harnessDigest = "";
+    residentThreadId;
+    residentThreadRestored = false;
+    initializedAt;
+    constructor(config, dependencies = {}) {
+        this.config = config;
+        this.harnessRegistry = new HarnessRegistry(config);
+        this.logger = new OptimusLogger(config);
+        this.dependencies = dependencies;
+    }
+    // initialize() bootstraps the resident triage worker once at runtime startup.
+    // It either restores a previously initialized thread or creates a new one and injects all ACCEPT contracts.
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.harnessContracts = this.loadHarnessContracts();
+        this.harnessDigest = this.buildHarnessDigest(this.harnessContracts);
+        this.initializedAt = new Date().toISOString();
+        await this.logger.info("optimus.triage.starting", {
+            model: resolveEffectiveCodexModel(this.config),
+            provider: resolveConfiguredCodexModelProvider(this.config),
+            sandboxMode: this.config.codex.sandboxMode,
+            approvalPolicy: this.config.codex.approvalPolicy,
+            taskTypes: this.harnessContracts.map((contract) => contract.taskType)
+        });
+        try {
+            await this.restoreOrInitializeResidentThread();
+            this.initialized = true;
+            await this.logger.info("optimus.triage.ready", this.getStatusSnapshot());
+        }
+        catch (error) {
+            const failureCategory = this.classifyFailure(error);
+            await this.logger.error("optimus.triage.start_failed", {
+                failureCategory,
+                reason: error instanceof Error ? error.message : "Unknown triage startup failure"
+            });
+            throw error;
+        }
+    }
+    // triage() is runtime's only semantic admission API.
+    // It validates minimal event shape and then uses the resident Codex triage thread to classify the event.
+    async triage(event) {
+        const content = event.content.content.trim();
+        const title = event.content.title?.trim() || this.deriveTitle(content);
+        if (!content) {
+            return {
+                decision: "rejected",
+                summary: "Runtime event is missing usable content for triage.",
+                reason: "input_missing",
+                missingInfo: ["content"]
+            };
+        }
+        if (!title) {
+            return {
+                decision: "rejected",
+                summary: "Runtime event is missing a stable title for triage.",
+                reason: "title_missing",
+                missingInfo: ["title"]
+            };
+        }
+        if (event.type === "task.retry_requested" || event.type === "task.cancel_requested") {
+            return {
+                decision: "rejected",
+                summary: `Event ${event.type} is handled directly by runtime without triage packaging.`,
+                reason: "runtime_control_event"
+            };
+        }
+        await this.initialize();
+        const decision = this.materializeDecision(event, title, content, await this.decideWithResidentThread(event, title, content));
+        if (decision.decision === "accepted") {
+            await this.logger.info("triage.accepted", {
+                eventId: event.eventId,
+                taskType: decision.taskType,
+                source: event.content.source,
+                sourceRef: event.content.sourceRef,
+                title: decision.taskPackage.title,
+                ...(this.residentThreadId ? { sdkThreadId: this.residentThreadId } : {})
+            });
+            return decision;
+        }
+        await this.logger.warn("triage.rejected", {
+            eventId: event.eventId,
+            source: event.content.source,
+            reason: decision.reason,
+            summary: decision.summary,
+            missingInfo: decision.missingInfo,
+            ...(this.residentThreadId ? { sdkThreadId: this.residentThreadId } : {})
+        });
+        return decision;
+    }
+    classifyFailure(error) {
+        if (typeof error === "object" && error && "failureCategory" in error) {
+            const category = error.failureCategory;
+            if (category) {
+                return category;
+            }
+        }
+        if (error instanceof Error) {
+            return classifyCodexFailureCategory(error.message);
+        }
+        return "unknown";
+    }
+    // getStatusSnapshot() exposes the resident triage state so doctor/runtime can report whether triage is initialized,
+    // restored from a previous session, and which harness contracts it is currently serving.
+    getStatusSnapshot() {
+        return {
+            ok: this.initialized,
+            startedAt: this.initializedAt,
+            mode: "codex",
+            model: resolveEffectiveCodexModel(this.config),
+            provider: resolveConfiguredCodexModelProvider(this.config),
+            taskTypes: this.harnessContracts.map((contract) => contract.taskType),
+            harnessDigest: this.harnessDigest || undefined,
+            restored: this.residentThreadRestored,
+            threadId: this.residentThreadId,
+            sessionStatePath: this.getSessionStatePath()
+        };
+    }
+    loadHarnessContracts() {
+        return this.harnessRegistry.list().map((definition) => this.readHarnessContract(definition));
+    }
+    // ACCEPT.md is the only source of triage admission rules for a task harness.
+    // Runtime only loads the markdown so the resident triage runner sees the original candidate contract text.
+    readHarnessContract(definition) {
+        const manifest = this.harnessRegistry.getManifest(definition.taskType);
+        const acceptMarkdown = manifest.triageRules
+            .map((file) => readFileSync(join(manifest.harnessDir, file), "utf8").trim())
+            .filter(Boolean)
+            .join("\n\n---\n\n");
+        return {
+            taskType: definition.taskType,
+            acceptMarkdown
+        };
+    }
+    buildHarnessDigest(contracts) {
+        const serialized = contracts
+            .map((contract) => [contract.taskType, contract.acceptMarkdown].join("\n"))
+            .join("\n\n====\n\n");
+        return createHash("sha256").update(serialized).digest("hex");
+    }
+    async restoreOrInitializeResidentThread() {
+        const sessionState = await this.readSessionState();
+        const taskTypes = this.harnessContracts.map((contract) => contract.taskType);
+        if (sessionState &&
+            sessionState.harnessDigest === this.harnessDigest &&
+            this.sameStringArray(sessionState.taskTypes, taskTypes)) {
+            this.residentThreadId = sessionState.threadId;
+            this.residentThreadRestored = true;
+            await this.logger.info("optimus.triage.session_restored", {
+                threadId: sessionState.threadId,
+                taskTypes,
+                harnessDigest: this.harnessDigest
+            });
+            return;
+        }
+        if (sessionState) {
+            await this.logger.info("optimus.triage.session_rebuild_required", {
+                previousThreadId: sessionState.threadId,
+                previousHarnessDigest: sessionState.harnessDigest,
+                currentHarnessDigest: this.harnessDigest,
+                previousTaskTypes: sessionState.taskTypes,
+                currentTaskTypes: taskTypes
+            });
+        }
+        await this.startFreshResidentThread();
+    }
+    // A fresh triage thread receives the full acceptance-contract corpus once.
+    // Later task turns only send the event payload and rely on the resident thread memory to choose the task type or reject.
+    async startFreshResidentThread() {
+        const prompt = this.buildInitializationPrompt();
+        const promptPath = await this.writeTriageArtifact("triage-init-prompt.md", prompt[0]?.text ?? "");
+        await this.logger.debug("optimus.triage.init_prompt", {
+            artifactPath: promptPath,
+            taskTypes: this.harnessContracts.map((contract) => contract.taskType)
+        });
+        try {
+            const result = await this.executeCodexTurn({
+                prompt,
+                outputSchema: this.buildInitializationOutputSchema(),
+                timeoutMs: this.config.runtime.startupTimeoutMs,
+                sandboxMode: this.config.codex.sandboxMode
+            });
+            const responsePath = await this.writeTriageArtifact("triage-init-response.json", result.response);
+            await this.logger.debug("optimus.triage.init_response", {
+                ...(result.sdkThreadId ? { sdkThreadId: result.sdkThreadId } : {}),
+                responsePreview: this.previewResponse(result.response, 3000),
+                responseArtifactPath: responsePath
+            });
+            const parsed = this.parseInitializationResponse(result.response);
+            if (!parsed.ready) {
+                throw new TriageRunnerError(`Triage initialization returned ready=false: ${parsed.summary}`, "schema_error");
+            }
+            if (!result.sdkThreadId) {
+                throw new TriageRunnerError("Triage initialization completed without a persisted thread id.", "environment_error");
+            }
+            this.residentThreadId = result.sdkThreadId;
+            this.residentThreadRestored = false;
+            await this.writeSessionState(this.buildSessionState(result.sdkThreadId, new Date().toISOString()));
+        }
+        catch (error) {
+            this.residentThreadId = undefined;
+            this.residentThreadRestored = false;
+            await this.deleteSessionState();
+            throw error;
+        }
+    }
+    buildInitializationPrompt() {
+        const renderedContracts = this.harnessContracts.map((contract) => [
+            `## TASK HARNESS CANDIDATE: ${contract.taskType}`,
+            contract.acceptMarkdown
+        ].join("\n\n")).join("\n\n---\n\n");
+        return [{
+                type: "text",
+                text: [
+                    "# TRIAGE RUNNER INITIALIZATION",
+                    "You are the resident triage runner for Optimus.",
+                    "Your job is to classify future runtime events into one registered task harness, or reject them with a concrete reason.",
+                    "The task harness candidate list below is the complete set of task types you may choose from.",
+                    "Read and retain each ACCEPT contract exactly as written before handling future events.",
+                    "Never invent a taskType. Only select one taskType from the candidate list below.",
+                    "If no task harness safely accepts the event, reject it.",
+                    "When rejecting for missing information, only use field names explicitly declared by the acceptance contracts.",
+                    "Later event turns will only send event payloads. You must keep using the candidate list loaded in this initialization turn.",
+                    "Return JSON only.",
+                    "",
+                    "# OUTPUT CONTRACT",
+                    JSON.stringify({ ready: true, summary: "triage_initialized", taskTypes: this.harnessContracts.map((contract) => contract.taskType) }, null, 2),
+                    "",
+                    "# TASK HARNESS CANDIDATE LIST",
+                    renderedContracts
+                ].join("\n")
+            }];
+    }
+    buildInitializationOutputSchema() {
+        return {
+            type: "object",
+            additionalProperties: false,
+            required: ["ready", "summary", "taskTypes"],
+            properties: {
+                ready: { type: "boolean" },
+                summary: { type: "string" },
+                taskTypes: {
+                    type: "array",
+                    items: { type: "string" }
+                }
+            }
+        };
+    }
+    parseInitializationResponse(response) {
+        let parsed;
+        try {
+            parsed = JSON.parse(response);
+        }
+        catch (error) {
+            throw new TriageRunnerError(`Triage initialization response was not valid JSON: ${error instanceof Error ? error.message : "unknown parse error"}`, "parse_error");
+        }
+        if (!parsed || typeof parsed !== "object") {
+            throw new TriageRunnerError("Triage initialization response schema mismatch: root is not an object.", "schema_error");
+        }
+        const candidate = parsed;
+        if (typeof candidate.ready !== "boolean" || typeof candidate.summary !== "string" || !Array.isArray(candidate.taskTypes)) {
+            throw new TriageRunnerError("Triage initialization response schema mismatch: ready/summary/taskTypes missing.", "schema_error");
+        }
+        return {
+            ready: candidate.ready,
+            summary: candidate.summary,
+            taskTypes: candidate.taskTypes.filter((item) => typeof item === "string")
+        };
+    }
+    async decideWithResidentThread(event, title, content) {
+        const prompt = this.buildTaskPrompt(event, title, content);
+        try {
+            return await this.executeDecisionTurn(event, prompt);
+        }
+        catch (error) {
+            if (!this.residentThreadId) {
+                throw error;
+            }
+            await this.logger.warn("optimus.triage.resume_failed", {
+                eventId: event.eventId,
+                threadId: this.residentThreadId,
+                failureCategory: this.classifyFailure(error),
+                reason: error instanceof Error ? error.message : "Unknown resident thread failure"
+            });
+            await this.startFreshResidentThread();
+            await this.logger.info("optimus.triage.thread_rebuilt", {
+                eventId: event.eventId,
+                threadId: this.residentThreadId,
+                harnessDigest: this.harnessDigest
+            });
+            return this.executeDecisionTurn(event, prompt);
+        }
+    }
+    buildTaskPrompt(event, title, content) {
+        return [{
+                type: "text",
+                text: [
+                    "# TRIAGE TASK",
+                    "Decide whether this runtime event should be accepted into one registered task harness, or rejected.",
+                    "Use only the acceptance contracts already loaded during initialization.",
+                    "Return JSON only and satisfy the schema exactly.",
+                    "",
+                    "# RUNTIME EVENT",
+                    JSON.stringify({
+                        eventId: event.eventId,
+                        type: event.type,
+                        source: event.content.source,
+                        title,
+                        description: event.content.description ?? "",
+                        content,
+                        repo: event.content.repo,
+                        branch: event.content.branch,
+                        metadata: event.content.metadata ?? {}
+                    }, null, 2),
+                    "",
+                    "# OUTPUT RULES",
+                    "- accepted: include decision=accepted, summary, and taskType.",
+                    "- rejected: include decision=rejected, summary, reason, and optional missingInfo.",
+                    "- reason must be a short machine-readable snake_case string.",
+                    "- missingInfo must only contain field names declared by the acceptance contracts."
+                ].join("\n")
+            }];
+    }
+    async executeDecisionTurn(event, prompt) {
+        const result = await this.executeCodexTurn({
+            prompt,
+            outputSchema: this.buildDecisionOutputSchema(),
+            timeoutMs: this.config.runtime.startupTimeoutMs,
+            sandboxMode: this.config.codex.sandboxMode,
+            ...(this.residentThreadId ? { threadId: this.residentThreadId } : {})
+        });
+        const rawResponsePath = await this.writeTriageArtifact(`${event.eventId}-triage-raw-response.json`, result.response);
+        await this.logger.debug("optimus.triage.raw_response", {
+            eventId: event.eventId,
+            eventType: event.type,
+            ...(result.sdkThreadId ? { sdkThreadId: result.sdkThreadId } : {}),
+            responsePreview: this.previewResponse(result.response, 3000),
+            response: result.response,
+            responseArtifactPath: rawResponsePath
+        });
+        if (result.sdkThreadId && result.sdkThreadId !== this.residentThreadId) {
+            this.residentThreadId = result.sdkThreadId;
+            await this.writeSessionState(this.buildSessionState(result.sdkThreadId, this.initializedAt ?? new Date().toISOString()));
+        }
+        const parsed = this.parseCodexDecision(result.response);
+        const parsedPath = await this.writeTriageArtifact(`${event.eventId}-triage-parsed-response.json`, JSON.stringify(parsed, null, 2));
+        await this.logger.debug("optimus.triage.parsed_response", {
+            eventId: event.eventId,
+            eventType: event.type,
+            ...(this.residentThreadId ? { sdkThreadId: this.residentThreadId } : {}),
+            decision: parsed.decision,
+            ...(parsed.taskType ? { taskType: parsed.taskType } : {}),
+            parsedResponsePath: parsedPath
+        });
+        return parsed;
+    }
+    buildDecisionOutputSchema() {
+        return {
+            type: "object",
+            additionalProperties: false,
+            // The current Codex/Responses schema validator requires root.required to enumerate
+            // every declared property when additionalProperties=false is used.
+            // We still treat taskType/reason/missingInfo as decision-dependent in parseCodexDecision(),
+            // but the wire schema must list them all and allow null so rejected/accepted variants remain valid.
+            required: ["decision", "summary", "taskType", "reason", "missingInfo"],
+            properties: {
+                decision: { type: "string", enum: ["accepted", "rejected"] },
+                summary: { type: "string" },
+                taskType: {
+                    type: ["string", "null"]
+                },
+                reason: {
+                    type: ["string", "null"]
+                },
+                missingInfo: {
+                    type: ["array", "null"],
+                    items: { type: "string" }
+                }
+            }
+        };
+    }
+    parseCodexDecision(response) {
+        let parsed;
+        try {
+            parsed = JSON.parse(response);
+        }
+        catch (error) {
+            throw new TriageRunnerError(`Codex triage response was not valid JSON: ${error instanceof Error ? error.message : "unknown parse error"}`, "parse_error");
+        }
+        if (!parsed || typeof parsed !== "object") {
+            throw new TriageRunnerError("Codex triage response schema mismatch: root is not an object.", "schema_error");
+        }
+        const candidate = parsed;
+        if ((candidate.decision !== "accepted" && candidate.decision !== "rejected") || typeof candidate.summary !== "string" || candidate.summary.trim().length === 0) {
+            throw new TriageRunnerError("Codex triage response schema mismatch: decision/summary missing.", "schema_error");
+        }
+        if (candidate.decision === "accepted") {
+            if (typeof candidate.taskType !== "string" || candidate.taskType.trim().length === 0) {
+                throw new TriageRunnerError("Codex triage accepted the event but omitted taskType.", "schema_error");
+            }
+            if (!this.harnessContracts.some((contract) => contract.taskType === candidate.taskType)) {
+                throw new TriageRunnerError(`Codex triage selected unregistered taskType ${candidate.taskType}.`, "schema_error");
+            }
+            return {
+                decision: "accepted",
+                summary: candidate.summary,
+                taskType: candidate.taskType
+            };
+        }
+        const normalizedMissingInfo = Array.isArray(candidate.missingInfo)
+            ? candidate.missingInfo
+                .filter((item) => typeof item === "string" && item.trim().length > 0)
+                .map((item) => item.trim())
+            : undefined;
+        return {
+            decision: "rejected",
+            summary: candidate.summary,
+            reason: typeof candidate.reason === "string" && candidate.reason.trim().length > 0 ? candidate.reason : "unsupported_problem_type",
+            ...(normalizedMissingInfo && normalizedMissingInfo.length > 0 ? { missingInfo: normalizedMissingInfo } : {})
+        };
+    }
+    // Materialization intentionally keeps Codex output narrow.
+    // The agent only chooses accept/reject and taskType; system code still builds the governed TaskPackage contract.
+    materializeDecision(event, title, content, decision) {
+        if (decision.decision === "rejected") {
+            return {
+                decision: "rejected",
+                summary: decision.summary,
+                reason: decision.reason ?? "unsupported_problem_type",
+                ...(decision.missingInfo && decision.missingInfo.length > 0 ? { missingInfo: decision.missingInfo } : {})
+            };
+        }
+        const matchedContract = this.harnessContracts.find((contract) => contract.taskType === decision.taskType);
+        if (!matchedContract) {
+            throw new TriageRunnerError(`Codex triage selected unsupported taskType ${decision.taskType ?? "<empty>"}.`, "schema_error");
+        }
+        const taskPackage = {
+            taskPackageId: `pkg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            sourceEventId: event.eventId,
+            source: event.content.source,
+            ...(event.content.sourceRef ? { sourceRef: event.content.sourceRef } : {}),
+            ...(this.shouldUseIdempotency(event) ? { idempotencyKey: this.buildIdempotencyKey(title) } : {}),
+            taskType: matchedContract.taskType,
+            title,
+            ...(event.content.repo ? { repo: event.content.repo } : {}),
+            ...(event.content.branch ? { branch: event.content.branch } : {}),
+            input: {
+                description: event.content.description ?? title,
+                content,
+                ...(event.content.metadata ? { metadata: event.content.metadata } : {})
+            },
+            createdAt: new Date().toISOString()
+        };
+        return {
+            decision: "accepted",
+            summary: decision.summary,
+            taskType: matchedContract.taskType,
+            taskPackage
+        };
+    }
+    async executeCodexTurn(input) {
+        const turnExecutor = this.dependencies.runCodexTurn ?? ((payload) => this.runCodexTurn(payload));
+        return turnExecutor(input);
+    }
+    async runCodexTurn(input) {
+        await this.ensureCodexHome();
+        const codex = this.createCodexClient();
+        const thread = input.threadId
+            ? codex.resumeThread(input.threadId, this.buildThreadOptions({
+                workingDirectory: process.cwd(),
+                sandboxMode: input.sandboxMode
+            }))
+            : codex.startThread(this.buildThreadOptions({
+                workingDirectory: process.cwd(),
+                sandboxMode: input.sandboxMode
+            }));
+        const turn = await thread.run(input.prompt, {
+            outputSchema: input.outputSchema,
+            signal: this.createExecutionSignal(undefined, input.timeoutMs)
+        });
+        return {
+            response: turn.finalResponse,
+            ...(thread.id ? { sdkThreadId: thread.id } : {})
+        };
+    }
+    buildThreadOptions(input) {
+        const options = {
+            modelReasoningEffort: this.config.codex.reasoningEffort,
+            workingDirectory: input.workingDirectory,
+            skipGitRepoCheck: true,
+            sandboxMode: input.sandboxMode,
+            approvalPolicy: this.config.codex.approvalPolicy,
+            networkAccessEnabled: this.config.runtime.networkAccessEnabled
+        };
+        const effectiveModel = resolveEffectiveCodexModel(this.config);
+        if (effectiveModel) {
+            options.model = effectiveModel;
+        }
+        return options;
+    }
+    createExecutionSignal(externalSignal, timeoutMs) {
+        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+        if (!externalSignal) {
+            return timeoutSignal;
+        }
+        if (typeof AbortSignal.any === "function") {
+            return AbortSignal.any([externalSignal, timeoutSignal]);
+        }
+        const controller = new AbortController();
+        const forwardAbort = (signal) => {
+            if (signal.aborted) {
+                controller.abort(signal.reason);
+                return;
+            }
+            signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+        };
+        forwardAbort(externalSignal);
+        forwardAbort(timeoutSignal);
+        return controller.signal;
+    }
+    async ensureCodexHome() {
+        // Runtime must always materialize the private CODEX_HOME directory first.
+        // Even when no runtime config.toml is rendered yet, the SDK still receives CODEX_HOME,
+        // and Codex Exec aborts immediately if that relative path does not exist.
+        await mkdir(this.config.codex.homeDir, { recursive: true });
+        const configText = renderRuntimeCodexHomeConfig(this.config);
+        if (!configText) {
+            throw new TriageRunnerError("Unable to render runtime codex-home/config.toml. Check codex.provider and codex.model.", "config_error");
+        }
+        await writeFile(join(this.config.codex.homeDir, "config.toml"), configText, "utf8");
+    }
+    createCodexClient() {
+        const auth = new CodexAuthResolver(this.config).resolve();
+        const env = { ...auth.env };
+        // Keep the operator's HOME untouched and scope only Codex state to the private runtime home.
+        env.CODEX_HOME = this.config.codex.homeDir;
+        const options = { env };
+        if (auth.baseUrl) {
+            options.baseUrl = auth.baseUrl;
+        }
+        if (auth.apiKey) {
+            options.apiKey = auth.apiKey;
+        }
+        return new Codex(options);
+    }
+    async readSessionState() {
+        try {
+            const raw = await readFile(this.getSessionStatePath(), "utf8");
+            const parsed = JSON.parse(raw);
+            if (parsed.runner !== "triage" ||
+                typeof parsed.threadId !== "string" ||
+                typeof parsed.harnessDigest !== "string" ||
+                !Array.isArray(parsed.taskTypes) ||
+                typeof parsed.initializedAt !== "string") {
+                return undefined;
+            }
+            return {
+                runner: "triage",
+                threadId: parsed.threadId,
+                harnessDigest: parsed.harnessDigest,
+                taskTypes: parsed.taskTypes.filter((item) => typeof item === "string"),
+                initializedAt: parsed.initializedAt,
+                ...(typeof parsed.model === "string" ? { model: parsed.model } : {})
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async writeSessionState(state) {
+        await mkdir(this.config.storage.rootDir, { recursive: true });
+        await writeFile(this.getSessionStatePath(), JSON.stringify(state, null, 2), "utf8");
+    }
+    async deleteSessionState() {
+        await rm(this.getSessionStatePath(), { force: true });
+    }
+    buildSessionState(threadId, initializedAt) {
+        const state = {
+            runner: "triage",
+            threadId,
+            harnessDigest: this.harnessDigest,
+            taskTypes: this.harnessContracts.map((contract) => contract.taskType),
+            initializedAt
+        };
+        const model = resolveEffectiveCodexModel(this.config);
+        if (model) {
+            state.model = model;
+        }
+        return state;
+    }
+    getSessionStatePath() {
+        return join(this.config.storage.rootDir, "triage-session.json");
+    }
+    sameStringArray(left, right) {
+        if (left.length !== right.length) {
+            return false;
+        }
+        return left.every((value, index) => value === right[index]);
+    }
+    async writeTriageArtifact(fileName, content) {
+        const artifactDir = join(this.config.storage.rootDir, "artifacts", "triage");
+        await mkdir(artifactDir, { recursive: true });
+        const targetPath = join(artifactDir, fileName);
+        await writeFile(targetPath, content, "utf8");
+        return targetPath;
+    }
+    previewResponse(response, limit = 600) {
+        const normalized = response.replace(/\s+/g, " ").trim();
+        return normalized.length > limit ? `${normalized.slice(0, limit - 3)}...` : normalized;
+    }
+    deriveTitle(content) {
+        return content.split(/\r?\n/).map((line) => line.trim()).find(Boolean)?.slice(0, 120) ?? "Untitled task";
+    }
+    buildIdempotencyKey(title) {
+        const normalized = title.replace(/\s+/g, " ").trim().toLowerCase();
+        return `title-${createHash("sha256").update(normalized).digest("hex").slice(0, 16)}`;
+    }
+    shouldUseIdempotency(event) {
+        const metadata = event.content.metadata;
+        if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+            return true;
+        }
+        return metadata.allowDuplicate !== true;
+    }
+}
+//# sourceMappingURL=triage-runner.js.map