open-multi-agent-kit 0.78.0

package/dist/commands/parallel/utils.js

@@ -0,0 +1,114 @@
+import { renderActionDigest, buildIntentFrame } from "../../goal/intent-frame.js";
+import { renderPromptDigest } from "../../goal/prompt-digest.js";
+export function normalizeApprovalPolicy(value, _profile) {
+    const v = value?.trim().toLowerCase();
+    if (v === "interactive" || v === "auto" || v === "yolo" || v === "block")
+        return v;
+    // Default: interactive for safety in parallel mode
+    return "interactive";
+}
+/**
+ * Returns the minimal OMK control block with critical authority ownership instructions.
+ * Used when no rich orchestrationPrompt is available (e.g. direct `omk parallel` calls).
+ */
+export function buildOmkMinimalControlBlock() {
+    return [
+        `OMK AUTHORITY & GUARDRAILS:`,
+        `- The configured OMK authority provider is the sole orchestrator, planner, merger, and final synthesis runtime. Never delegate merge, destructive shell, MCP routing, or final synthesis to any other provider.`,
+        `- Merge authority: Only the Authority provider resolves conflicts across parallel worker outputs and produces the final unified evidence.`,
+        `- MCP routing authority: Only the Authority provider assigns MCP servers, skills, and hooks to worker lanes. Workers request resources; they must not self-assign.`,
+        `- Synthesis authority: The Authority provider owns the final summary, verification report, and evidence aggregation. Workers produce scoped outputs; Authority merges.`,
+        `- Destructive operations: Shell commands with write/delete/install side effects must route through the Authority provider approval gate (unless approval policy is auto/yolo with explicit lane-level approval).`,
+    ].join("\n");
+}
+export function buildPromptText(goal, runId, profile, workerCount, mcpScope, intent, intentFrame = buildIntentFrame(goal), memorySummary, executionStrategy = "parallel", omkControlBlock) {
+    const taskType = intent?.taskType ?? "general";
+    const lines = [
+        `# Primary provider DAG Execution Envelope`,
+        ``,
+        `Primary provider must transform the orchestration context into node-level action. Do not echo the prompt, restart completed work, or ask for generic continuation.`,
+        ``,
+        `## Strict Intent / Action Digest`,
+        renderActionDigest(intentFrame),
+        ``,
+        `## Non-verbatim Source Digest`,
+        renderPromptDigest("Execution envelope digest", goal, { maxKeywords: 18, maxPhrases: 3 }),
+        `- raw prompt text: audit-only in run artifacts; not available for worker prompts.`,
+        ``,
+        `## Run Metadata`,
+        `Run ID: ${runId}`,
+        `Resource profile: ${profile}`,
+        `Worker budget: ${workerCount}`,
+        `MCP scope: ${mcpScope}`,
+        `Execution strategy: ${executionStrategy}`,
+        `Task type: ${taskType}`,
+    ];
+    if (memorySummary?.trim()) {
+        lines.push(``, `## Initial Memory Recall Summary`, memorySummary.trim().slice(0, 2_000));
+    }
+    if (intent) {
+        lines.push(`Complexity: ${intent.complexity}`, `Parallelizable: ${intent.parallelizable}`, `Required roles: ${intent.requiredRoles.join(", ")}`, `Read-only: ${intent.isReadOnly}`, ``);
+    }
+    if (executionStrategy === "sequential") {
+        lines.push(`Execute the goal one by one with a single primary provider worker lane.`, `- The coordinator plans the next scoped action before execution.`, `- Do not spawn parallel subagent, DeepSeek, or capability fanout lanes.`, `- The reviewer verifies the sequential output before final reporting.`, `- Produce concrete evidence, changed files, and verification results.`);
+    }
+    else {
+        lines.push(`Execute the goal using parallel agents.`, `- The coordinator plans and delegates.`, `- Workers execute scoped sub-tasks in parallel.`, `- The reviewer verifies and merges outputs.`, `- Produce concrete evidence, changed files, and verification results.`);
+    }
+    // Task-type specific guidance
+    if (taskType === "explore" || taskType === "research") {
+        lines.push(`- Each worker focuses on a distinct subsystem, module, or question.`, `- Synthesize findings across workers rather than editing code.`, `- Prefer read-only tools (Glob, Grep, ReadFile, SearchWeb).`);
+    }
+    else if (taskType === "bugfix") {
+        lines.push(`- First worker reproduces the bug; others explore root causes in parallel.`, `- Fix must be minimal and include a regression test.`, `- Run quality gates after the fix to verify no new failures.`);
+    }
+    else if (taskType === "refactor") {
+        lines.push(`- Preserve external behavior; run tests before and after.`, `- Each worker handles a distinct file group or abstraction layer.`, `- Coordinate interfaces between refactored boundaries.`);
+    }
+    else if (taskType === "review") {
+        lines.push(`- Each worker audits a different dimension: correctness, security, maintainability.`, `- Cite specific lines and file paths for every finding.`, `- Rank issues by severity (critical / warning / suggestion).`);
+    }
+    else if (taskType === "test") {
+        lines.push(`- Cover edge cases, failure paths, and happy paths in parallel.`, `- Verify test isolation and deterministic behavior.`, `- Report coverage delta explicitly.`);
+    }
+    else if (taskType === "security") {
+        lines.push(`- Audit trust boundaries, secret handling, and input validation.`, `- Do NOT commit or expose any discovered secrets.`, `- Provide concrete remediation steps with file references.`);
+    }
+    else if (taskType === "implement") {
+        lines.push(`- Follow existing code style and design conventions.`, `- Split work by component or file boundary when possible.`, `- Include tests and documentation for new surfaces.`);
+    }
+    // Always inject OMK Orchestration Control Block (minimal when no rich prompt is available)
+    const effectiveControlBlock = (omkControlBlock?.trim())
+        ? omkControlBlock.trim()
+        : buildOmkMinimalControlBlock();
+    lines.push(``, `## OMK Orchestration Control Block`, effectiveControlBlock);
+    lines.push(``, `PROVIDER FALLBACK:`, `- If a provider (including DeepSeek) becomes unavailable due to rate-limit, payment, or confidence, immediately fall back to the OMK authority provider and continue without blocking the DAG.`, `- Never stall the DAG waiting for a non-authority provider.`);
+    lines.push(``, `MEMORY RECALL (MANDATORY):`, `- Before planning, the coordinator MUST read memory-recall-summary.md and call omk_memory_mindmap or omk_search_memory when more detail is needed.`, `- Workers MUST only use skills and MCP servers relevant to their assigned role.`, ``, `MEMORY WRITEBACK (MANDATORY):`, `- After completing DAG nodes, write final decisions to .omk/memory/decisions.md.`, `- Write identified risks and mitigations to .omk/memory/risks.md.`, `- Use omk_write_memory or direct file write for persistence.`, ``, `SKILLS & MCP USAGE (MANDATORY):`, `- Activate relevant skills from the routing hints for each node.`, mcpScope === "none"
+        ? `- MCP scope is none for this run: do not launch MCP servers; rely on local tools and skills/hooks.`
+        : mcpScope === "project"
+            ? `- MCP scope is project for this run: use only project-local/builtin MCP servers such as omk-project.`
+            : `- MCP scope is all for this run: global and project MCP servers may be available; never expose secrets or raw config.`, `- Prefer omk-project MCP tools for checkpoint, memory, and run-state operations when MCP is enabled.`, `- Use SearchWeb / FetchURL for external docs, official APIs, or citations.`);
+    lines.push(``, `DEEPSEEK RESTRICTIONS: DeepSeek nodes are read-only advisory. Never assign merge, destructive shell, MCP routing, secret handling, or write authority to DeepSeek workers.`);
+    lines.push(``, `CONTINUE ENGINE:`, `- If this is a continuation, synthesize a fresh next prompt from Current Execution Context instead of repeating the goal objective.`, `- Do NOT redo completed work unless the evidence is invalid or stale.`, `- Focus on missing success criteria, failed evidence gates, and the highest-confidence next action.`, `- Re-select worker roles and MCP/skills based on the remaining work.`);
+    return lines.join("\n");
+}
+export function buildDeepSeekPromptPrefix(goalContext, runId, workerCount, intent, intentFrame = buildIntentFrame(goalContext)) {
+    const taskType = intent?.taskType ?? "general";
+    const lines = [
+        `OMK DeepSeek model-agent worker.`,
+        `Initial primary provider orchestration may spawn dedicated DeepSeek Flash/Pro read-only agents; opportunistic routing may also offload low-risk workers.`,
+        `Direct mode is read-only. For file-affecting advisory mode, propose patch strategy only; Authority provider owns actual edits, merge authority, and final synthesis.`,
+        `DeepSeek MUST NOT: merge, destructive shell, MCP routing, secret handling, write authority. DeepSeek is READ-ONLY advisory/composition only.`,
+        `Do not repeat or restart the user's original goal. Read the current primary provider / goal context below and answer only for the assigned DAG node.`,
+        ``,
+        `## Current Run Context`,
+        `- Run ID: ${runId}`,
+        `- Worker budget: ${workerCount}`,
+        `- Task type: ${taskType}`,
+    ];
+    if (intent) {
+        lines.push(`- Complexity: ${intent.complexity}`, `- Parallelizable: ${intent.parallelizable}`, `- Required roles: ${intent.requiredRoles.join(", ")}`, `- Read-only intent: ${intent.isReadOnly}`, `- Rationale: ${intent.rationale}`);
+    }
+    lines.push(``, `## Current Primary Provider Goal Action Digest`, renderActionDigest(intentFrame, { maxAtoms: 6 }), ``, `## Non-verbatim Context Digest`, renderPromptDigest("DeepSeek context digest", goalContext, { maxKeywords: 12, maxPhrases: 2 }), `- raw prompt text: unavailable to DeepSeek/model-advisory lanes.`);
+    return lines.join("\n");
+}

package/dist/commands/parallel/worker.d.ts

@@ -0,0 +1,43 @@
+import type { Dag } from "../../orchestration/dag.js";
+import type { RunState } from "../../contracts/orchestration.js";
+import type { ProviderPolicy } from "../../providers/index.js";
+import type { IntentFrame } from "../../contracts/goal.js";
+import type { ExecutionStrategy } from "../../contracts/orchestration.js";
+import { parseProviderModelArg } from "../../providers/model-registry.js";
+import { getOmkResourceSettings } from "../../util/resource-profile.js";
+export declare function normalizeWorkerCount(value: string | undefined, fallback: number): number;
+export declare function executeParallelRun(input: {
+    runId: string;
+    dag: Dag;
+    routedState: RunState;
+    statePath: string;
+    options: {
+        noPause?: boolean;
+        chat?: boolean;
+        signal?: AbortSignal;
+        timeoutPreset?: string;
+        alternateScreen?: boolean;
+        compact?: boolean;
+        view?: string;
+        noWatch?: boolean;
+        watch?: boolean;
+    };
+    root: string;
+    runDir: string;
+    resources: Awaited<ReturnType<typeof getOmkResourceSettings>>;
+    effectiveGoal: string;
+    workerCount: number;
+    approvalPolicy: "interactive" | "auto" | "yolo" | "block";
+    providerPolicy: ProviderPolicy;
+    modelArg: ReturnType<typeof parseProviderModelArg>;
+    mcpScope: "all" | "project" | "none";
+    executionPrompt: string;
+    agentFile: string;
+    promptText: string;
+    intentFrame: IntentFrame;
+    deepseekPromptPrefix: string;
+    executionStrategy: ExecutionStrategy;
+}): Promise<{
+    runId: string;
+    success: boolean;
+}>;

package/dist/commands/parallel/worker.js

@@ -0,0 +1,276 @@
+import { ParallelLiveRenderer, renderCompactParallelFrame } from "../../orchestration/parallel-ui.js";
+import { omkCliHero, style, status, label, bullet } from "../../util/theme.js";
+import { formatOmkVersionFooter } from "../../util/version.js";
+import { captureTerminalInputState, restoreTerminalInputState } from "../../util/terminal-input.js";
+import { createHarnessTaskRunner } from "../../harness/create-harness-task-runner.js";
+import { executeHarnessRun } from "../../harness/execute-harness-run.js";
+import { getActiveRuntimePreset } from "../../util/resource-profile.js";
+import { createOmkSessionEnv } from "../../util/session.js";
+import { t } from "../../util/i18n.js";
+import readline from "readline";
+import { isCapabilityAgentNode } from "../../orchestration/capability-agents.js";
+import { renderActionDigest } from "../../goal/intent-frame.js";
+export function normalizeWorkerCount(value, fallback) {
+    const effective = (value ?? process.env.OMK_WORKERS)?.trim();
+    if (!effective || effective === "auto")
+        return fallback;
+    if (!/^\d+$/.test(effective))
+        return fallback;
+    const parsed = Number(effective);
+    if (!Number.isInteger(parsed) || parsed < 1)
+        return fallback;
+    return Math.min(parsed, 6);
+}
+function buildWorkerLabels(state) {
+    const labels = {};
+    const withProvider = (node, base) => {
+        const provider = node.routing?.assignedProvider ?? node.routing?.provider;
+        return provider && provider !== "auto" ? `${base}@${provider}` : base;
+    };
+    const coordinator = state.nodes.find((n) => n.id === "root-coordinator" || n.id === "architect");
+    if (coordinator) {
+        labels[coordinator.id] = withProvider(coordinator, coordinator.role === "architect" ? "architect" : "planner");
+    }
+    const reviewer = state.nodes.find((n) => n.id === "review-merge" || n.role === "reviewer" || n.role === "aggregator");
+    if (reviewer) {
+        labels[reviewer.id] = withProvider(reviewer, reviewer.role === "aggregator" ? "aggregator" : "reviewer");
+    }
+    const security = state.nodes.find((n) => n.id === "security-audit");
+    if (security) {
+        labels[security.id] = withProvider(security, "security");
+    }
+    const design = state.nodes.find((n) => n.id === "design-review");
+    if (design) {
+        labels[design.id] = withProvider(design, "design");
+    }
+    const qa = state.nodes.find((n) => n.id === "quality-check");
+    if (qa) {
+        labels[qa.id] = withProvider(qa, qa.role === "tester" ? "tester" : "qa");
+    }
+    const workers = state.nodes.filter((n) => n.id.startsWith("worker-"));
+    const roleCounts = {};
+    workers.forEach((n) => {
+        const role = n.role ?? "coder";
+        roleCounts[role] = (roleCounts[role] ?? 0) + 1;
+        if (!labels[n.id]) {
+            labels[n.id] = withProvider(n, `${role}-${roleCounts[role]}`);
+        }
+    });
+    for (const node of state.nodes.filter((n) => n.id.startsWith("deepseek-"))) {
+        labels[node.id] = node.routing?.providerModelTier
+            ? `deepseek-${node.routing.providerModelTier}`
+            : "deepseek";
+    }
+    for (const node of state.nodes.filter((n) => isCapabilityAgentNode(n))) {
+        labels[node.id] = node.routing?.routeSource ? `capability-${node.routing.routeSource}` : "capability";
+    }
+    return labels;
+}
+function logRunStateTransitions(stateSnapshot, previousStatuses) {
+    for (const node of stateSnapshot.nodes) {
+        const previous = previousStatuses.get(node.id);
+        previousStatuses.set(node.id, node.status);
+        if (previous === node.status)
+            continue;
+        if (previous === undefined && node.status === "pending")
+            continue;
+        console.log(renderNodeTransition(node.id, node.name, node.status));
+    }
+}
+function renderNodeTransition(id, name, nodeStatus) {
+    const text = `${id}: ${name}`;
+    if (nodeStatus === "running")
+        return bullet(`running  ${text}`, "purple");
+    if (nodeStatus === "done")
+        return bullet(`done     ${text}`, "mint");
+    if (nodeStatus === "failed")
+        return bullet(`failed   ${text}`, "pink");
+    if (nodeStatus === "blocked")
+        return bullet(`blocked  ${text}`, "skin");
+    return bullet(`${nodeStatus}  ${text}`, "blue");
+}
+export async function executeParallelRun(input) {
+    const { runId, dag, routedState, statePath, options, root, runDir, resources, effectiveGoal, workerCount, approvalPolicy, providerPolicy, modelArg, mcpScope, agentFile, promptText, intentFrame, deepseekPromptPrefix, } = input;
+    const abortController = new AbortController();
+    if (options.signal) {
+        options.signal.addEventListener("abort", () => abortController.abort(), { once: true });
+    }
+    let shuttingDown = false;
+    let forceExitTimer;
+    function handleSignal() {
+        if (shuttingDown) {
+            if (options.noPause !== true) {
+                process.exit(1);
+            }
+            return;
+        }
+        shuttingDown = true;
+        abortController.abort();
+        // Force exit if graceful shutdown hangs (e.g. long-running node)
+        // In programmatic mode (noPause=true) we skip force-exit so callers can handle abort.
+        if (options.noPause !== true) {
+            forceExitTimer = setTimeout(() => process.exit(1), 5000);
+            forceExitTimer.unref?.();
+        }
+    }
+    process.once("SIGINT", handleSignal);
+    process.once("SIGTERM", handleSignal);
+    console.log(omkCliHero(formatOmkVersionFooter()));
+    console.log(style.phosphorBold("◈ omk parallel — DAG executor with live UI"));
+    console.log(style.gray(t("parallel.agentsActivated")));
+    // Determine TTY and mode defaults
+    const isTTY = Boolean(process.stdout.isTTY);
+    const useWatch = options.noWatch
+        ? false
+        : options.watch ?? isTTY;
+    const useAlternateScreen = options.alternateScreen === true;
+    const useCompact = options.compact === true || options.view === "compact";
+    const shouldPause = isTTY && options.noPause !== true;
+    // Build worker labels for the UI
+    const workerLabels = buildWorkerLabels(routedState);
+    // Enter alternate screen only when explicitly requested
+    if (useAlternateScreen && isTTY) {
+        process.stdout.write("\x1b[?1049h");
+    }
+    // ── Live parallel UI ──
+    let latestState = routedState;
+    const liveRenderer = new ParallelLiveRenderer({
+        runId,
+        approvalPolicy,
+        workerCount,
+        ensembleEnabled: resources.ensembleDefaultEnabled,
+        refreshMs: 1500,
+        goalTitle: effectiveGoal,
+        mode: useWatch ? "watch" : "no-watch",
+        workerLabels,
+        statePath,
+        view: options.view ?? (useCompact ? "compact" : "cockpit"),
+    });
+    const previousStatuses = new Map();
+    const handleStateChange = (stateSnapshot) => {
+        if (useWatch) {
+            latestState = stateSnapshot;
+            if (useCompact) {
+                const line = renderCompactParallelFrame(stateSnapshot, {
+                    runId,
+                    approvalPolicy,
+                    workerCount,
+                    ensembleEnabled: resources.ensembleDefaultEnabled,
+                    goalTitle: effectiveGoal,
+                    mode: "watch",
+                    workerLabels,
+                    statePath,
+                });
+                console.log(line);
+            }
+            return;
+        }
+        logRunStateTransitions(stateSnapshot, previousStatuses);
+    };
+    if (useWatch) {
+        if (!useCompact) {
+            liveRenderer.start(() => latestState);
+        }
+    }
+    const activePreset = await getActiveRuntimePreset();
+    const harnessEnv = {
+        ...createOmkSessionEnv(root, runId),
+        OMK_RUN_ID: runId,
+        OMK_FLOW: "parallel",
+        OMK_GOAL: intentFrame.desiredOutcome,
+        OMK_GOAL_CONTEXT: renderActionDigest(intentFrame),
+        OMK_WORKERS: String(workerCount),
+        OMK_DAG_ROUTING: "1",
+        OMK_DAG_STATE_PATH: statePath,
+        OMK_MCP_SCOPE: mcpScope,
+        OMK_SKILLS_SCOPE: resources.skillsScope,
+        OMK_APPROVAL_POLICY: approvalPolicy,
+        ...(modelArg.model ? { OMK_PROVIDER_MODEL: modelArg.model } : {}),
+    };
+    const runner = await createHarnessTaskRunner({
+        root,
+        runId,
+        mode: "parallel",
+        providerPolicy,
+        providerOptions: {
+            eventRunDir: runDir,
+            deepseekPromptPrefix,
+            allowDeepSeekAdvisoryFileNodes: true,
+            agentFile,
+            promptPrefix: promptText,
+            mcpScope,
+            skillsScope: resources.skillsScope,
+            hooksScope: resources.hooksScope,
+            mcpNames: activePreset?.mcpServers ?? [],
+            skillNames: activePreset?.skills ?? [],
+            hookNames: activePreset?.hooks ?? [],
+            toolNames: [],
+        },
+        env: harnessEnv,
+    });
+    let result;
+    try {
+        result = await executeHarnessRun({
+            root,
+            runId,
+            dag,
+            runner,
+            env: harnessEnv,
+            workers: workerCount,
+            approvalPolicy: approvalPolicy,
+            nodeTimeoutMs: options.timeoutPreset ? undefined : 600_000,
+            timeoutPreset: options.timeoutPreset,
+            resumeFromState: routedState,
+            eventRunDir: runDir,
+            ensemble: resources.ensembleDefaultEnabled ? {} : false,
+            signal: abortController.signal,
+            onStateChange: handleStateChange,
+        });
+    }
+    finally {
+        liveRenderer.stop();
+        process.off("SIGINT", handleSignal);
+        process.off("SIGTERM", handleSignal);
+        if (forceExitTimer) {
+            clearTimeout(forceExitTimer);
+            forceExitTimer = undefined;
+        }
+        // Restore original terminal screen before printing results/errors.
+        if (useAlternateScreen && isTTY) {
+            process.stdout.write("\x1b[?1049l");
+        }
+    }
+    console.log("");
+    if (result.success) {
+        console.log(status.ok("Parallel DAG run complete"));
+    }
+    else {
+        console.log(status.error("Parallel DAG run failed"));
+    }
+    console.log(label("State", statePath));
+    // ── Interactive handoff ──
+    if (options.chat && result.success) {
+        console.log(style.purple(t("parallel.complete")));
+        const { chatCommand } = await import("../chat.js");
+        await chatCommand({ runId });
+        return { runId, success: true };
+    }
+    // Pause so the user can read the result before the process exits
+    if (shouldPause) {
+        console.log(style.gray("\n  Press Enter to continue..."));
+        const terminalInputState = captureTerminalInputState(process.stdin);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        await new Promise((resolve) => {
+            rl.once("line", () => {
+                resolve();
+            });
+        }).finally(() => {
+            rl.close();
+            restoreTerminalInputState(process.stdin, terminalInputState);
+        });
+    }
+    return { runId, success: result.success };
+}

package/dist/commands/parallel.d.ts

@@ -0,0 +1,4 @@
+export { parallelCommand } from "./parallel/core.js";
+export type { ParallelCommandOptions } from "./parallel/core.js";
+export { buildDynamicNodes, buildParallelRouteDecision, createExecutableDagFromState, createInteractiveRunState, resolveParallelCommandExecutionDecision, } from "./parallel/orchestrator.js";
+export { normalizeWorkerCount } from "./parallel/worker.js";

package/dist/commands/parallel.js

@@ -0,0 +1,3 @@
+export { parallelCommand } from "./parallel/core.js";
+export { buildDynamicNodes, buildParallelRouteDecision, createExecutableDagFromState, createInteractiveRunState, resolveParallelCommandExecutionDecision, } from "./parallel/orchestrator.js";
+export { normalizeWorkerCount } from "./parallel/worker.js";

package/dist/commands/plan.d.ts

@@ -0,0 +1,6 @@
+export declare function planCommand(goal: string, options: {
+    thinking?: string;
+    runId?: string;
+    specKit?: boolean;
+    noSpecKit?: boolean;
+}): Promise<void>;

package/dist/commands/plan.js

@@ -0,0 +1,113 @@
+import { join } from "path";
+import { runShell } from "../util/shell.js";
+import { getOmkPath, getProjectRoot, pathExists, injectKimiGlobals, readTextFile } from "../util/fs.js";
+import { header, status, label } from "../util/theme.js";
+import { createOmkSessionEnv, createOmkSessionId } from "../util/session.js";
+import { t } from "../util/i18n.js";
+import { detectSpecKitContext, injectSpecKitPrompt } from "./spec.js";
+import { resolveSpecifyCli } from "./specify.js";
+import { getOmkResourceSettings } from "../util/resource-profile.js";
+import { defaultScopedRoleAgentFile, writeScopedAgentFile } from "../util/scoped-agent-file.js";
+export async function planCommand(goal, options) {
+    const root = getProjectRoot();
+    const agentFile = getOmkPath("agents/roles/architect.yaml");
+    const sessionId = createOmkSessionId("plan");
+    if (!(await pathExists(agentFile))) {
+        console.error(status.error(t("plan.architectMissing")));
+        process.exit(1);
+    }
+    // Determine spec-kit flag
+    let specFlag = "auto";
+    if (options.noSpecKit)
+        specFlag = "no";
+    else if (options.specKit)
+        specFlag = "yes";
+    const specCtx = await detectSpecKitContext(specFlag);
+    // If --spec-kit explicitly requested but no artifacts, try init
+    if (options.specKit && !specCtx.useSpecKit) {
+        const specifyDir = join(root, ".specify");
+        const hasSpecifyDir = await pathExists(specifyDir);
+        if (!hasSpecifyDir) {
+            if (process.stdin.isTTY) {
+                // Ask user
+                const { createInterface } = await import("readline");
+                const rl = createInterface({ input: process.stdin, output: process.stdout });
+                const answer = await new Promise((resolve) => {
+                    rl.question(".specify/ not found. Initialize spec-kit now? [y/N] ", (ans) => {
+                        rl.close();
+                        resolve(ans.trim().toLowerCase());
+                    });
+                });
+                if (answer === "y" || answer === "yes") {
+                    const cli = await resolveSpecifyCli();
+                    if (!cli) {
+                        console.error(status.error("spec-kit CLI not found. Install: pip install specify-cli"));
+                        process.exit(1);
+                    }
+                    const initResult = await runShell(cli.cmd, [...cli.args, "init", "--here"], {
+                        cwd: root,
+                        timeout: 60000,
+                        stdio: "inherit",
+                    });
+                    if (initResult.failed) {
+                        process.exit(initResult.exitCode);
+                    }
+                    // Re-detect after init
+                    const reloaded = await detectSpecKitContext("yes");
+                    Object.assign(specCtx, reloaded);
+                }
+            }
+            else {
+                // Non-TTY: read config
+                const config = await readTextFile(join(root, ".omk", "config.toml"), "");
+                const autoInitMatch = config.match(/^\s*auto_init\s*=\s*"([^"]+)"/m);
+                const autoInit = autoInitMatch?.[1] ?? "ask";
+                if (autoInit === "always") {
+                    const cli = await resolveSpecifyCli();
+                    if (cli) {
+                        await runShell(cli.cmd, [...cli.args, "init", "--here"], { cwd: root, timeout: 60000 });
+                        const reloaded = await detectSpecKitContext("yes");
+                        Object.assign(specCtx, reloaded);
+                    }
+                }
+            }
+        }
+    }
+    let promptText = t("plan.prompt", goal);
+    if (specCtx.useSpecKit) {
+        promptText = injectSpecKitPrompt(promptText, specCtx);
+        console.log(label("Spec Kit", "integrated"));
+    }
+    console.log(header(t("plan.header")));
+    console.log(label(t("plan.goalLabel"), goal) + "\n");
+    const env = createOmkSessionEnv(root, sessionId);
+    if (options.runId) {
+        env.OMK_RUN_ID = options.runId;
+    }
+    const resources = await getOmkResourceSettings();
+    const scopedAgentFile = await writeScopedAgentFile({
+        baseAgentFile: agentFile,
+        outputFile: defaultScopedRoleAgentFile(root, env.OMK_RUN_ID ?? sessionId, "architect"),
+        role: "architect",
+        resources,
+    });
+    const args = ["--print", "--output-format=stream-json"];
+    args.push("--agent-file", scopedAgentFile);
+    await injectKimiGlobals(args, {
+        role: "architect",
+        mcpScope: resources.mcpScope,
+        skillsScope: resources.skillsScope,
+        hooksScope: resources.hooksScope,
+    });
+    args.push("-p", promptText);
+    const result = await runShell("kimi", args, {
+        timeout: 120000,
+        cwd: root,
+        env,
+    });
+    console.log(result.stdout);
+    if (result.failed) {
+        console.error(result.stderr);
+        process.exit(result.exitCode);
+    }
+}

package/dist/commands/project-index.d.ts

@@ -0,0 +1,18 @@
+interface SymbolEntry {
+    name: string;
+    kind: "function" | "class" | "interface" | "type" | "enum" | "variable" | "unknown";
+    file: string;
+    line: number;
+    exported: boolean;
+}
+interface SymbolIndex {
+    generatedAt: string;
+    symbols: SymbolEntry[];
+}
+export declare function buildSymbolIndex(root: string): Promise<SymbolIndex>;
+export declare function indexCommand(options: {
+    changed?: boolean;
+    symbols?: boolean;
+}): Promise<void>;
+export declare function indexShowCommand(): Promise<void>;
+export {};