projscan 4.3.1 → 4.4.0

package/dist/core/startMode.js

@@ -0,0 +1,139 @@
+import { routeIntent } from './intentRouter.js';
+import { isProductPlanningWorkplanRoute } from './startSuccessCriteria.js';
+import { isWorkplanMode } from './workplan.js';
+const MODE_RESOLVERS = [
+    releaseMode,
+    bugHuntMode,
+    productPlanningMode,
+    hardeningMode,
+    evidencePackMode,
+    reviewMode,
+    regressionMode,
+    prDiffMode,
+    mergeRiskMode,
+    primaryPreflightMode,
+    fallbackPreflightMode,
+];
+export function resolveStartMode(value, intent) {
+    if (typeof value === 'string' && isWorkplanMode(value)) {
+        return {
+            mode: value,
+            source: 'explicit',
+            reason: `Mode ${value} was provided explicitly.`,
+        };
+    }
+    const inferred = inferModeFromIntent(intent);
+    if (inferred) {
+        return {
+            mode: inferred,
+            source: 'intent',
+            reason: `Intent "${intent}" maps to the ${inferred} workflow.`,
+        };
+    }
+    return {
+        mode: 'before_edit',
+        source: 'default',
+        reason: defaultModeReason(intent, routesForIntent(intent).length > 0),
+    };
+}
+export function inferModeFromIntent(intent) {
+    const routes = routesForIntent(intent);
+    const context = {
+        intent: intent ?? '',
+        routes,
+        primaryRoute: routes[0],
+    };
+    for (const resolver of MODE_RESOLVERS) {
+        const mode = resolver(context);
+        if (mode)
+            return mode;
+    }
+    return undefined;
+}
+export function routesForIntent(intent) {
+    if (!intent)
+        return [];
+    return routeIntent(intent).matches.map(routeEntryToStartIntent);
+}
+export function preflightModeFromIntent(intent) {
+    const text = intent.toLowerCase();
+    if (/\b(?:merge|merged|merging|release|rebase|rebasing|conflict|conflicts|resolve|resolving)\b/.test(text))
+        return 'before_merge';
+    if (/\bcommit|committing|committed|pr|pull\s+request\b/.test(text))
+        return 'before_commit';
+    return 'before_edit';
+}
+function defaultModeReason(intent, routed) {
+    if (!intent)
+        return 'No mode-specific intent or explicit mode was supplied, so start defaults to before_edit.';
+    if (routed) {
+        return `Mission Control routed the intent, but no workflow-mode hint matched "${intent}", so start defaults to before_edit.`;
+    }
+    return `No mode-specific intent matched "${intent}", so start defaults to before_edit.`;
+}
+function routeEntryToStartIntent(entry) {
+    return {
+        intent: entry.intent,
+        category: entry.category,
+        tool: entry.tool,
+        cli: entry.cli,
+        why: entry.why,
+        example: entry.example,
+        confidence: entry.confidence,
+        rank: entry.rank,
+        score: entry.score,
+        matchedKeywords: entry.matchedKeywords,
+    };
+}
+function releaseMode({ primaryRoute }) {
+    return primaryRoute?.tool === 'projscan_release_train' ? 'release' : undefined;
+}
+function bugHuntMode({ primaryRoute }) {
+    return primaryRoute?.tool === 'projscan_bug_hunt' && primaryRoute.confidence === 'high'
+        ? 'bug_hunt'
+        : undefined;
+}
+function productPlanningMode({ primaryRoute }) {
+    return isProductPlanningWorkplanRoute(primaryRoute) ? 'bug_hunt' : undefined;
+}
+function hardeningMode({ primaryRoute }) {
+    return primaryRoute?.tool === 'projscan_dataflow' && primaryRoute.confidence === 'high'
+        ? 'hardening'
+        : undefined;
+}
+function evidencePackMode({ primaryRoute }) {
+    return primaryRoute?.tool === 'projscan_evidence_pack' ? 'before_commit' : undefined;
+}
+function reviewMode({ intent, primaryRoute }) {
+    return primaryRoute?.tool === 'projscan_review' ? reviewModeFromIntent(intent) : undefined;
+}
+function regressionMode({ intent, primaryRoute }) {
+    return primaryRoute?.tool === 'projscan_regression_plan'
+        ? regressionModeFromIntent(intent)
+        : undefined;
+}
+function prDiffMode({ primaryRoute }) {
+    return primaryRoute?.tool === 'projscan_pr_diff' ? 'before_commit' : undefined;
+}
+function mergeRiskMode({ primaryRoute }) {
+    return primaryRoute?.tool === 'projscan_merge_risk' ? 'before_merge' : undefined;
+}
+function primaryPreflightMode({ intent, primaryRoute, }) {
+    return primaryRoute?.tool === 'projscan_preflight' ? preflightModeFromIntent(intent) : undefined;
+}
+function fallbackPreflightMode({ intent, routes }) {
+    if (routes.some((route) => route.tool === 'projscan_preflight') && hasPreflightModeHint(intent)) {
+        return preflightModeFromIntent(intent);
+    }
+    return undefined;
+}
+function hasPreflightModeHint(intent) {
+    return /\b(?:safe|safety|gate|preflight|commit|committing|committed|merge|merged|merging|rebase|rebasing|conflict|conflicts|resolve|resolving|edit|proceed|block|blocked|blocker|blockers|blocking|allowed)\b/i.test(intent);
+}
+function regressionModeFromIntent(intent) {
+    return /\bmerge|merged|merging|release\b/i.test(intent) ? 'before_merge' : 'before_commit';
+}
+function reviewModeFromIntent(intent) {
+    return /\bmerge|merged|merging\b/i.test(intent) ? 'before_merge' : 'before_commit';
+}
+//# sourceMappingURL=startMode.js.map

package/dist/core/startMode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startMode.js","sourceRoot":"","sources":["../../src/core/startMode.ts"],"names":[],"mappings":"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"}

package/dist/core/startOptions.d.ts

@@ -0,0 +1,18 @@
+import { type StartModeResolution } from './startMode.js';
+import type { WorkplanMode } from '../types.js';
+export interface ComputeStartOptions {
+    mode?: WorkplanMode;
+    intent?: string;
+    missionDir?: string;
+    maxTasks?: number;
+    maxRisks?: number;
+    includeHandoff?: boolean;
+}
+export interface NormalizedStartOptions {
+    intent?: string;
+    modeResolution: StartModeResolution;
+    mode: WorkplanMode;
+    maxTasks: number;
+    maxRisks: number;
+}
+export declare function normalizeStartOptions(options?: ComputeStartOptions): NormalizedStartOptions;

package/dist/core/startOptions.js

@@ -0,0 +1,29 @@
+import { resolveStartMode } from './startMode.js';
+const DEFAULT_MAX_TASKS = 5;
+const DEFAULT_MAX_RISKS = 5;
+const MAX_START_ITEMS = 12;
+export function normalizeStartOptions(options = {}) {
+    const intent = normalizeIntent(options.intent);
+    const modeResolution = resolveStartMode(options.mode, intent);
+    return {
+        intent,
+        modeResolution,
+        mode: modeResolution.mode,
+        maxTasks: normalizeLimit(options.maxTasks, DEFAULT_MAX_TASKS, MAX_START_ITEMS),
+        maxRisks: normalizeLimit(options.maxRisks, DEFAULT_MAX_RISKS, MAX_START_ITEMS),
+    };
+}
+function normalizeIntent(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim().replace(/\s+/g, ' ');
+    if (trimmed.length === 0)
+        return undefined;
+    return trimmed.slice(0, 240);
+}
+function normalizeLimit(value, fallback, max) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.max(1, Math.min(max, Math.floor(value)));
+}
+//# sourceMappingURL=startOptions.js.map

package/dist/core/startOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startOptions.js","sourceRoot":"","sources":["../../src/core/startOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAA4B,MAAM,gBAAgB,CAAC;AAoB5E,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAC5B,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAC5B,MAAM,eAAe,GAAG,EAAE,CAAC;AAE3B,MAAM,UAAU,qBAAqB,CAAC,UAA+B,EAAE;IACrE,MAAM,MAAM,GAAG,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/C,MAAM,cAAc,GAAG,gBAAgB,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC9D,OAAO;QACL,MAAM;QACN,cAAc;QACd,IAAI,EAAE,cAAc,CAAC,IAAI;QACzB,QAAQ,EAAE,cAAc,CAAC,OAAO,CAAC,QAAQ,EAAE,iBAAiB,EAAE,eAAe,CAAC;QAC9E,QAAQ,EAAE,cAAc,CAAC,OAAO,CAAC,QAAQ,EAAE,iBAAiB,EAAE,eAAe,CAAC;KAC/E,CAAC;AACJ,CAAC;AAED,SAAS,eAAe,CAAC,KAAyB;IAChD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IAChD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAClD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC3C,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC/B,CAAC;AAED,SAAS,cAAc,CAAC,KAAyB,EAAE,QAAgB,EAAE,GAAW;IAC9E,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,QAAQ,CAAC;IAC1E,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACvD,CAAC"}

package/dist/core/startResume.d.ts

@@ -0,0 +1,7 @@
+import type { MissionOutcome, StartExecutionCursor, StartExecutionPhase, StartExecutionPlan, StartMissionResume } from '../types/start.js';
+export declare function missionResume(plan: StartExecutionPlan, outcome?: MissionOutcome): StartMissionResume;
+export declare function proofCommandToolCall(command: string): StartMissionResume['toolCall'] | undefined;
+export declare function executionCursor(phases: StartExecutionPhase[]): StartExecutionCursor;
+export declare function argsAreReady(value: unknown): boolean;
+export declare function isRunnableCommand(command: string): boolean;
+export declare function uniqueStrings(values: string[]): string[];

package/dist/core/startResume.js

@@ -0,0 +1,468 @@
+import { isPlaceholder } from './startIntentTargets.js';
+const CURSOR_SELECTORS = [
+    (phase, step) => phase.id === 'ready_now' && step.status === 'ready' && typeof step.command === 'string',
+    (phase, step) => phase.id === 'resolve_inputs' && step.status === 'blocked',
+    (phase, step) => phase.id === 'proof' && step.status === 'ready',
+    (phase) => phase.id === 'done_when',
+    (phase) => phase.id === 'next_action',
+];
+const CURSOR_REASON_RULES = [
+    { matches: (step) => step.status === 'ready' && step.kind === 'tool', reason: readyToolReason },
+    {
+        matches: (step) => step.status === 'blocked' && step.kind === 'input',
+        reason: () => 'Resolve this blocked input before running dependent follow-up steps.',
+    },
+    {
+        matches: (step) => step.status === 'ready' && step.kind === 'proof',
+        reason: () => 'Run this proof command when action steps are complete.',
+    },
+    {
+        matches: (step) => step.kind === 'criterion',
+        reason: () => 'Use this criterion to decide when the task is complete.',
+    },
+];
+function readyToolReason(step) {
+    return step.unlocks && step.unlocks.length > 0
+        ? 'Run this ready command next; it can unlock later inputs or follow-up steps.'
+        : 'Run this ready command next.';
+}
+export function missionResume(plan, outcome) {
+    const cursor = plan.cursor;
+    const commandBlock = runnableCursorCommand(cursor);
+    const toolCall = resumeToolCall(plan, cursor);
+    const followUps = resumeFollowUps(plan, cursor);
+    const inputBindings = resumeInputBindings(plan, cursor);
+    const checklist = resumeChecklist(plan, cursor, inputBindings, followUps);
+    const remainingProofItems = resumeRemainingProofItems(checklist);
+    const remainingProofCommands = resumeRemainingProofCommands(checklist);
+    const remainingProofToolCalls = resumeRemainingProofToolCalls(checklist);
+    const unlocks = resolveResumeReferences(plan, cursor.unlocks);
+    const blockedBy = resolveResumeReferences(plan, cursor.blockedBy);
+    const instruction = resumeInstruction(cursor, commandBlock);
+    const prompt = resumePrompt(cursor, commandBlock, instruction, unlocks, blockedBy, outcome);
+    const resume = {
+        currentStep: cursor,
+        status: cursor.status,
+        instruction,
+        prompt,
+    };
+    attachResumeAction(resume, commandBlock, toolCall);
+    attachResumeCollections(resume, {
+        followUps,
+        inputBindings,
+        checklist,
+        remainingProofItems,
+        remainingProofCommands,
+        remainingProofToolCalls,
+        unlocks,
+        blockedBy,
+    });
+    return resume;
+}
+function runnableCursorCommand(cursor) {
+    return cursor.command && isRunnableCommand(cursor.command) ? cursor.command : undefined;
+}
+function resumeInstruction(cursor, commandBlock) {
+    if (commandBlock)
+        return `Run ${commandBlock}.`;
+    if (cursor.instruction)
+        return `Resolve ${cursor.label}: ${cursor.instruction}`;
+    return `Continue with ${cursor.label}.`;
+}
+function resumePrompt(cursor, commandBlock, instruction, unlocks, blockedBy, outcome) {
+    const base = commandBlock
+        ? `Resume at ${cursor.stepId} in ${cursor.phaseId}: run \`${commandBlock}\`.${resumeUnlocksSentence(unlocks, cursor.unlocks)}`
+        : `Resume at ${cursor.stepId} in ${cursor.phaseId}: ${instruction}${resumeBlockersSentence(blockedBy, cursor.blockedBy)}`;
+    return outcome?.available ? `${outcome.resumePrompt} ${base}` : base;
+}
+function attachResumeAction(resume, commandBlock, toolCall) {
+    if (commandBlock)
+        resume.commandBlock = commandBlock;
+    if (toolCall)
+        resume.toolCall = toolCall;
+}
+function attachResumeCollections(resume, collections) {
+    if (collections.followUps.length > 0)
+        resume.followUps = collections.followUps;
+    if (collections.inputBindings.length > 0)
+        resume.inputBindings = collections.inputBindings;
+    if (collections.checklist.length > 0)
+        resume.checklist = collections.checklist;
+    if (collections.remainingProofItems.length > 0)
+        resume.remainingProofItems = collections.remainingProofItems;
+    if (collections.remainingProofCommands.length > 0)
+        resume.remainingProofCommands = collections.remainingProofCommands;
+    if (collections.remainingProofToolCalls.length > 0)
+        resume.remainingProofToolCalls = collections.remainingProofToolCalls;
+    if (collections.unlocks.length > 0)
+        resume.unlocks = collections.unlocks;
+    if (collections.blockedBy.length > 0)
+        resume.blockedBy = collections.blockedBy;
+}
+function resumeRemainingProofCommands(checklist) {
+    return checklist
+        .filter((item) => item.kind === 'run_proof' && typeof item.command === 'string')
+        .map((item) => item.command);
+}
+function resumeRemainingProofItems(checklist) {
+    return checklist.flatMap((item) => {
+        if (item.kind !== 'run_proof' || typeof item.command !== 'string')
+            return [];
+        const toolCall = proofChecklistToolCall(item);
+        return [
+            {
+                stepId: item.stepId,
+                status: item.status,
+                label: item.label,
+                command: item.command,
+                ...(toolCall ? { toolCall } : {}),
+            },
+        ];
+    });
+}
+function resumeRemainingProofToolCalls(checklist) {
+    return checklist.flatMap((item) => {
+        if (item.kind !== 'run_proof' || typeof item.command !== 'string')
+            return [];
+        const toolCall = proofChecklistToolCall(item);
+        return toolCall ? [{ stepId: item.stepId, command: item.command, ...toolCall }] : [];
+    });
+}
+function proofChecklistToolCall(item) {
+    if (item.tool) {
+        return {
+            tool: item.tool,
+            ...(typeof item.args !== 'undefined' ? { args: item.args } : {}),
+        };
+    }
+    return typeof item.command === 'string' ? proofCommandToolCall(item.command) : undefined;
+}
+export function proofCommandToolCall(command) {
+    const preflightMatch = /^projscan preflight(?: --mode ([a-z_]+))? --format json$/.exec(command);
+    if (preflightMatch) {
+        return {
+            tool: 'projscan_preflight',
+            args: preflightMatch[1] ? { mode: preflightMatch[1] } : {},
+        };
+    }
+    const understandMatch = /^projscan understand --view ([a-z_]+)(?: --intent "((?:\\.|[^"\\])*)")? --format json$/.exec(command);
+    if (understandMatch) {
+        return {
+            tool: 'projscan_understand',
+            args: {
+                view: understandMatch[1],
+                ...(understandMatch[2] ? { intent: unescapeDoubleQuoted(understandMatch[2]) } : {}),
+            },
+        };
+    }
+    if (command === 'projscan session touched --format json') {
+        return {
+            tool: 'projscan_session',
+            args: { action: 'touched' },
+        };
+    }
+    return undefined;
+}
+function unescapeDoubleQuoted(value) {
+    return value.replace(/\\(["\\$`])/g, '$1');
+}
+function resumeChecklist(plan, cursor, inputBindings, followUps) {
+    const current = findStepInPlan(plan, cursor.stepId);
+    const currentItem = current
+        ? resumeChecklistItemFromStep(current.phase, current.step, currentChecklistKind(current.step), cursor.stepId)
+        : undefined;
+    const includedStepIds = new Set(currentItem ? [currentItem.stepId] : []);
+    const inputItems = inputBindings.flatMap((binding) => {
+        if (includedStepIds.has(binding.inputId))
+            return [];
+        const found = findStepInPlan(plan, binding.inputId);
+        if (!found)
+            return [];
+        includedStepIds.add(found.step.id);
+        return [
+            {
+                id: `resume-${found.step.id}`,
+                kind: 'resolve_input',
+                phaseId: found.phase.id,
+                stepId: found.step.id,
+                status: found.step.status,
+                label: binding.label,
+                placeholder: binding.placeholder,
+                instruction: binding.instruction,
+                followUpIds: binding.followUpIds,
+                ...(found.step.dependsOn && found.step.dependsOn.length > 0
+                    ? { dependsOn: found.step.dependsOn }
+                    : {}),
+                ...(found.step.unlocks && found.step.unlocks.length > 0
+                    ? { unlocks: found.step.unlocks }
+                    : {}),
+            },
+        ];
+    });
+    const followUpItems = followUps.flatMap((followUp) => {
+        if (includedStepIds.has(followUp.id))
+            return [];
+        includedStepIds.add(followUp.id);
+        return [
+            {
+                id: `resume-${followUp.id}`,
+                kind: 'run_follow_up',
+                phaseId: followUp.phaseId,
+                stepId: followUp.id,
+                status: followUp.status,
+                label: followUp.label,
+                ...(followUp.command ? { command: followUp.command } : {}),
+                ...(followUp.tool ? { tool: followUp.tool } : {}),
+                ...(followUp.args ? { args: followUp.args } : {}),
+                ...(followUp.blockedBy && followUp.blockedBy.length > 0
+                    ? { blockedBy: followUp.blockedBy }
+                    : {}),
+                ...(followUp.dependsOn && followUp.dependsOn.length > 0
+                    ? { dependsOn: followUp.dependsOn }
+                    : {}),
+            },
+        ];
+    });
+    const currentCommand = current?.step.command;
+    const proofItems = stepsForPhase(plan, 'proof')
+        .filter(({ step }) => step.command && step.command !== currentCommand)
+        .map(({ phase, step }) => resumeChecklistItemFromStep(phase, step, 'run_proof', step.id));
+    const doneItems = stepsForPhase(plan, 'done_when').map(({ phase, step }) => resumeChecklistItemFromStep(phase, step, 'confirm_done', step.id));
+    return [
+        ...(currentItem ? [currentItem] : []),
+        ...inputItems,
+        ...followUpItems,
+        ...proofItems,
+        ...doneItems,
+    ];
+}
+function resumeChecklistItemFromStep(phase, step, kind, stepId) {
+    const item = {
+        id: `resume-${stepId}`,
+        kind,
+        phaseId: phase.id,
+        stepId,
+        status: step.status,
+        label: step.label,
+    };
+    appendChecklistStepFields(item, step);
+    return item;
+}
+function appendChecklistStepFields(item, step) {
+    addTruthyValue(item, 'command', step.command);
+    addTruthyValue(item, 'tool', step.tool);
+    addTruthyValue(item, 'args', step.args);
+    addTruthyValue(item, 'placeholder', step.placeholder);
+    addTruthyValue(item, 'instruction', step.instruction);
+    addNonEmptyStrings(item, 'blockedBy', step.blockedBy);
+    addNonEmptyStrings(item, 'dependsOn', step.dependsOn);
+    addNonEmptyStrings(item, 'unlocks', step.unlocks);
+}
+function currentChecklistKind(step) {
+    if (step.kind === 'input')
+        return 'resolve_input';
+    if (step.kind === 'proof')
+        return 'run_proof';
+    if (step.kind === 'criterion')
+        return 'confirm_done';
+    return 'run_current';
+}
+function resumeInputBindings(plan, cursor) {
+    const ids = uniqueStrings([
+        ...(cursor.kind === 'input' ? [cursor.stepId] : []),
+        ...(cursor.unlocks ?? []),
+    ]);
+    return ids.flatMap((id) => {
+        const found = findStepInPlan(plan, id);
+        if (!found || found.step.kind !== 'input' || !found.step.placeholder || !found.step.instruction)
+            return [];
+        const followUpIds = (found.step.unlocks ?? []).filter((unlockedId) => findStepInPlan(plan, unlockedId)?.phase.id === 'follow_up');
+        return [
+            {
+                inputId: found.step.id,
+                label: found.step.label,
+                placeholder: found.step.placeholder,
+                instruction: found.step.instruction,
+                followUpIds,
+            },
+        ];
+    });
+}
+function resumeFollowUps(plan, cursor) {
+    const followUpIds = new Set();
+    for (const id of cursor.unlocks ?? []) {
+        const found = findStepInPlan(plan, id);
+        if (!found)
+            continue;
+        if (found.phase.id === 'follow_up')
+            followUpIds.add(found.step.id);
+        for (const unlockedId of found.step.unlocks ?? []) {
+            const unlocked = findStepInPlan(plan, unlockedId);
+            if (unlocked?.phase.id === 'follow_up')
+                followUpIds.add(unlocked.step.id);
+        }
+    }
+    return Array.from(followUpIds).flatMap((id) => {
+        const found = findStepInPlan(plan, id);
+        if (!found)
+            return [];
+        return [
+            {
+                id: found.step.id,
+                phaseId: found.phase.id,
+                kind: found.step.kind,
+                status: found.step.status,
+                label: found.step.label,
+                ...(found.step.command ? { command: found.step.command } : {}),
+                ...(found.step.tool ? { tool: found.step.tool } : {}),
+                ...(found.step.args ? { args: found.step.args } : {}),
+                ...(found.step.blockedBy && found.step.blockedBy.length > 0
+                    ? { blockedBy: found.step.blockedBy }
+                    : {}),
+                ...(found.step.dependsOn && found.step.dependsOn.length > 0
+                    ? { dependsOn: found.step.dependsOn }
+                    : {}),
+            },
+        ];
+    });
+}
+function resumeToolCall(plan, cursor) {
+    const found = findStepInPlan(plan, cursor.stepId);
+    if (!found?.step.tool || !argsAreReady(found.step.args))
+        return undefined;
+    return {
+        tool: found.step.tool,
+        ...(typeof found.step.args !== 'undefined' ? { args: found.step.args } : {}),
+    };
+}
+function resolveResumeReferences(plan, ids) {
+    if (!ids || ids.length === 0)
+        return [];
+    const references = [];
+    for (const id of ids) {
+        const found = findStepInPlan(plan, id);
+        if (!found)
+            continue;
+        references.push({
+            id: found.step.id,
+            phaseId: found.phase.id,
+            kind: found.step.kind,
+            status: found.step.status,
+            label: found.step.label,
+            ...(found.step.instruction ? { instruction: found.step.instruction } : {}),
+            ...(found.step.command ? { command: found.step.command } : {}),
+            ...(found.step.placeholder ? { placeholder: found.step.placeholder } : {}),
+        });
+    }
+    return references;
+}
+function findStepInPlan(plan, id) {
+    for (const phase of plan.phases) {
+        for (const step of phase.steps) {
+            if (step.id === id)
+                return { phase, step };
+        }
+    }
+    return undefined;
+}
+function stepsForPhase(plan, phaseId) {
+    const phase = plan.phases.find((item) => item.id === phaseId);
+    return phase ? phase.steps.map((step) => ({ phase, step })) : [];
+}
+function resumeUnlocksSentence(unlocks, rawIds) {
+    if (unlocks.length > 0)
+        return ` This can unlock ${unlocks.map(formatResumeReferenceLabel).join(', ')}.`;
+    return rawIds && rawIds.length > 0 ? ` This can unlock ${rawIds.join(', ')}.` : '';
+}
+function resumeBlockersSentence(blockedBy, rawIds) {
+    if (blockedBy.length > 0)
+        return ` Blocked by ${blockedBy.map(formatResumeReferenceLabel).join(', ')}.`;
+    return rawIds && rawIds.length > 0 ? ` Blocked by ${rawIds.join(', ')}.` : '';
+}
+function formatResumeReferenceLabel(reference) {
+    return `${reference.id} (${reference.label})`;
+}
+export function executionCursor(phases) {
+    const selected = selectExecutionStep(phases);
+    return selected ? executionCursorFromSelection(selected) : fallbackExecutionCursor();
+}
+function selectExecutionStep(phases) {
+    for (const selector of CURSOR_SELECTORS) {
+        const selected = findExecutionStep(phases, selector);
+        if (selected)
+            return selected;
+    }
+    return undefined;
+}
+function fallbackExecutionCursor() {
+    return {
+        phaseId: 'done_when',
+        stepId: 'criterion-1',
+        status: 'pending',
+        kind: 'criterion',
+        label: 'The next action is complete and verified.',
+        reason: 'Use this criterion to decide when the task is complete.',
+    };
+}
+function executionCursorFromSelection(selected) {
+    const cursor = {
+        phaseId: selected.phase.id,
+        stepId: selected.step.id,
+        status: selected.step.status,
+        kind: selected.step.kind,
+        label: selected.step.label,
+        reason: executionCursorReason(selected.step),
+    };
+    appendCursorStepFields(cursor, selected.step);
+    return cursor;
+}
+function appendCursorStepFields(cursor, step) {
+    addTruthyValue(cursor, 'command', step.command);
+    addTruthyValue(cursor, 'tool', step.tool);
+    addDefinedValue(cursor, 'args', step.args);
+    addTruthyValue(cursor, 'instruction', step.instruction);
+    addTruthyValue(cursor, 'placeholder', step.placeholder);
+    addNonEmptyStrings(cursor, 'blockedBy', step.blockedBy);
+    addNonEmptyStrings(cursor, 'unlocks', step.unlocks);
+}
+function findExecutionStep(phases, predicate) {
+    for (const phase of phases) {
+        for (const step of phase.steps) {
+            if (predicate(phase, step))
+                return { phase, step };
+        }
+    }
+    return undefined;
+}
+function executionCursorReason(step) {
+    return (CURSOR_REASON_RULES.find((rule) => rule.matches(step))?.reason(step) ??
+        'Use this step as the current execution pointer.');
+}
+export function argsAreReady(value) {
+    if (typeof value === 'string')
+        return !isPlaceholder(value);
+    if (Array.isArray(value))
+        return value.every(argsAreReady);
+    if (value && typeof value === 'object')
+        return Object.values(value).every(argsAreReady);
+    return true;
+}
+export function isRunnableCommand(command) {
+    return !/<[^<>]+>/.test(command);
+}
+export function uniqueStrings(values) {
+    return [...new Set(values.filter((value) => value.length > 0))];
+}
+function addTruthyValue(target, key, value) {
+    if (value)
+        target[key] = value;
+}
+function addDefinedValue(target, key, value) {
+    if (typeof value !== 'undefined')
+        target[key] = value;
+}
+function addNonEmptyStrings(target, key, values) {
+    if (values && values.length > 0)
+        target[key] = values;
+}
+//# sourceMappingURL=startResume.js.map