@sireai/optimus 0.1.1

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

@@ -0,0 +1,636 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { mkdir, 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 { CodexPreflight } from "../../problem-solving-core/codex/codex-preflight.js";
+import { renderManagedCodexHomeConfig, resolveCodexSdkConfigOverrides, resolveEffectiveCodexModel, useManagedCodexHome } from "../../problem-solving-core/codex/codex-provider-profile.js";
+import { OptimusLogger } from "../observability/logger.js";
+import { HarnessRegistry } from "./harness-registry.js";
+const SUPPORTED_EVENT_TYPES = new Set([
+    "task.submitted_manually",
+    "problem.discovered",
+    "bug.discovered",
+    "task.retry_requested",
+    "task.cancel_requested"
+]);
+class TriageAgentError extends Error {
+    failureCategory;
+    constructor(message, failureCategory) {
+        super(message);
+        this.name = "TriageAgentError";
+        this.failureCategory = failureCategory;
+    }
+}
+// TriageAgent is the dedicated role that decides whether a raw event can become a governed task package.
+// Runtime owns queueing and persistence, while this component owns semantic admission, task typing, and rejection reasons.
+export class TriageAgent {
+    config;
+    harnessRegistry;
+    logger;
+    dependencies;
+    initialized = false;
+    constructor(config, dependencies = {}) {
+        this.config = config;
+        this.harnessRegistry = new HarnessRegistry(config);
+        this.logger = new OptimusLogger(config);
+        this.dependencies = dependencies;
+    }
+    // initialize() is called during runtime startup so triage readiness becomes part of the resident service lifecycle.
+    // In codex_sdk mode it performs preflight plus a real warmup turn; startup must fail if this step fails.
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        if (this.config.codex.provider !== "codex_sdk") {
+            this.initialized = true;
+            await this.logger.info("triage.agent.ready", {
+                provider: this.config.codex.provider,
+                mode: "local_matcher"
+            });
+            return;
+        }
+        await this.logger.info("triage.agent.starting", {
+            provider: this.config.codex.provider,
+            model: resolveEffectiveCodexModel(this.config),
+            sandboxMode: this.config.codex.analysisSandbox,
+            approvalPolicy: this.config.codex.approvalPolicy
+        });
+        try {
+            const preflight = await new CodexPreflight(this.config).run();
+            if (!preflight.ok) {
+                throw new TriageAgentError(preflight.summary, preflight.failureCategory ?? "auth_missing");
+            }
+            const warmupExecutor = this.dependencies.runCodexTurn ?? ((input) => this.runCodexTurn(input));
+            const warmup = await warmupExecutor({
+                prompt: [{
+                        type: "text",
+                        text: [
+                            "# Optimus Triage Warmup",
+                            "Return JSON only.",
+                            "Confirm that the triage agent is ready to classify runtime events.",
+                            '{"ready": true, "summary": "triage_ready"}'
+                        ].join("\n")
+                    }],
+                outputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    required: ["ready", "summary"],
+                    properties: {
+                        ready: { type: "boolean" },
+                        summary: { type: "string" }
+                    }
+                },
+                timeoutMs: this.config.codex.execTimeoutMs,
+                sandboxMode: this.config.codex.analysisSandbox
+            });
+            const parsedWarmup = this.parseWarmupResponse(warmup.response);
+            if (!parsedWarmup.ready) {
+                throw new TriageAgentError(`Triage warmup returned ready=false: ${parsedWarmup.summary}`, "schema_error");
+            }
+            this.initialized = true;
+            await this.logger.info("triage.agent.ready", {
+                provider: this.config.codex.provider,
+                summary: parsedWarmup.summary,
+                ...(warmup.sdkThreadId ? { sdkThreadId: warmup.sdkThreadId } : {})
+            });
+        }
+        catch (error) {
+            const failureCategory = this.resolveFailureCategory(error);
+            await this.logger.error("triage.agent.start_failed", {
+                provider: this.config.codex.provider,
+                failureCategory,
+                reason: error instanceof Error ? error.message : "Unknown triage startup failure"
+            });
+            throw error;
+        }
+    }
+    // decide() is the stable triage seam for the whole runtime.
+    // In codex_sdk mode it uses Codex to understand the event plus role contracts; in mock mode it uses the deterministic local matcher.
+    async decide(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"]
+            };
+        }
+        // Control events are runtime governance concerns and must not re-enter semantic task admission.
+        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"
+            };
+        }
+        const contracts = this.loadRoleContracts();
+        if (this.config.codex.provider !== "codex_sdk") {
+            return this.decideLocally(event, title, content, contracts);
+        }
+        await this.initialize();
+        const codexDecision = await this.decideWithCodex(event, title, content, contracts);
+        return this.materializeDecision(event, title, content, contracts, codexDecision);
+    }
+    // Triage contracts are discovered from the harness manifest so admission rules are explicit and decoupled from execution documents.
+    loadRoleContracts() {
+        return this.harnessRegistry.list().map((definition) => this.readRoleContract(definition));
+    }
+    readRoleContract(definition) {
+        const manifest = this.harnessRegistry.getManifest(definition.taskType);
+        const rulePaths = manifest.triageRules.map((file) => join(manifest.harnessDir, file));
+        const triageRulesMarkdown = rulePaths
+            .map((path) => [
+            `<!-- ${path} -->`,
+            readFileSync(path, "utf8")
+        ].join("\n"))
+            .join("\n\n---\n\n");
+        const eventTypes = this.extractList(triageRulesMarkdown, "## 事件范围")
+            .map((eventType) => eventType.replace(/`/g, "").trim())
+            .filter(Boolean);
+        const missingInfoFields = this.extractList(triageRulesMarkdown, "## 拒绝时优先反馈的缺失信息")
+            .map((field) => field.replace(/`/g, "").trim())
+            .filter(Boolean);
+        if (eventTypes.length === 0) {
+            throw new Error(`Triage rules for taskType ${definition.taskType} must define a non-empty 事件范围 list.`);
+        }
+        const normalizedEventTypes = eventTypes.map((eventType) => {
+            if (!SUPPORTED_EVENT_TYPES.has(eventType)) {
+                throw new Error(`Triage rules for taskType ${definition.taskType} declare unsupported 事件范围 entry ${eventType}.`);
+            }
+            return eventType;
+        });
+        return {
+            taskType: definition.taskType,
+            rulePaths,
+            triageRulesMarkdown,
+            eventTypes: normalizedEventTypes,
+            missingInfoFields
+        };
+    }
+    // The Codex-backed path lets a real agent interpret ambiguous natural language using the same harness family that the executor will later consume.
+    async decideWithCodex(event, title, content, contracts) {
+        const prompt = this.buildCodexPrompt(event, title, content, contracts);
+        const turnExecutor = this.dependencies.runCodexTurn ?? ((input) => this.runCodexTurn(input));
+        const result = await turnExecutor({
+            prompt,
+            outputSchema: this.buildOutputSchema(),
+            timeoutMs: this.config.codex.execTimeoutMs,
+            sandboxMode: this.config.codex.analysisSandbox
+        });
+        const rawResponsePath = await this.writeDebugResponseArtifact(event.eventId, "triage-raw-response.json", result.response);
+        await this.logger.debug("triage.agent.raw_response", {
+            eventId: event.eventId,
+            eventType: event.type,
+            ...(result.sdkThreadId ? { sdkThreadId: result.sdkThreadId } : {}),
+            responsePreview: this.previewResponse(result.response, 3000),
+            response: result.response,
+            responseArtifactPath: rawResponsePath
+        });
+        const parsed = this.parseCodexDecision(result.response, contracts);
+        const parsedPath = await this.writeDebugResponseArtifact(event.eventId, "triage-parsed-response.json", JSON.stringify(parsed, null, 2));
+        await this.logger.debug("triage.agent.parsed_response", {
+            eventId: event.eventId,
+            eventType: event.type,
+            ...(result.sdkThreadId ? { sdkThreadId: result.sdkThreadId } : {}),
+            decision: parsed.decision,
+            ...(parsed.taskType ? { taskType: parsed.taskType } : {}),
+            parsedResponsePath: parsedPath
+        });
+        return parsed;
+    }
+    // Materialization keeps the model output narrow: Codex decides accept/reject and task type, while the system still assembles the final TaskPackage contract.
+    materializeDecision(event, title, content, contracts, 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 = contracts.find((contract) => contract.taskType === decision.taskType);
+        if (!matchedContract) {
+            throw new TriageAgentError(`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 } : {}),
+            idempotencyKey: this.buildIdempotencyKey(title),
+            taskType: matchedContract.taskType,
+            title,
+            objective: this.buildObjective(matchedContract.taskType),
+            input: {
+                title,
+                description: event.content.description ?? content,
+                content,
+                ...(event.content.repo ? { repo: event.content.repo } : {}),
+                ...(event.content.branch ? { branch: event.content.branch } : {}),
+                ...(event.content.metadata ? { metadata: event.content.metadata } : {})
+            },
+            constraints: this.buildConstraints(event),
+            requestedCapabilities: this.buildRequestedCapabilities(matchedContract.taskType),
+            desiredArtifactKinds: this.resolveDesiredArtifactKinds(matchedContract.taskType),
+            triageSummary: decision.summary,
+            createdAt: new Date().toISOString()
+        };
+        return {
+            decision: "accepted",
+            summary: taskPackage.triageSummary,
+            taskType: matchedContract.taskType,
+            taskPackage
+        };
+    }
+    // The local matcher remains only for mock mode and deterministic tests.
+    // It uses a conservative bug-vs-non-bug heuristic while the real admission semantics stay in ACCEPT.md and Codex triage.
+    decideLocally(event, title, content, contracts) {
+        const hintedTaskType = typeof event.content.metadata?.taskTypeHint === "string" ? event.content.metadata.taskTypeHint.trim() : "";
+        const matchedContract = hintedTaskType
+            ? (() => {
+                const hintedContract = contracts.find((contract) => contract.taskType === hintedTaskType);
+                if (!hintedContract) {
+                    return undefined;
+                }
+                return this.matchesRoleContract(hintedContract, event, title, content) ? hintedContract : undefined;
+            })()
+            : contracts.find((contract) => this.matchesRoleContract(contract, event, title, content));
+        if (!matchedContract) {
+            return {
+                decision: "rejected",
+                summary: "Runtime event does not match any registered task harness role contract.",
+                reason: "unsupported_problem_type"
+            };
+        }
+        return this.materializeDecision(event, title, content, contracts, {
+            decision: "accepted",
+            summary: `Triage accepted runtime event ${event.eventId} as ${matchedContract.taskType}.`,
+            taskType: matchedContract.taskType
+        });
+    }
+    // The mock/local triage path is intentionally conservative.
+    // It only approximates bug-style requests for deterministic tests; the real routing contract is owned by ACCEPT.md.
+    matchesRoleContract(contract, event, title, content) {
+        if (!contract.eventTypes.includes(event.type)) {
+            return false;
+        }
+        const description = typeof event.content.description === "string" ? event.content.description.trim() : "";
+        if (!title.trim() || (!description && !content.trim())) {
+            return false;
+        }
+        const normalized = `${title}\n${description}\n${content}`.toLowerCase();
+        if (this.looksLikeNonBugRequest(normalized)) {
+            return false;
+        }
+        return this.looksLikeBugReport(normalized);
+    }
+    looksLikeBugReport(content) {
+        const positiveSignals = [
+            "bug",
+            "crash",
+            "error",
+            "exception",
+            "fail",
+            "failure",
+            "regression",
+            "broken",
+            "报错",
+            "崩溃",
+            "异常",
+            "失败",
+            "不生效",
+            "不工作",
+            "卡死",
+            "闪退",
+            "无法",
+            "出错"
+        ];
+        return positiveSignals.some((signal) => content.includes(signal));
+    }
+    looksLikeNonBugRequest(content) {
+        const negativeSignals = [
+            "方案",
+            "建议",
+            "选型",
+            "比较",
+            "brainstorm",
+            "周报",
+            "总结",
+            "汇总",
+            "咨询",
+            "怎么做",
+            "为什么这样设计"
+        ];
+        return negativeSignals.some((signal) => content.includes(signal));
+    }
+    buildCodexPrompt(event, title, content, contracts) {
+        const renderedRoles = contracts.map((contract) => [
+            `## TASK_TYPE: ${contract.taskType}`,
+            `TRIAGE_RULE_PATHS: ${contract.rulePaths.join(", ")}`,
+            contract.triageRulesMarkdown
+        ].join("\n\n")).join("\n\n---\n\n");
+        return [{
+                type: "text",
+                text: [
+                    "# Triage Agent",
+                    "You are the dedicated triage agent for Optimus.",
+                    "Decide whether the runtime event should be accepted into one of the registered task harnesses.",
+                    "You must read the candidate triage rule documents before deciding.",
+                    "Do not invent task types. Only use one of the provided task types.",
+                    "If none of the task types can safely process the event, reject it.",
+                    "If information is missing for admission, reject it and list the missingInfo fields.",
+                    "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),
+                    "",
+                    "# Candidate Task Harness Roles",
+                    renderedRoles,
+                    "",
+                    "# Output Rules",
+                    "- accepted: include decision=accepted, summary, and taskType.",
+                    "- rejected: include decision=rejected, summary, reason, and optional missingInfo.",
+                    "- reason should be a short machine-readable snake_case string when rejected.",
+                    "- missingInfo should only contain concrete field names declared by the selected acceptance contract, such as repo, description_or_content, logs, stack_trace, expected_behavior, actual_behavior."
+                ].join("\n")
+            }];
+    }
+    buildOutputSchema() {
+        return {
+            type: "object",
+            additionalProperties: false,
+            required: ["decision", "summary"],
+            properties: {
+                decision: { type: "string", enum: ["accepted", "rejected"] },
+                summary: { type: "string" },
+                taskType: { type: "string" },
+                reason: { type: "string" },
+                missingInfo: {
+                    type: "array",
+                    items: { type: "string" }
+                }
+            }
+        };
+    }
+    parseCodexDecision(response, contracts) {
+        let parsed;
+        try {
+            parsed = JSON.parse(response);
+        }
+        catch (error) {
+            throw new TriageAgentError(`Codex triage response was not valid JSON: ${error instanceof Error ? error.message : "unknown parse error"}`, "parse_error");
+        }
+        if (!parsed || typeof parsed !== "object") {
+            throw new TriageAgentError("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 TriageAgentError("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 TriageAgentError("Codex triage accepted the event but omitted taskType.", "schema_error");
+            }
+            if (!contracts.some((contract) => contract.taskType === candidate.taskType)) {
+                throw new TriageAgentError(`Codex triage selected unregistered taskType ${candidate.taskType}.`, "schema_error");
+            }
+            return {
+                decision: "accepted",
+                summary: candidate.summary,
+                taskType: candidate.taskType
+            };
+        }
+        const allowedMissingInfo = new Set(contracts.flatMap((contract) => contract.missingInfoFields));
+        const normalizedMissingInfo = Array.isArray(candidate.missingInfo)
+            ? candidate.missingInfo
+                .filter((item) => typeof item === "string" && item.trim().length > 0)
+                .map((item) => item.trim())
+                .filter((item) => allowedMissingInfo.size === 0 || allowedMissingInfo.has(item))
+            : 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 } : {})
+        };
+    }
+    parseWarmupResponse(response) {
+        let parsed;
+        try {
+            parsed = JSON.parse(response);
+        }
+        catch (error) {
+            throw new TriageAgentError(`Triage warmup response was not valid JSON: ${error instanceof Error ? error.message : "unknown parse error"}`, "parse_error");
+        }
+        if (!parsed || typeof parsed !== "object") {
+            throw new TriageAgentError("Triage warmup response schema mismatch: root is not an object.", "schema_error");
+        }
+        const candidate = parsed;
+        if (typeof candidate.ready !== "boolean" || typeof candidate.summary !== "string") {
+            throw new TriageAgentError("Triage warmup response schema mismatch: ready/summary missing.", "schema_error");
+        }
+        return {
+            ready: candidate.ready,
+            summary: candidate.summary
+        };
+    }
+    async runCodexTurn(input) {
+        await this.ensureCodexHome();
+        const codex = this.createCodexClient();
+        const thread = 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 } : {})
+        };
+    }
+    // Triage always runs in a read-only Codex thread because it should classify and package work, never mutate the repository.
+    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.codex.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;
+    }
+    // Managed CODEX_HOME ensures provider routing stays isolated from the operator's personal global Codex state.
+    async ensureCodexHome() {
+        const configText = renderManagedCodexHomeConfig(this.config);
+        if (!configText || !useManagedCodexHome(this.config)) {
+            return;
+        }
+        await mkdir(this.config.codex.homeDir, { recursive: true });
+        await writeFile(join(this.config.codex.homeDir, "config.toml"), configText, "utf8");
+    }
+    createCodexClient() {
+        const auth = new CodexAuthResolver(this.config).resolve();
+        const env = { ...auth.env };
+        if (useManagedCodexHome(this.config)) {
+            env.CODEX_HOME = this.config.codex.homeDir;
+            env.HOME = this.config.codex.homeDir;
+        }
+        const options = { env };
+        if (auth.baseUrl) {
+            options.baseUrl = auth.baseUrl;
+        }
+        if (auth.apiKey) {
+            options.apiKey = auth.apiKey;
+        }
+        const configOverrides = resolveCodexSdkConfigOverrides(this.config);
+        if (configOverrides) {
+            options.config = configOverrides;
+        }
+        return new Codex(options);
+    }
+    async writeDebugResponseArtifact(eventId, filename, content) {
+        const artifactDir = join(this.config.storage.rootDir, "artifacts", "triage");
+        await mkdir(artifactDir, { recursive: true });
+        const targetPath = join(artifactDir, `${eventId}-${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;
+    }
+    resolveFailureCategory(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";
+    }
+    buildObjective(taskType) {
+        if (taskType === "bugfix") {
+            return "Use triage to define a bugfix task that can either produce a safe patch or conclude with a high-quality analysis closure when evidence is insufficient.";
+        }
+        return `Use triage to define a ${taskType} task.`;
+    }
+    resolveDesiredArtifactKinds(taskType) {
+        if (taskType === "bugfix") {
+            return ["analysis", "review_packet"];
+        }
+        return ["analysis"];
+    }
+    buildRequestedCapabilities(taskType) {
+        if (taskType === "bugfix") {
+            return ["problem_normalization", "context_lookup", "analysis", "patch_generation", "verification", "handoff_summary"];
+        }
+        return ["problem_normalization", "analysis"];
+    }
+    buildConstraints(event) {
+        const constraints = [
+            "Approval policy is fixed to never.",
+            "Reject events that do not contain enough information to enter the selected task harness pipeline.",
+            "Do not claim successful code changes during triage; triage only normalizes and routes work."
+        ];
+        if (event.content.repo) {
+            const repoAllowed = this.config.policy.allowedRepos.length === 0 || this.config.policy.allowedRepos.includes(event.content.repo);
+            constraints.push(repoAllowed ? `Repository ${event.content.repo} is allowed by policy.` : `Repository ${event.content.repo} is outside the current allow-list.`);
+        }
+        if (this.config.policy.allowedModules.length > 0) {
+            constraints.push(`Preferred modules: ${this.config.policy.allowedModules.join(", ")}.`);
+        }
+        if (this.config.policy.blockedPaths.length > 0) {
+            constraints.push(`Blocked paths: ${this.config.policy.blockedPaths.join(", ")}.`);
+        }
+        return constraints;
+    }
+    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)}`;
+    }
+    extractSection(markdown, heading) {
+        const lines = markdown.split(/\r?\n/);
+        const headingIndex = lines.findIndex((line) => line.trim() === heading);
+        if (headingIndex === -1) {
+            return undefined;
+        }
+        const collected = [];
+        for (const line of lines.slice(headingIndex + 1)) {
+            if (line.startsWith("## ")) {
+                break;
+            }
+            collected.push(line);
+        }
+        const section = collected.join("\n").trim();
+        return section || undefined;
+    }
+    extractList(markdown, heading) {
+        const section = this.extractSection(markdown, heading);
+        if (!section) {
+            return [];
+        }
+        return section
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.startsWith("- "))
+            .map((line) => line.slice(2).trim())
+            .filter(Boolean);
+    }
+}
+//# sourceMappingURL=triage-agent.js.map