@devcxl/opencode-cabbage 0.3.2 → 1.1.0

package/dist/plugin/server.js

@@ -1,20 +1,37 @@
-import { tool } from "@opencode-ai/plugin/tool";
 import path from "node:path";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { existsSync } from "node:fs";
 import { initPrompts } from "./prompts.js";
 import { initBootstrap, getBootstrapContent } from "./bootstrap.js";
 import { loadCommands } from "./commands.js";
 import { setupSkillsDir } from "./skills.js";
 import { loadAgents } from "./agents.js";
-import { createIsolatedShellEnv, detectAmbientCredentials } from "./shell.js";
-import { createGoalClient, createGoalTool, readGoal, writeGoal, bindFlowRunRef, readFlowRunRef, checkFlowRunBlockers, MAX_CONTINUATIONS, continuationPrompt, formatGoal } from "./goal.js";
-import { FlowBroker } from "./broker.js";
-import { flowRunStart, flowStageStart, flowStageComplete, flowTaskStart, flowRunFinalize, } from "../flowrun/transitions.js";
-import { readFlowRun } from "../flowrun/github.js";
+import { createAgentShellEnv } from "./shell.js";
+import { createGoalClient, createGoalTool, readGoal, writeGoal, MAX_CONTINUATIONS, continuationPrompt, formatGoal } from "./goal.js";
+import { readIndex, updateFlowSession } from "../kernel/session-index.js";
+import { createSetupControlTool } from "./setup-control.js";
+import { createFlowControlTool } from "./flow-control.js";
+import { createTaskControlTool } from "./task-control.js";
+import { createTddCheckpointTool } from "./tdd-checkpoint.js";
+import { createReleaseControlTool } from "./release-control.js";
+import { getContextBlock, formatContextBlock, CONTEXT_MARKER } from "../kernel/context.js";
+import { readProjectProfile } from "../kernel/profile.js";
 const abortedSessions = new Set();
 const errorRetryCount = new Map();
 const COMPACTION_THRESHOLD = 20;
+/**
+ * 决定首条 user 消息注入内容：
+ * - Primary（goal 激活）→ bootstrap + Project Context 块
+ * - 子 agent → 仅 Project Context 块
+ * - 其他 → 不注入
+ */
+export function buildFirstUserInjection(input) {
+    const parts = [];
+    if (input.hasGoal)
+        parts.push(input.bootstrap);
+    if (input.contextBlock && (input.hasGoal || input.isSubAgent)) {
+        parts.push(input.contextBlock.block);
+    }
+    return parts.length > 0 ? parts.join("\n\n") : null;
+}
 export function configureGoalTools(config) {
     config.tools = { ...config.tools, goal: false };
     for (const [agentName, agent] of Object.entries(config.agent ?? {})) {
@@ -25,57 +42,68 @@ export function configureGoalTools(config) {
         agentConfig.tools = { ...agentConfig.tools, goal: canUseGoal };
     }
 }
-function sessionStatePath(projectDir) {
-    return path.join(projectDir, ".opencode", "opencode-cabbage", "session-state.json");
-}
-async function saveSessionState(projectDir, sessionID, goal) {
-    const dir = path.dirname(sessionStatePath(projectDir));
-    if (!existsSync(dir))
-        await mkdir(dir, { recursive: true });
-    await writeFile(sessionStatePath(projectDir), JSON.stringify({
-        sessionID,
-        status: goal.status,
-        updatedAt: Date.now(),
-    }), "utf8");
-}
-async function loadLastSession(projectDir) {
-    try {
-        const data = JSON.parse(await readFile(sessionStatePath(projectDir), "utf8"));
-        return data.status === "active" ? data.sessionID : null;
-    }
-    catch {
-        return null;
-    }
-}
-async function clearSessionState(projectDir) {
-    try {
-        await writeFile(sessionStatePath(projectDir), JSON.stringify({ status: "completed", updatedAt: Date.now() }), "utf8");
+/**
+ * config 层第二道门（spec §2.2）：按 caller 矩阵把 5 个生命周期工具
+ * 对每个 agent 置 true/false。agent 名 → 角色映射与 caller.ts ROLE_BY_AGENT 一致。
+ */
+export function configureLifecycleTools(config) {
+    const lifecycleTools = ["setup_control", "flow_control", "task_control", "tdd_checkpoint", "release_control"];
+    const agentRole = (name) => {
+        switch (name) {
+            case "dev-lifecycle": return "primary";
+            case "developer": return "developer";
+            case "architect": return "architect";
+            case "reviewer": return "reviewer";
+            case "goal-verify": return "goal-verify";
+            default: return "reviewer";
+        }
+    };
+    const canUseTool = (role, tool) => {
+        if (role === "goal-verify")
+            return tool === "flow_control";
+        switch (tool) {
+            case "tdd_checkpoint": return role === "primary" || role === "developer";
+            default: return role === "primary";
+        }
+    };
+    for (const [agentName, agent] of Object.entries(config.agent ?? {})) {
+        if (!agent || typeof agent !== "object" || Array.isArray(agent))
+            continue;
+        const agentConfig = agent;
+        const role = agentRole(agentName);
+        const toolFlags = {};
+        for (const toolName of lifecycleTools) {
+            toolFlags[toolName] = canUseTool(role, toolName);
+        }
+        agentConfig.tools = { ...agentConfig.tools, ...toolFlags };
     }
-    catch { }
 }
 async function queueContinuation(client, sessionID, projectDir) {
     const { goal } = await readGoal(client, sessionID);
     if (!goal || goal.status !== "active")
         return;
-    if (projectDir)
-        saveSessionState(projectDir, sessionID, goal);
+    if (projectDir) {
+        await updateFlowSession(projectDir, goal.parentIssueNumber, { status: goal.status, continuationCount: goal.continuationCount });
+    }
     if (abortedSessions.has(sessionID)) {
         abortedSessions.delete(sessionID);
         goal.status = "paused";
         await writeGoal(client, sessionID, goal);
         if (projectDir)
-            clearSessionState(projectDir);
+            await updateFlowSession(projectDir, goal.parentIssueNumber, { status: "paused" });
         return;
     }
     if (goal.continuationCount >= MAX_CONTINUATIONS) {
         goal.status = "paused";
         await writeGoal(client, sessionID, goal);
         if (projectDir)
-            clearSessionState(projectDir);
+            await updateFlowSession(projectDir, goal.parentIssueNumber, { status: "paused" });
         return;
     }
     goal.continuationCount++;
     await writeGoal(client, sessionID, goal);
+    if (projectDir)
+        await updateFlowSession(projectDir, goal.parentIssueNumber, { continuationCount: goal.continuationCount });
     try {
         if (goal.continuationCount > 0 && goal.continuationCount % COMPACTION_THRESHOLD === 0) {
             try {
@@ -86,9 +114,13 @@ async function queueContinuation(client, sessionID, projectDir) {
             }
             catch { }
         }
+        const contextBlock = projectDir ? await getContextBlock(projectDir) : null;
+        const contextText = contextBlock ? `${formatContextBlock(contextBlock)}\n\n` : "";
+        // 显式传回用户最后使用的 agent/模型，防止 idle 续接回落/切换默认 agent（如 build）
         await client.session.promptAsync({
             sessionID,
-            parts: [{ type: "text", text: continuationPrompt(goal.objective, goal.completionCriterion), synthetic: true }],
+            parts: [{ type: "text", text: contextText + continuationPrompt(goal.parentIssueNumber), synthetic: true }],
+            ...(goal.sessionProfile ? { agent: goal.sessionProfile.agent, model: goal.sessionProfile.model } : {}),
         });
     }
     catch (err) {
@@ -96,26 +128,29 @@ async function queueContinuation(client, sessionID, projectDir) {
     }
 }
 async function autoResume(client, projectDir) {
-    const lastSessionID = await loadLastSession(projectDir);
-    if (!lastSessionID)
-        return;
-    const { goal } = await readGoal(client, lastSessionID);
-    if (!goal || goal.status !== "active") {
-        await clearSessionState(projectDir);
-        return;
-    }
-    try {
-        await client.session.promptAsync({
-            sessionID: lastSessionID,
-            parts: [{
-                    type: "text",
-                    text: `[auto-resume] Plugin restarted. Resuming previous goal:\n\n${formatGoal(goal)}\n\nContinue working.`,
-                    synthetic: true,
-                }],
-        });
-    }
-    catch (err) {
-        console.error("[cabbage] auto-resume failed:", err);
+    const index = await readIndex(projectDir);
+    for (const [parentIssueNumber, entry] of Object.entries(index.flows)) {
+        if (entry.status !== "active")
+            continue;
+        const { goal } = await readGoal(client, entry.sessionID);
+        if (!goal || goal.status !== "active") {
+            await updateFlowSession(projectDir, Number(parentIssueNumber), { status: "paused" });
+            continue;
+        }
+        try {
+            await client.session.promptAsync({
+                sessionID: entry.sessionID,
+                parts: [{
+                        type: "text",
+                        text: `[auto-resume] Plugin restarted. Resuming previous goal:\n\n${formatGoal(goal)}\n\nContinue working.`,
+                        synthetic: true,
+                    }],
+                ...(goal.sessionProfile ? { agent: goal.sessionProfile.agent, model: goal.sessionProfile.model } : {}),
+            });
+        }
+        catch (err) {
+            console.error("[cabbage] auto-resume failed:", err);
+        }
     }
 }
 function getRetryKey(sessionID, phase) {
@@ -141,257 +176,40 @@ function startPeriodicCleanup() {
         errorRetryCount.clear();
     }, ABORTED_SESSION_CLEANUP_INTERVAL);
 }
-// ─── Flow Control Tool ───
-function createFlowControlTool(broker, goalClient) {
-    return tool({
-        description: `Control the FlowRun lifecycle: start a FlowRun, transition stages, start tasks, and finalize completed runs.
-
-Operations:
-- run-start: Transition FlowRun from planned → running. Binds Goal to FlowRun.
-- stage-start: Start a stage (requirements/design/tasks/code). Requires prerequisites met.
-- stage-complete: Complete a stage (requirements/design/tasks). Requires all checks pass.
-- task-start: Start a task (pending/ready → running). Freezes TDD policy and sets execution binding.
-- run-finalize: Mark code→test→review→merge stages as pass, set FlowRun to completed. Requires all Tasks merged. Idempotent.`,
-        args: {
-            op: tool.schema.enum(["run-start", "stage-start", "stage-complete", "task-start", "run-finalize"]).describe("Flow control operation"),
-            parent_issue_number: tool.schema.number().describe("Parent GitHub Issue number containing the FlowRun"),
-            stage: tool.schema.enum(["requirements", "design", "tasks", "code", "test", "review", "merge"]).optional().describe("Stage name (for stage-start/stage-complete)"),
-            task_id: tool.schema.string().optional().describe("Task ID (for task-start)"),
-            execution_binding: tool.schema.object({
-                branch: tool.schema.string(),
-                base_sha: tool.schema.string(),
-                start_head_sha: tool.schema.string(),
-                worktree_id: tool.schema.string(),
-                session_id: tool.schema.string(),
-            }).optional().describe("Execution binding for task-start"),
-            tdd_policy_json: tool.schema.string().optional().describe("JSON string of frozen TDD policy (for task-start)"),
-        },
-        async execute(args, ctx) {
-            const sessionID = ctx.sessionID;
-            const op = args.op;
-            const parentIssueNumber = args.parent_issue_number;
-            try {
-                switch (op) {
-                    case "run-start":
-                        return handleRunStart(broker, goalClient, parentIssueNumber, sessionID);
-                    case "stage-start":
-                        return handleStageStart(broker, parentIssueNumber, args.stage);
-                    case "stage-complete":
-                        return handleStageComplete(broker, parentIssueNumber, args.stage);
-                    case "task-start":
-                        return handleTaskStart(broker, parentIssueNumber, args.task_id, args.execution_binding, args.tdd_policy_json);
-                    case "run-finalize":
-                        return handleRunFinalize(broker, parentIssueNumber);
-                    default:
-                        return errorResponse("UNKNOWN_OP", `Unknown operation: "${op}"`);
-                }
-            }
-            catch (err) {
-                return errorResponse("INTERNAL_ERROR", String(err));
-            }
-        },
-    });
-}
-function okResponse(overrides = {}) {
-    const resp = { ok: true, ...overrides };
-    return JSON.stringify(resp, null, 2);
-}
-function errorResponse(code, message) {
-    const resp = { ok: false, error: { code, message } };
-    return JSON.stringify(resp, null, 2);
-}
-async function handleRunStart(broker, goalClient, parentIssueNumber, sessionID) {
-    // 通过 broker 执行状态迁移
-    const writeResult = await broker.writeFlowRunWithLock(parentIssueNumber, (flowRun) => {
-        const res = flowRunStart(flowRun);
-        if (!res.ok) {
-            return { flowRun, result: res.error, shouldPersist: false };
-        }
-        return { flowRun: res.value, result: res.value.status, shouldPersist: true };
-    });
-    if (!writeResult.ok) {
-        return errorResponse(writeResult.code, writeResult.message);
-    }
-    if (!writeResult.persisted) {
-        // 状态迁移被拒绝（如已是 running）
-        return errorResponse("INVALID_TRANSITION", "FlowRun is not in planned state");
-    }
-    // 绑定 Goal → FlowRun
-    const actualFlowRunId = writeResult.flowRun.flowRunId;
-    const bindResult = await bindFlowRunRef(goalClient, sessionID, {
-        repo: writeResult.flowRun.repo,
-        parentIssueNumber,
-        flowRunId: actualFlowRunId,
-    });
-    if (!bindResult.ok) {
-        return errorResponse(bindResult.code, bindResult.message);
-    }
-    return okResponse({
-        flowRunStatus: writeResult.flowRun.status,
-    });
-}
-async function handleStageStart(broker, parentIssueNumber, stageName) {
-    if (!stageName) {
-        return errorResponse("POLICY_INVALID", "stage is required for stage-start");
-    }
-    const writeResult = await broker.writeFlowRunWithLock(parentIssueNumber, (flowRun) => {
-        const res = flowStageStart(flowRun, stageName);
-        if (!res.ok) {
-            return { flowRun, result: res.error, shouldPersist: false };
-        }
-        return {
-            flowRun: res.value,
-            result: { stage: stageName, status: res.value.stages[stageName].status },
-            shouldPersist: true,
-        };
-    });
-    if (!writeResult.ok) {
-        return errorResponse(writeResult.code, writeResult.message);
-    }
-    if (!writeResult.persisted && writeResult.result && typeof writeResult.result === "object" && "code" in writeResult.result) {
-        const err = writeResult.result;
-        return errorResponse(err.code, err.message);
-    }
-    return okResponse({
-        flowRunStatus: writeResult.flowRun.status,
-        stage: writeResult.result,
-    });
-}
-async function handleStageComplete(broker, parentIssueNumber, stageName) {
-    if (!stageName) {
-        return errorResponse("POLICY_INVALID", "stage is required for stage-complete");
-    }
-    const writeResult = await broker.writeFlowRunWithLock(parentIssueNumber, (flowRun) => {
-        const res = flowStageComplete(flowRun, stageName);
-        if (!res.ok) {
-            return { flowRun, result: res.error, shouldPersist: false };
-        }
-        return {
-            flowRun: res.value,
-            result: { stage: stageName, status: res.value.stages[stageName].status },
-            shouldPersist: true,
-        };
-    });
-    if (!writeResult.ok) {
-        return errorResponse(writeResult.code, writeResult.message);
-    }
-    if (!writeResult.persisted && writeResult.result && typeof writeResult.result === "object" && "code" in writeResult.result) {
-        const err = writeResult.result;
-        return errorResponse(err.code, err.message);
-    }
-    return okResponse({
-        flowRunStatus: writeResult.flowRun.status,
-        stage: writeResult.result,
-    });
-}
-async function handleTaskStart(broker, parentIssueNumber, taskId, executionBinding, tddPolicyJson) {
-    if (!taskId) {
-        return errorResponse("POLICY_INVALID", "task_id is required for task-start");
-    }
-    if (!executionBinding) {
-        return errorResponse("POLICY_INVALID", "execution_binding is required for task-start");
-    }
-    // 解析 frozen policy
-    let tddPolicy = undefined;
-    if (tddPolicyJson) {
-        try {
-            tddPolicy = JSON.parse(tddPolicyJson);
-        }
-        catch {
-            return errorResponse("POLICY_INVALID", "tdd_policy_json is not valid JSON");
-        }
-    }
-    const writeResult = await broker.writeFlowRunWithLock(parentIssueNumber, (flowRun) => {
-        const res = flowTaskStart(flowRun, taskId, executionBinding, tddPolicy);
-        if (!res.ok) {
-            return { flowRun, result: res.error, shouldPersist: false };
-        }
-        return {
-            flowRun: res.value.flowRun,
-            result: {
-                taskId,
-                status: res.value.task.status,
-                executionBinding: res.value.task.executionBinding,
-            },
-            shouldPersist: true,
-        };
-    });
-    if (!writeResult.ok) {
-        return errorResponse(writeResult.code, writeResult.message);
-    }
-    if (!writeResult.persisted && writeResult.result && typeof writeResult.result === "object" && "code" in writeResult.result) {
-        const err = writeResult.result;
-        return errorResponse(err.code, err.message);
-    }
-    return okResponse({
-        flowRunStatus: writeResult.flowRun.status,
-        task: writeResult.result,
-    });
-}
-async function handleRunFinalize(broker, parentIssueNumber) {
-    const writeResult = await broker.writeFlowRunWithLock(parentIssueNumber, (flowRun) => {
-        const res = flowRunFinalize(flowRun);
-        if (!res.ok) {
-            return { flowRun, result: res.error, shouldPersist: false };
-        }
-        return {
-            flowRun: res.value,
-            result: { status: res.value.status, completedAt: res.value.completedAt },
-            shouldPersist: true,
-        };
-    });
-    if (!writeResult.ok) {
-        return errorResponse(writeResult.code, writeResult.message);
-    }
-    if (!writeResult.persisted && writeResult.result && typeof writeResult.result === "object" && "code" in writeResult.result) {
-        const err = writeResult.result;
-        return errorResponse(err.code, err.message);
-    }
-    return okResponse({
-        flowRunStatus: writeResult.flowRun.status,
-    });
-}
 export function createOpencodeCabbage(packageRoot) {
     return async (ctx, _options) => {
         const sourceSkillsDir = path.join(packageRoot, "assets", "skills");
-        const contextDir = path.join(packageRoot, "assets", "context");
         const promptsDir = path.join(packageRoot, "assets", "prompts");
         const commandsDir = path.join(packageRoot, "assets", "commands");
-        const skillsDir = await setupSkillsDir(sourceSkillsDir, contextDir, promptsDir);
+        const skillsDir = await setupSkillsDir(sourceSkillsDir, promptsDir);
         const projectDir = ctx.worktree || ctx.directory;
         const v1Client = ctx.client._client;
         const goalClient = createGoalClient(ctx.serverUrl, v1Client);
-        const goalTool = createGoalTool(goalClient, async (parentSessionID) => {
-            // 验证绑定的 FlowRun 是否已终态
-            const ref = await readFlowRunRef(goalClient, parentSessionID);
-            if (!ref)
-                return null; // 无 FlowRun 绑定，允许完成
-            // 读取 FlowRun 状态
-            const flowResult = await readFlowRun(ref.parentIssueNumber);
-            if (!flowResult.ok) {
-                return `Failed to read FlowRun #${ref.parentIssueNumber}: ${flowResult.code}`;
-            }
-            return checkFlowRunBlockers(flowResult.data.status);
-        });
-        const broker = new FlowBroker();
-        const flowControlTool = createFlowControlTool(broker, goalClient);
+        const goalTool = createGoalTool(goalClient);
+        const sessionClient = goalClient;
+        const flowControlTool = createFlowControlTool({ projectDir, sessionClient });
+        const taskControlTool = createTaskControlTool({ projectDir, sessionClient });
+        const setupControlTool = createSetupControlTool({ projectDir, sessionClient });
+        const tddCheckpointTool = createTddCheckpointTool({ projectDir, sessionClient });
+        const releaseControlTool = createReleaseControlTool({ projectDir, sessionClient });
         const agentsDir = path.join(packageRoot, "assets", "agents");
         await initPrompts(packageRoot, projectDir);
         await initBootstrap();
         startPeriodicCleanup();
-        autoResume(goalClient, projectDir);
+        void autoResume(goalClient, projectDir).catch(err => {
+            console.error("[cabbage] auto-resume failed:", err);
+        });
         return {
             tool: {
                 goal: goalTool,
                 flow_control: flowControlTool,
+                task_control: taskControlTool,
+                setup_control: setupControlTool,
+                tdd_checkpoint: tddCheckpointTool,
+                release_control: releaseControlTool,
             },
             config: async (rawConfig) => {
                 const config = rawConfig;
-                // ── Ambient credential 检测 ──
-                const ambientReport = detectAmbientCredentials();
-                if (ambientReport.hasWriteCredentials) {
-                    console.warn("[cabbage] ⚠️  检测到可用 GitHub 写凭证，Runtime enforcement 已降级为 advisory:", ambientReport.sources.map(s => s.location).join(", "));
-                }
                 config.skills = config.skills || {};
                 config.skills.paths = config.skills.paths || [];
                 if (!config.skills.paths.includes(skillsDir)) {
@@ -410,6 +228,31 @@ export function createOpencodeCabbage(packageRoot) {
                     };
                 }
                 config.agent = config.agent || {};
+                // 渲染 permission 占位符：`<profile-test-command>` → Profile.testCommand 首 token（§9.1）
+                const profile = await readProjectProfile(projectDir);
+                const testCommandToken = profile.testCommand?.split(" ")[0] ?? "";
+                const renderPermission = (perm) => {
+                    if (!perm)
+                        return perm;
+                    const renderRules = (rules) => {
+                        if (!rules)
+                            return rules;
+                        const out = {};
+                        for (const [pattern, action] of Object.entries(rules)) {
+                            if (pattern.includes("<profile-test-command>") && testCommandToken === "") {
+                                // Profile 未配置测试命令 → 删除占位规则，避免渲染成 "*" 覆盖兜底 deny
+                                continue;
+                            }
+                            out[pattern.replaceAll("<profile-test-command>", testCommandToken)] = action;
+                        }
+                        return out;
+                    };
+                    const out = { ...perm };
+                    if (perm.bash && typeof perm.bash === "object" && !Array.isArray(perm.bash)) {
+                        out.bash = renderRules(perm.bash);
+                    }
+                    return out;
+                };
                 for (const agent of loadAgents(agentsDir)) {
                     if (config.agent[agent.key])
                         continue;
@@ -418,14 +261,14 @@ export function createOpencodeCabbage(packageRoot) {
                         mode: agent.mode,
                         color: agent.color,
                         prompt: agent.prompt,
-                        tools: agent.tools ?? { read: true, bash: true, edit: true },
-                        permission: agent.permission,
+                        permission: renderPermission(agent.permission),
                         shell: {
-                            env: createIsolatedShellEnv(agent),
+                            env: createAgentShellEnv(),
                         },
                     };
                 }
                 configureGoalTools(config);
+                configureLifecycleTools(config);
             },
             "experimental.chat.messages.transform": async (_input, output) => {
                 if (!output.messages.length)
@@ -433,13 +276,20 @@ export function createOpencodeCabbage(packageRoot) {
                 const firstUser = output.messages.find(m => m.info.role === "user");
                 if (!firstUser || !firstUser.parts.length)
                     return;
-                if (firstUser.parts.some(p => p.type === "text" && p.text.includes("EXTREMELY_IMPORTANT")))
+                if (firstUser.parts.some(p => p.type === "text" && (p.text.includes("EXTREMELY_IMPORTANT") || p.text.includes(CONTEXT_MARKER))))
                     return;
-                // Only inject bootstrap for active flow: goal is active or user sent a flow command
-                const hasGoal = await readGoal(goalClient, output.messages[0].info.sessionID).then(r => r.goal?.status === "active").catch(() => false);
-                if (!hasGoal)
-                    return;
-                firstUser.parts.unshift({ type: "text", text: getBootstrapContent() });
+                const sessionID = output.messages[0].info.sessionID;
+                const { goal, session } = await readGoal(goalClient, sessionID);
+                const contextBlock = await getContextBlock(projectDir);
+                const injection = buildFirstUserInjection({
+                    hasGoal: goal?.status === "active",
+                    isSubAgent: !!session?.parentID,
+                    contextBlock,
+                    bootstrap: getBootstrapContent(),
+                });
+                if (injection) {
+                    firstUser.parts.unshift({ type: "text", text: injection });
+                }
             },
             async event({ event }) {
                 const evt = event;
@@ -453,10 +303,18 @@ export function createOpencodeCabbage(packageRoot) {
                 if (evt.type === "session.status" && evt.properties?.status?.type === "idle") {
                     const sessionID = evt.properties.sessionID;
                     if (sessionID) {
-                        const result = await goalClient.session.get({ sessionID });
-                        if (result?.data?.parentID)
+                        try {
+                            const result = await goalClient.session.get({ sessionID });
+                            if (result?.data?.parentID)
+                                return;
+                        }
+                        catch (err) {
+                            console.error("[cabbage] session lookup failed:", err);
                             return;
-                        void queueContinuation(goalClient, sessionID, projectDir);
+                        }
+                        void queueContinuation(goalClient, sessionID, projectDir).catch(err => {
+                            console.error("[cabbage] continuation failed:", err);
+                        });
                     }
                 }
                 if (evt.type === "session.status" && evt.properties?.status?.type === "error") {
@@ -466,24 +324,36 @@ export function createOpencodeCabbage(packageRoot) {
                         const action = shouldEscalate(sessionID, phase);
                         const { goal } = await readGoal(goalClient, sessionID);
                         if (action === "retry" && goal) {
-                            await goalClient.session.promptAsync({
-                                sessionID,
-                                parts: [{
-                                        type: "text",
-                                        text: `[auto-retry] Previous attempt failed. Try a different approach.\n\nGoal: ${goal.objective}`,
-                                        synthetic: true,
-                                    }],
-                            });
+                            try {
+                                await goalClient.session.promptAsync({
+                                    sessionID,
+                                    parts: [{
+                                            type: "text",
+                                            text: `[auto-retry] Previous attempt failed. Try a different approach.\n\n${formatGoal(goal)}`,
+                                            synthetic: true,
+                                        }],
+                                    ...(goal.sessionProfile ? { agent: goal.sessionProfile.agent, model: goal.sessionProfile.model } : {}),
+                                });
+                            }
+                            catch (err) {
+                                console.error("[cabbage] auto-retry prompt failed:", err);
+                            }
                         }
                         else if (action === "skip" && goal) {
-                            await goalClient.session.promptAsync({
-                                sessionID,
-                                parts: [{
-                                        type: "text",
-                                        text: `[skip] Skipping failed step. Continue with remaining work.\n\nGoal: ${goal.objective}`,
-                                        synthetic: true,
-                                    }],
-                            });
+                            try {
+                                await goalClient.session.promptAsync({
+                                    sessionID,
+                                    parts: [{
+                                            type: "text",
+                                            text: `[skip] Skipping failed step. Continue with remaining work.\n\n${formatGoal(goal)}`,
+                                            synthetic: true,
+                                        }],
+                                    ...(goal.sessionProfile ? { agent: goal.sessionProfile.agent, model: goal.sessionProfile.model } : {}),
+                                });
+                            }
+                            catch (err) {
+                                console.error("[cabbage] auto-skip prompt failed:", err);
+                            }
                         }
                     }
                 }
@@ -494,6 +364,14 @@ export function createOpencodeCabbage(packageRoot) {
                         const { goal, session } = await readGoal(goalClient, sessionID);
                         if (goal) {
                             goal.continuationCount = 0;
+                            // 刷新用户最后使用的 agent/模型快照（用户在 TUI 切换 agent/模型后发消息）
+                            const info = evt.properties.info;
+                            if (info?.agent) {
+                                goal.sessionProfile = {
+                                    agent: info.agent,
+                                    model: info.model?.providerID ? { providerID: info.model.providerID, modelID: info.model.modelID } : goal.sessionProfile?.model,
+                                };
+                            }
                             await writeGoal(goalClient, sessionID, goal, session ?? undefined);
                         }
                     }
@@ -503,7 +381,7 @@ export function createOpencodeCabbage(packageRoot) {
                     if (sessionID) {
                         const { goal } = await readGoal(goalClient, sessionID);
                         if (goal?.status === "complete") {
-                            await clearSessionState(projectDir);
+                            await updateFlowSession(projectDir, goal.parentIssueNumber, { status: "completed" });
                         }
                     }
                 }