inferoa 0.1.0

package/dist/src/goals/state.js

@@ -0,0 +1,736 @@
+import { randomId } from "../util/hash.js";
+import { truncateText } from "../util/limit.js";
+const PLAN_PROMPT_BODY_LIMIT = 6000;
+export function readGoalState(store, sessionId) {
+    const event = latestGoalEvent(store.listEvents(sessionId));
+    if (!event) {
+        return undefined;
+    }
+    return parseGoalState(event.data);
+}
+export function createGoalState(input, now = new Date()) {
+    const objective = input.objective.trim();
+    if (!objective) {
+        throw new Error("objective is required");
+    }
+    validateTokenBudget(input.token_budget);
+    const timestamp = now.toISOString();
+    return {
+        enabled: true,
+        goal: {
+            id: randomId("goal"),
+            objective,
+            status: "active",
+            token_budget: input.token_budget,
+            tokens_used: 0,
+            time_used_ms: 0,
+            time_used_seconds: 0,
+            tool_rounds_used: 0,
+            tool_calls_used: 0,
+            created_at: timestamp,
+            updated_at: timestamp,
+        },
+    };
+}
+export function replaceGoalPlanning(state, input, now = new Date()) {
+    const next = cloneGoalState(state);
+    next.goal.planning = createGoalPlanning(input, now);
+    next.goal.updated_at = next.goal.planning.updated_at;
+    return next;
+}
+export function attachGoalPlanSnapshot(state, plan, now = new Date()) {
+    let next = cloneGoalState(state);
+    next.goal.plan = { ...plan };
+    const steps = goalPlanningStepsFromMarkdown(plan.body);
+    if (steps.length) {
+        next = syncApprovedPlanIntoGoalPlanning(next, steps, plan.summary, now);
+    }
+    next.goal.updated_at = now.toISOString();
+    return next;
+}
+function syncApprovedPlanIntoGoalPlanning(state, planSteps, summary, now) {
+    if (!state.goal.planning) {
+        return replaceGoalPlanning(state, {
+            summary,
+            steps: planSteps,
+        }, now);
+    }
+    const existing = state.goal.planning;
+    const byId = new Map(existing.steps.map((step) => [step.id, step]));
+    const byTitle = new Map(existing.steps.map((step) => [goalStepTitleKey(step.title), step]));
+    const used = new Set();
+    const mergedSteps = planSteps.map((step, index) => {
+        const title = step.title.trim();
+        const provisionalId = normalizeGoalStepId(step.id, title, index, new Set());
+        const prior = byId.get(provisionalId) ?? byTitle.get(goalStepTitleKey(title));
+        const id = normalizeGoalStepId(prior?.id ?? step.id, title, index, used);
+        used.add(id);
+        return {
+            id,
+            title,
+            status: prior?.status ?? step.status ?? "pending",
+            notes: prior?.notes ?? cleanOptionalString(step.notes),
+            evidence: prior?.evidence ? cloneJsonObject(prior.evidence) : step.evidence ? cloneJsonObject(step.evidence) : undefined,
+        };
+    });
+    return replaceGoalPlanning(state, {
+        summary: summary ?? existing.summary,
+        active_step_id: existing.active_step_id && mergedSteps.some((step) => step.id === existing.active_step_id) ? existing.active_step_id : undefined,
+        steps: mergedSteps,
+    }, now);
+}
+export function updateGoalPlanningStep(state, input, now = new Date()) {
+    if (!state.goal.planning) {
+        throw new Error("goal planning has not been decomposed yet");
+    }
+    const stepId = input.step_id.trim();
+    if (!stepId) {
+        throw new Error("step_id is required");
+    }
+    const timestamp = now.toISOString();
+    const next = cloneGoalState(state);
+    const planning = next.goal.planning;
+    let step = planning.steps.find((item) => item.id === stepId);
+    if (!step) {
+        const title = input.title?.trim();
+        if (!title) {
+            throw new Error(`unknown goal step: ${stepId}`);
+        }
+        step = {
+            id: normalizeGoalStepId(stepId, title, planning.steps.length, new Set(planning.steps.map((item) => item.id))),
+            title,
+            status: input.status ?? "pending",
+            updated_at: timestamp,
+        };
+        planning.steps.push(step);
+    }
+    if (input.title !== undefined) {
+        const title = input.title.trim();
+        if (!title) {
+            throw new Error("step title cannot be empty");
+        }
+        step.title = title;
+    }
+    if (input.status) {
+        step.status = input.status;
+    }
+    if (input.notes !== undefined) {
+        const notes = input.notes.trim();
+        if (notes) {
+            step.notes = notes;
+        }
+        else {
+            delete step.notes;
+        }
+    }
+    if (input.evidence !== undefined) {
+        step.evidence = cloneJsonObject(input.evidence);
+    }
+    step.updated_at = timestamp;
+    if (input.active_step_id !== undefined) {
+        planning.active_step_id = normalizeExistingStepId(input.active_step_id, planning.steps);
+    }
+    else if (step.status === "in_progress") {
+        planning.active_step_id = step.id;
+    }
+    else if (planning.active_step_id === step.id && isTerminalGoalStepStatus(step.status)) {
+        planning.active_step_id = firstNonTerminalStep(planning.steps)?.id;
+    }
+    const active = planning.active_step_id ? planning.steps.find((item) => item.id === planning.active_step_id) : undefined;
+    if (active && active.status === "pending") {
+        active.status = "in_progress";
+        active.updated_at = timestamp;
+    }
+    planning.updated_at = timestamp;
+    next.goal.updated_at = timestamp;
+    return next;
+}
+export function createGoalPlanning(input, now = new Date()) {
+    const timestamp = now.toISOString();
+    const used = new Set();
+    const steps = input.steps.map((step, index) => {
+        const title = step.title.trim();
+        if (!title) {
+            throw new Error("goal planning steps must have non-empty titles");
+        }
+        const id = normalizeGoalStepId(step.id, title, index, used);
+        used.add(id);
+        return {
+            id,
+            title,
+            status: step.status ?? "pending",
+            notes: cleanOptionalString(step.notes),
+            evidence: step.evidence ? cloneJsonObject(step.evidence) : undefined,
+            updated_at: timestamp,
+        };
+    });
+    if (!steps.length) {
+        throw new Error("goal planning requires at least one step");
+    }
+    const activeStepId = normalizeExistingStepId(input.active_step_id, steps) ?? firstNonTerminalStep(steps)?.id;
+    const activeStep = activeStepId ? steps.find((step) => step.id === activeStepId) : undefined;
+    if (activeStep && activeStep.status === "pending") {
+        activeStep.status = "in_progress";
+    }
+    return {
+        summary: cleanOptionalString(input.summary),
+        active_step_id: activeStepId,
+        steps,
+        updated_at: timestamp,
+    };
+}
+export function writeGoalState(store, sessionId, state, runId) {
+    const cloned = cloneGoalState(state);
+    store.appendEvent({
+        session_id: sessionId,
+        run_id: runId,
+        type: "goal.updated",
+        data: goalStateToJson(cloned),
+    });
+    return cloned;
+}
+export function goalCompletionReportForRun(store, sessionId, runId) {
+    return goalCompletionForRun(store, sessionId, runId)?.report;
+}
+export function recordGoalCompletionReport(store, sessionId, runId) {
+    const completion = goalCompletionForRun(store, sessionId, runId);
+    if (!completion) {
+        return undefined;
+    }
+    const state = readGoalState(store, sessionId);
+    if (!state) {
+        return undefined;
+    }
+    const exists = store.listEvents(sessionId).some((event) => event.run_id === runId && event.type === "goal.completion_report");
+    if (!exists) {
+        const data = {
+            goal_objective: completion.objective,
+            report: completion.report,
+            tool_rounds: state.goal.tool_rounds_used,
+            tool_calls: state.goal.tool_calls_used,
+            tokens: state.goal.tokens_used,
+            duration_ms: goalDurationMs(state.goal),
+        };
+        if (state.goal.summary) {
+            data.completion_summary = state.goal.summary;
+        }
+        store.appendEvent({
+            session_id: sessionId,
+            run_id: runId,
+            type: "goal.completion_report",
+            data,
+        });
+    }
+    return completion;
+}
+export function goalStateToJson(state) {
+    return {
+        enabled: state.enabled,
+        goal: state.goal,
+    };
+}
+export function applyGoalUsage(store, sessionId, usage, runId) {
+    const state = readGoalState(store, sessionId);
+    if (!state || !shouldAccountGoalUsage(store, sessionId, state, runId)) {
+        return state;
+    }
+    const tokens = Math.max(0, Math.trunc(usage.tokens ?? 0));
+    const seconds = Math.max(0, Math.trunc(usage.time_seconds ?? 0));
+    const durationMs = Math.max(0, Math.trunc(usage.duration_ms ?? seconds * 1000));
+    const toolRounds = Math.max(0, Math.trunc(usage.tool_rounds ?? 0));
+    const toolCalls = Math.max(0, Math.trunc(usage.tool_calls ?? 0));
+    if (tokens === 0 && durationMs === 0 && toolRounds === 0 && toolCalls === 0) {
+        return state;
+    }
+    const next = cloneGoalState(state);
+    next.goal.tokens_used += tokens;
+    next.goal.time_used_ms = goalDurationMs(next.goal) + durationMs;
+    next.goal.time_used_seconds = Math.floor(next.goal.time_used_ms / 1000);
+    next.goal.tool_rounds_used += toolRounds;
+    next.goal.tool_calls_used += toolCalls;
+    next.goal.updated_at = new Date().toISOString();
+    if (next.goal.token_budget !== undefined &&
+        next.goal.tokens_used >= next.goal.token_budget &&
+        next.goal.status === "active") {
+        next.goal.status = "budget-limited";
+    }
+    return writeGoalState(store, sessionId, next, runId);
+}
+export function modelUsageTokenCost(usage) {
+    if (!usage) {
+        return 0;
+    }
+    if (typeof usage.total_tokens === "number" && Number.isFinite(usage.total_tokens)) {
+        return Math.max(0, Math.trunc(usage.total_tokens));
+    }
+    const prompt = numeric(usage.prompt_tokens);
+    const completion = numeric(usage.completion_tokens);
+    return Math.max(0, prompt + completion);
+}
+export function renderGoalModeSection(state) {
+    if (!state?.enabled || !isActiveGoalPromptStatus(state.goal.status)) {
+        return undefined;
+    }
+    const goal = state.goal;
+    const budgetLine = goal.token_budget === undefined
+        ? "token budget: none"
+        : `token budget: ${goal.token_budget}; tokens used: ${goal.tokens_used}; remaining tokens: ${Math.max(0, goal.token_budget - goal.tokens_used)}`;
+    const loopLine = `tool loops used: ${goal.tool_rounds_used}; tool calls used: ${goal.tool_calls_used}`;
+    const statusLine = goal.status === "budget-limited"
+        ? "status: budget-limited; finish with a concise final answer or call goal complete when the objective is actually done."
+        : `status: ${goal.status}`;
+    return [
+        "A goal-mode objective is active for this session.",
+        renderTrustedObjective(goal.objective),
+        statusLine,
+        budgetLine,
+        loopLine,
+        `time used seconds: ${goal.time_used_seconds}`,
+        `time used ms: ${goalDurationMs(goal)}`,
+        goal.planning ? renderGoalPlanning(goal.planning) : "Internal goal plan: not decomposed yet.",
+        goal.plan ? renderApprovedPlan(goal.plan, Boolean(goal.planning)) : undefined,
+        goal.planning
+            ? "Keep the internal goal plan current with goal op=update_step as findings, edits, and verification change."
+            : "For broad or multi-step work, call goal op=decompose with concrete steps before risky edits.",
+        "Work on the objective until it is genuinely handled. Use the goal tool to inspect, resume, complete, or drop goal state when appropriate.",
+        "When completing the goal, include a completion summary in the goal tool call.",
+        "Do not mark the goal complete merely because the turn is ending or the budget is low.",
+    ]
+        .filter((line) => Boolean(line))
+        .join("\n");
+}
+export function completionBudgetReport(goal) {
+    const usage = goal.token_budget === undefined
+        ? `${goal.tokens_used} tokens used`
+        : `${goal.tokens_used} of ${goal.token_budget} tokens used`;
+    return `Goal achieved. ${countLabel(goal.tool_rounds_used, "loop")} · ${countLabel(goal.tool_calls_used, "tool call")} · ${formatDurationMs(goalDurationMs(goal))} · ${usage}.`;
+}
+export function goalDurationMs(goal) {
+    return Math.max(0, Math.trunc(goal.time_used_ms ?? goal.time_used_seconds * 1000));
+}
+export function formatGoalDuration(goal) {
+    return formatDurationMs(goalDurationMs(goal));
+}
+export function renderTrustedObjective(objective) {
+    return `<objective>\n${escapeXmlText(objective)}\n</objective>`;
+}
+export function escapeXmlText(input) {
+    return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+export function cloneGoalState(state) {
+    return {
+        enabled: state.enabled,
+        goal: {
+            ...state.goal,
+            planning: state.goal.planning ? cloneGoalPlanning(state.goal.planning) : undefined,
+            plan: state.goal.plan ? { ...state.goal.plan } : undefined,
+        },
+    };
+}
+export function incompleteGoalPlanningSteps(goal) {
+    return goal.planning?.steps.filter((step) => !isTerminalGoalStepStatus(step.status)) ?? [];
+}
+export function incompleteGoalPlanningMessage(goal) {
+    const incomplete = incompleteGoalPlanningSteps(goal);
+    if (!incomplete.length) {
+        return undefined;
+    }
+    const visible = incomplete.slice(0, 8).map((step) => step.id);
+    const suffix = incomplete.length > visible.length ? `, and ${incomplete.length - visible.length} more` : "";
+    return `Cannot complete goal with unfinished internal plan steps: ${visible.join(", ")}${suffix}`;
+}
+export function goalPlanningProgressSummary(planning) {
+    const counts = new Map();
+    for (const step of planning.steps) {
+        counts.set(step.status, (counts.get(step.status) ?? 0) + 1);
+    }
+    const parts = [
+        countPart(counts, "completed", "completed"),
+        countPart(counts, "in_progress", "in progress"),
+        countPart(counts, "blocked", "blocked"),
+        countPart(counts, "pending", "pending"),
+        countPart(counts, "skipped", "skipped"),
+    ].filter((part) => Boolean(part));
+    return parts.length ? parts.join(" · ") : "no steps";
+}
+export function goalPlanningStepsFromMarkdown(body) {
+    if (!body) {
+        return [];
+    }
+    return body
+        .split(/\r?\n/)
+        .map(parseGoalPlanningStepLine)
+        .filter((step) => Boolean(step));
+}
+export function validateTokenBudget(value) {
+    if (value === undefined) {
+        return;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error("token_budget must be a positive integer when provided");
+    }
+}
+export function isAccountingGoal(goal) {
+    return goal.status === "active" || goal.status === "budget-limited";
+}
+function shouldAccountGoalUsage(store, sessionId, state, runId) {
+    if (state.enabled && isAccountingGoal(state.goal)) {
+        return true;
+    }
+    if (!runId || (state.goal.status !== "complete" && state.goal.status !== "dropped")) {
+        return false;
+    }
+    return store.listEvents(sessionId).some((event) => {
+        if (event.run_id !== runId || event.type !== "goal.updated") {
+            return false;
+        }
+        const eventState = parseGoalState(event.data);
+        return eventState?.goal.id === state.goal.id && (eventState.goal.status === "complete" || eventState.goal.status === "dropped");
+    });
+}
+function goalCompletionForRun(store, sessionId, runId) {
+    const state = readGoalState(store, sessionId);
+    if (!state || state.goal.status !== "complete") {
+        return undefined;
+    }
+    const completedInRun = store.listEvents(sessionId).some((event) => {
+        if (event.run_id !== runId || event.type !== "goal.updated") {
+            return false;
+        }
+        const eventState = parseGoalState(event.data);
+        return eventState?.goal.id === state.goal.id && eventState.goal.status === "complete";
+    });
+    const report = completedInRun ? completionBudgetReport(state.goal) : undefined;
+    return report ? { objective: state.goal.objective, report } : undefined;
+}
+function isActiveGoalPromptStatus(status) {
+    return status === "active" || status === "budget-limited";
+}
+function latestGoalEvent(events) {
+    return events.filter((event) => event.type === "goal.updated").at(-1);
+}
+function parseGoalState(data) {
+    const goal = data.goal;
+    if (!goal || typeof goal !== "object" || Array.isArray(goal)) {
+        return undefined;
+    }
+    const candidate = goal;
+    const objective = typeof candidate.objective === "string" ? candidate.objective : "";
+    const status = parseGoalStatus(candidate.status);
+    const id = typeof candidate.id === "string" ? candidate.id : "";
+    if (!id || !objective || !status) {
+        return undefined;
+    }
+    const tokenBudget = numericOrUndefined(candidate.token_budget);
+    return {
+        enabled: data.enabled === true,
+        goal: {
+            id,
+            objective,
+            status,
+            token_budget: tokenBudget,
+            tokens_used: numeric(candidate.tokens_used),
+            time_used_ms: durationMsFromGoalData(candidate),
+            time_used_seconds: numeric(candidate.time_used_seconds),
+            tool_rounds_used: numeric(candidate.tool_rounds_used),
+            tool_calls_used: numeric(candidate.tool_calls_used),
+            planning: parseGoalPlanning(candidate.planning),
+            plan: parseGoalPlan(candidate.plan),
+            summary: optionalString(candidate.summary),
+            created_at: typeof candidate.created_at === "string" ? candidate.created_at : "",
+            updated_at: typeof candidate.updated_at === "string" ? candidate.updated_at : "",
+        },
+    };
+}
+function renderApprovedPlan(plan, hasInternalPlanning) {
+    const bodySyncedIntoInternalPlan = hasInternalPlanning && goalPlanningStepsFromMarkdown(plan.body).length > 0;
+    return [
+        "Approved plan:",
+        `<plan_objective>\n${escapeXmlText(plan.objective)}\n</plan_objective>`,
+        plan.summary ? `Plan summary: ${escapeXmlText(plan.summary)}` : undefined,
+        bodySyncedIntoInternalPlan ? "Body synced into the internal goal plan above." : plan.body ? `Plan body:\n${escapeXmlText(truncateText(plan.body, PLAN_PROMPT_BODY_LIMIT).text)}` : undefined,
+    ]
+        .filter((line) => Boolean(line))
+        .join("\n");
+}
+function renderGoalPlanning(planning) {
+    const active = planning.active_step_id ? planning.steps.find((step) => step.id === planning.active_step_id) : undefined;
+    return [
+        "Internal goal plan:",
+        planning.summary ? `Plan summary: ${escapeXmlText(planning.summary)}` : undefined,
+        active ? `Active step: ${escapeXmlText(active.id)} ${escapeXmlText(active.title)}` : undefined,
+        `Progress: ${goalPlanningProgressSummary(planning)}`,
+        ...planning.steps.flatMap((step) => renderGoalPlanningStep(step)),
+    ]
+        .filter((line) => Boolean(line))
+        .join("\n");
+}
+function renderGoalPlanningStep(step) {
+    const marker = stepMarker(step.status);
+    const lines = [`[${marker}] ${escapeXmlText(step.id)} ${escapeXmlText(step.title)}`];
+    if (step.notes) {
+        lines.push(`notes: ${escapeXmlText(truncateEvidenceText(step.notes, 500))}`);
+    }
+    if (step.evidence) {
+        lines.push(`evidence: ${escapeXmlText(compactEvidenceSummary(step.evidence))}`);
+    }
+    return lines;
+}
+function compactEvidenceSummary(value) {
+    return compactEvidenceObject(value, 0) || "recorded";
+}
+function compactEvidenceObject(value, depth) {
+    const entries = Object.keys(value)
+        .sort()
+        .slice(0, depth === 0 ? 8 : 4)
+        .map((key) => {
+        const compact = compactEvidenceValue(value[key], depth + 1);
+        return compact ? `${key}=${compact}` : "";
+    })
+        .filter(Boolean);
+    const omitted = Math.max(0, Object.keys(value).length - (depth === 0 ? 8 : 4));
+    if (omitted > 0) {
+        entries.push(`${omitted} more`);
+    }
+    return entries.join("; ");
+}
+function compactEvidenceValue(value, depth) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    if (typeof value === "string") {
+        return truncateEvidenceText(value);
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        const items = value.map((item) => compactEvidenceValue(item, depth)).filter(Boolean).slice(0, 6);
+        const omitted = Math.max(0, value.length - items.length);
+        return `${items.join(", ")}${omitted ? `, ${omitted} more` : ""}`;
+    }
+    if (typeof value === "object") {
+        if (depth >= 3) {
+            return "object";
+        }
+        const compact = compactEvidenceObject(value, depth);
+        return compact ? `(${compact})` : "";
+    }
+    return truncateEvidenceText(String(value));
+}
+function truncateEvidenceText(value, max = 160) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > max ? `${normalized.slice(0, max - 3)}...` : normalized;
+}
+function parseGoalPlan(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const data = value;
+    const id = optionalString(data.id);
+    const objective = optionalString(data.objective);
+    const approvedAt = optionalString(data.approved_at);
+    if (!id || !objective || !approvedAt) {
+        return undefined;
+    }
+    return {
+        id,
+        objective,
+        summary: optionalString(data.summary),
+        body: optionalString(data.body),
+        approved_at: approvedAt,
+    };
+}
+function parseGoalPlanning(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const data = value;
+    const rawSteps = Array.isArray(data.steps) ? data.steps : [];
+    const steps = rawSteps.map(parseGoalPlanningStep).filter((step) => Boolean(step));
+    if (!steps.length) {
+        return undefined;
+    }
+    const activeStepId = normalizeExistingStepId(optionalString(data.active_step_id), steps) ?? firstNonTerminalStep(steps)?.id;
+    return {
+        summary: optionalString(data.summary),
+        active_step_id: activeStepId,
+        steps,
+        updated_at: typeof data.updated_at === "string" ? data.updated_at : "",
+    };
+}
+function parseGoalPlanningStep(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const data = value;
+    const id = optionalString(data.id);
+    const title = optionalString(data.title);
+    const status = parseGoalStepStatus(data.status);
+    if (!id || !title || !status) {
+        return undefined;
+    }
+    return {
+        id,
+        title,
+        status,
+        notes: optionalString(data.notes),
+        evidence: parseJsonObject(data.evidence),
+        updated_at: typeof data.updated_at === "string" ? data.updated_at : "",
+    };
+}
+function parseGoalStatus(value) {
+    return value === "active" || value === "paused" || value === "budget-limited" || value === "complete" || value === "dropped"
+        ? value
+        : undefined;
+}
+export function parseGoalStepStatus(value) {
+    return value === "pending" || value === "in_progress" || value === "completed" || value === "blocked" || value === "skipped"
+        ? value
+        : undefined;
+}
+function numeric(value) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+}
+function numericOrUndefined(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+function durationMsFromGoalData(candidate) {
+    const millis = numeric(candidate.time_used_ms);
+    if (millis > 0 || typeof candidate.time_used_ms === "number") {
+        return millis;
+    }
+    return numeric(candidate.time_used_seconds) * 1000;
+}
+function optionalString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function cleanOptionalString(value) {
+    return optionalString(value);
+}
+function cleanPlanStepTitle(value) {
+    const trimmed = value
+        ?.replace(/`([^`]+)`/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/\*([^*]+)\*/g, "$1")
+        .trim();
+    return trimmed || undefined;
+}
+function parseGoalPlanningStepLine(line) {
+    const match = /^\s*(?:[-*+]|\d+[.)])\s+(?:\[(?<mark>[ xX-])\]\s*)?(?<title>.+?)\s*$/.exec(line);
+    const title = cleanPlanStepTitle(match?.groups?.title);
+    if (!title) {
+        return undefined;
+    }
+    const status = goalStepStatusFromCheckbox(match?.groups?.mark);
+    return status ? { title, status } : { title };
+}
+function goalStepStatusFromCheckbox(value) {
+    if (value === "x" || value === "X") {
+        return "completed";
+    }
+    if (value === "-") {
+        return "skipped";
+    }
+    if (value === " ") {
+        return "pending";
+    }
+    return undefined;
+}
+function goalStepTitleKey(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function cloneGoalPlanning(planning) {
+    return {
+        summary: planning.summary,
+        active_step_id: planning.active_step_id,
+        updated_at: planning.updated_at,
+        steps: planning.steps.map((step) => ({
+            ...step,
+            evidence: step.evidence ? cloneJsonObject(step.evidence) : undefined,
+        })),
+    };
+}
+function cloneJsonObject(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function parseJsonObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return cloneJsonObject(value);
+}
+function normalizeGoalStepId(rawId, title, index, used) {
+    const seed = rawId?.trim() || title.trim() || `step-${index + 1}`;
+    const base = seed
+        .toLowerCase()
+        .replace(/[^a-z0-9_.:-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64) || `step-${index + 1}`;
+    let candidate = base;
+    let suffix = 2;
+    while (used.has(candidate)) {
+        candidate = `${base}-${suffix}`;
+        suffix += 1;
+    }
+    return candidate;
+}
+function normalizeExistingStepId(stepId, steps) {
+    const trimmed = stepId?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return steps.some((step) => step.id === trimmed) ? trimmed : undefined;
+}
+function firstNonTerminalStep(steps) {
+    return steps.find((step) => !isTerminalGoalStepStatus(step.status));
+}
+function isTerminalGoalStepStatus(status) {
+    return status === "completed" || status === "skipped";
+}
+function countPart(counts, status, label) {
+    const count = counts.get(status) ?? 0;
+    return count > 0 ? `${count} ${label}` : undefined;
+}
+function countLabel(count, singular) {
+    return `${count} ${singular}${count === 1 ? "" : "s"}`;
+}
+function formatDurationMs(durationMs) {
+    const safe = Math.max(0, Math.trunc(durationMs));
+    if (safe > 0 && safe < 1000) {
+        return `${safe}ms`;
+    }
+    return formatSeconds(Math.floor(safe / 1000));
+}
+function formatSeconds(seconds) {
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    if (minutes < 60) {
+        return remainder ? `${minutes}m ${remainder}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const minuteRemainder = minutes % 60;
+    return minuteRemainder ? `${hours}h ${minuteRemainder}m` : `${hours}h`;
+}
+function stepMarker(status) {
+    switch (status) {
+        case "completed":
+            return "x";
+        case "in_progress":
+            return "*";
+        case "blocked":
+            return "!";
+        case "skipped":
+            return "-";
+        case "pending":
+            return " ";
+    }
+}
+//# sourceMappingURL=state.js.map