botmux 2.93.1 → 2.95.0

package/dist/daemon.js

@@ -15,7 +15,7 @@ import { sendRestartReportIfPending } from './core/restart-report.js';
 import { statSync } from 'node:fs';
 import { addReaction, getChatMode, listChatMemberOpenIds, replyMessage, resolveAllowedUsersWithMap, sendMessage, sendUserMessage, updateMessage } from './im/lark/client.js';
 import { resolveGroupJoinPrompt, waitForAllowedUserInChat } from './core/auto-start.js';
-import { loadBotConfigs, registerBot, getBot, getAllBots, findOncallChat } from './bot-registry.js';
+import { loadBotConfigs, registerBot, getBot, getAllBots, findOncallChat, effectiveDefaultWorkingDir } from './bot-registry.js';
 import * as sessionStore from './services/session-store.js';
 import * as chatFirstSeenStore from './services/chat-first-seen-store.js';
 import { ensureDefaultOncallBound } from './services/oncall-store.js';
@@ -54,8 +54,18 @@ import { beginReplyTargetTurn, fallbackTurnId, resolveSessionReplyTarget, syncRe
 import { sweepOrphanSandboxes } from './adapters/backend/sandbox.js';
 import { sweepIdleWorkers, DEFAULT_MAX_LIVE_WORKERS } from './core/idle-worker-sweeper.js';
 import { handleCardAction } from './im/lark/card-handler.js';
-import { executeWorkflowCommand, parseWorkflowCommand, resolveBotSnapshot, } from './im/lark/workflow-slash-command.js';
+import { executeWorkflowCommand, parseWorkflowCommand, parseWorkflowGrillTrigger, buildWorkflowGrillPrompt, resolveBotSnapshot, WORKFLOW_USAGE, WORKFLOW_V2_RENAME_NOTICE, } from './im/lark/workflow-slash-command.js';
 import { workflowRunDetailUrl } from './im/lark/workflow-cards.js';
+import { createV3GateRunner, requestV3Retry, requestV3LoopGrant } from './workflows/v3/daemon-run.js';
+import { buildV3GateCard } from './im/lark/v3-gate-card.js';
+import { buildV3BlockedCard } from './im/lark/v3-blocked-card.js';
+import { buildV3LoopGrantCard } from './im/lark/v3-loop-grant-card.js';
+import { buildV3RevisitGrantCard } from './im/lark/v3-revisit-grant-card.js';
+import { isValidRunId as isValidV3RunId } from './workflows/v3/ops-projection.js';
+import { readRunChatBinding as readV3RunChatBinding, defaultBaseDir as v3DefaultBaseDir } from './workflows/v3/grill-state.js';
+/** This daemon process's bot larkAppId (set in startDaemon).  Used to scope v3
+ *  humanGate cold-attach + start to runs this bot owns (codex blocker #1). */
+let selfV3LarkAppId;
 import { buildWorkflowStartingCard, buildWorkflowProgressCard, buildAttemptDeeplinkEnricher, } from './im/lark/workflow-progress-card.js';
 import { EventLog as WorkflowEventLog } from './workflows/events/append.js';
 import { replay as replayWorkflow } from './workflows/events/replay.js';
@@ -1089,6 +1099,13 @@ function workflowSpawnFn() {
     return createDaemonSpawnFn(daemonDeps);
 }
 async function handleWorkflowCommandIfAny(content, anchor, chatId, larkAppId, initiator) {
+    // 旧 `/workflow run|cancel` 软降级：在执行前**先**发改名提示，让迁移指引第一时间
+    // 到达用户（codex review：先发优于后发）。从原始 content 判定而非 parse 结果，
+    // 这样连 `/workflow run`（缺 id）这类 invalid legacy 也能收到提示（codex review）。
+    // 仅匹配 legacy 的 run|cancel（executeWorkflowCommand 必然 handle），不误伤 /template。
+    if (/^\/workflow\s+(run|cancel)\b/.test(content.trim())) {
+        await sessionReply(anchor, WORKFLOW_V2_RENAME_NOTICE, 'text', larkAppId);
+    }
     // Captured by the `onRunCreated` closure so the trailing text reply can be
     // suppressed when the run-level progress card already landed.  Codex
     // round 1 medium: "single self-updating tile" promise breaks if we also
@@ -1265,6 +1282,96 @@ function fireSessionlessCommandDetached(cmd, anchor, message, larkAppId) {
     void handleCommand(cmd, anchor, message, commandDeps, larkAppId).catch((err) => logger.error(`[sessionless ${cmd}] ${anchor.substring(0, 12)} failed: ${err?.message ?? err}`));
 }
 // Dependencies passed to card-handler
+// v3 humanGate run-controller: drives daemon-side v3 runs, posts/​re-posts
+// approval cards to the run's bound topic, and re-arms pending gates on startup
+// (cold-attach).  postCard / notifyTerminal use the daemon's Lark sender; the
+// run logic + in-flight guard live in createV3GateRunner.
+const v3GateRunner = createV3GateRunner({
+    postCard: async (binding, gate, runId) => {
+        const card = buildV3GateCard({
+            runId,
+            waitId: gate.waitId,
+            nodeId: gate.nodeId,
+            prompt: gate.prompt,
+            options: gate.options,
+            approveOptions: gate.approveOptions,
+            approvers: gate.approvers,
+        });
+        // codex blocker #3: never silently skip — a missing rootMessageId would
+        // leave the run stuck at awaitingGate forever.  Reply in-thread when we have
+        // an anchor; otherwise post to the chat directly.
+        if (binding.rootMessageId) {
+            await sessionReply(binding.rootMessageId, card, 'interactive', binding.larkAppId);
+        }
+        else {
+            await sendMessage(binding.larkAppId, binding.chatId, card, 'interactive');
+        }
+    },
+    postBlockedCard: async (binding, info, runId) => {
+        const card = buildV3BlockedCard({
+            runId,
+            nodeId: info.nodeId,
+            attemptId: info.attemptId,
+            errorClass: info.errorClass,
+            errorCode: info.errorCode,
+            message: info.message,
+            // human-ask 受阻 → 渲染问题 + 选项按钮卡（替代纯重试卡）。
+            ...(info.ask ? { ask: info.ask } : {}),
+        });
+        if (binding.rootMessageId) {
+            await sessionReply(binding.rootMessageId, card, 'interactive', binding.larkAppId);
+        }
+        else {
+            await sendMessage(binding.larkAppId, binding.chatId, card, 'interactive');
+        }
+    },
+    postLoopGrantCard: async (binding, info, runId) => {
+        const card = buildV3LoopGrantCard({
+            runId,
+            loopId: info.loopId,
+            iteration: info.iteration,
+            maxIterations: info.maxIterations,
+            granted: info.granted,
+            detail: info.detail,
+        });
+        if (binding.rootMessageId) {
+            await sessionReply(binding.rootMessageId, card, 'interactive', binding.larkAppId);
+        }
+        else {
+            await sendMessage(binding.larkAppId, binding.chatId, card, 'interactive');
+        }
+    },
+    postRevisitGrantCard: async (binding, info, runId) => {
+        const card = buildV3RevisitGrantCard({
+            runId,
+            sourceNodeId: info.sourceNodeId,
+            toNodeId: info.toNodeId,
+            tier: info.tier,
+            attemptId: info.attemptId,
+            detail: info.detail,
+        });
+        if (binding.rootMessageId) {
+            await sessionReply(binding.rootMessageId, card, 'interactive', binding.larkAppId);
+        }
+        else {
+            await sendMessage(binding.larkAppId, binding.chatId, card, 'interactive');
+        }
+    },
+    notifyTerminal: async (binding, runId, outcome) => {
+        if (!binding?.rootMessageId)
+            return;
+        const msg = outcome.runStatus === 'succeeded'
+            ? `✅ v3 workflow \`${runId}\` 跑完了`
+            : outcome.runStatus === 'blocked'
+                // Fallback only — the blocked path normally posts a retry/grant card instead.
+                ? `⏸️ v3 workflow \`${runId}\` 受阻${outcome.blockedNodeId ? `（节点 ${outcome.blockedNodeId}）` : ''}，可 \`botmux workflow retry ${runId}\` 重试（loop 耗尽则 \`botmux workflow grant ${runId}\` 追加一轮）`
+                : `❌ v3 workflow \`${runId}\` 失败${outcome.failedNodeId ? `（节点 ${outcome.failedNodeId}）` : ''}`;
+        await sessionReply(binding.rootMessageId, msg, 'text', binding.larkAppId).catch(() => { });
+    },
+    onError: (runId, err) => {
+        logger.warn(`[v3:${runId}] drive failed: ${err instanceof Error ? err.message : String(err)}`);
+    },
+});
 const cardDeps = {
     activeSessions,
     sessionReply,
@@ -1274,6 +1381,24 @@ const cardDeps = {
             logger.warn(`[workflow:${runId}] re-entry after approval failed: ${err instanceof Error ? err.message : String(err)}`);
         });
     },
+    v3GateDeps: {
+        driveRun: (runId) => v3GateRunner.driveDetached(runId),
+        // 审批权限：复用 canOperate（话题 owner / allowedUsers / oncall）。无 binding（corrupt /
+        // 非 grill 出生的旧卡）→ **拒**（codex follow-up：合法卡一定有 binding，缺失即可疑）.
+        canResolve: (binding, operatorOpenId) => binding ? canOperate(binding.larkAppId, binding.chatId, operatorOpenId) : false,
+    },
+    v3BlockedDeps: {
+        driveRun: (runId) => v3GateRunner.driveDetached(runId),
+        canResolve: (binding, operatorOpenId) => binding ? canOperate(binding.larkAppId, binding.chatId, operatorOpenId) : false,
+    },
+    v3LoopGrantDeps: {
+        driveRun: (runId) => v3GateRunner.driveDetached(runId),
+        canResolve: (binding, operatorOpenId) => binding ? canOperate(binding.larkAppId, binding.chatId, operatorOpenId) : false,
+    },
+    v3RevisitGrantDeps: {
+        driveRun: (runId) => v3GateRunner.driveDetached(runId),
+        canResolve: (binding, operatorOpenId) => binding ? canOperate(binding.larkAppId, binding.chatId, operatorOpenId) : false,
+    },
 };
 function dashboardWaitStatus(error) {
     switch (error.error) {
@@ -1308,6 +1433,99 @@ for (const [path, resolution] of [
         return jsonRes(res, 200, result);
     });
 }
+// v3 humanGate: start a daemon-driven run (grill `approve-dag` 后的主入口).  Same
+// 127.0.0.1 ipcRoute posture as the v0.2 approve/reject mutations (dashboard
+// proxies authed external calls).  Fire-and-forget: the runner drives the run +
+// posts gate cards; the caller polls /api/v3/runs/:id for status.
+ipcRoute('POST', '/api/v3/runs/:runId/start', async (_req, res, params) => {
+    const runId = params.runId;
+    if (!isValidV3RunId(runId))
+        return jsonRes(res, 400, { ok: false, error: 'bad_run_id' });
+    // Owner check (codex blocker #1): only the daemon owning this run's bot may
+    // start it — otherwise the wrong daemon drives + posts cards with its client.
+    const binding = readV3RunChatBinding(join(v3DefaultBaseDir(), runId));
+    if (!binding)
+        return jsonRes(res, 404, { ok: false, error: 'unknown_run_or_no_binding' });
+    if (selfV3LarkAppId && binding.larkAppId !== selfV3LarkAppId) {
+        return jsonRes(res, 409, { ok: false, error: 'wrong_daemon', ownerLarkAppId: binding.larkAppId });
+    }
+    v3GateRunner.driveDetached(runId);
+    return jsonRes(res, 202, { ok: true, runId });
+});
+// v3 blocked retry: append the retry intent + re-drive.  Same owner posture as
+// /start.  Body: { nodeId? } (defaults to the run's blockedNodeId).
+ipcRoute('POST', '/api/v3/runs/:runId/retry', async (req, res, params) => {
+    const runId = params.runId;
+    if (!isValidV3RunId(runId))
+        return jsonRes(res, 400, { ok: false, error: 'bad_run_id' });
+    const binding = readV3RunChatBinding(join(v3DefaultBaseDir(), runId));
+    if (!binding)
+        return jsonRes(res, 404, { ok: false, error: 'unknown_run_or_no_binding' });
+    if (selfV3LarkAppId && binding.larkAppId !== selfV3LarkAppId) {
+        return jsonRes(res, 409, { ok: false, error: 'wrong_daemon', ownerLarkAppId: binding.larkAppId });
+    }
+    let body = {};
+    try {
+        body = await readJsonBody(req);
+    }
+    catch {
+        /* empty body is fine — retry the blockedNodeId */
+    }
+    const nodeId = typeof body.nodeId === 'string' && body.nodeId ? body.nodeId : undefined;
+    let outcome;
+    try {
+        outcome = requestV3Retry(v3DefaultBaseDir(), runId, { nodeId });
+    }
+    catch (err) {
+        return jsonRes(res, 500, { ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+    if (outcome.kind === 'stale-run') {
+        return jsonRes(res, 409, {
+            ok: false,
+            error: outcome.reason === 'missing' ? 'unknown_run'
+                : outcome.reason === 'loop-node' ? 'loop_node_use_grant'
+                    : 'not_blocked',
+        });
+    }
+    // requested / already-requested → make sure the run is moving.
+    v3GateRunner.driveDetached(runId);
+    return jsonRes(res, 202, { ok: true, runId, ...outcome });
+});
+// v3 loop grant: append one extra iteration for an exhausted loop + re-drive.
+// Same owner posture as /retry.  Body: { loopId? } (defaults to the run's
+// blocked loop).
+ipcRoute('POST', '/api/v3/runs/:runId/grant', async (req, res, params) => {
+    const runId = params.runId;
+    if (!isValidV3RunId(runId))
+        return jsonRes(res, 400, { ok: false, error: 'bad_run_id' });
+    const binding = readV3RunChatBinding(join(v3DefaultBaseDir(), runId));
+    if (!binding)
+        return jsonRes(res, 404, { ok: false, error: 'unknown_run_or_no_binding' });
+    if (selfV3LarkAppId && binding.larkAppId !== selfV3LarkAppId) {
+        return jsonRes(res, 409, { ok: false, error: 'wrong_daemon', ownerLarkAppId: binding.larkAppId });
+    }
+    let body = {};
+    try {
+        body = await readJsonBody(req);
+    }
+    catch {
+        /* empty body is fine — grant the blocked loop */
+    }
+    const loopId = typeof body.loopId === 'string' && body.loopId ? body.loopId : undefined;
+    let outcome;
+    try {
+        outcome = requestV3LoopGrant(v3DefaultBaseDir(), runId, { loopId, by: 'cli' });
+    }
+    catch (err) {
+        return jsonRes(res, 500, { ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+    if (outcome.kind === 'stale-run') {
+        return jsonRes(res, 409, { ok: false, error: outcome.reason === 'missing' ? 'unknown_run' : 'not_exhausted' });
+    }
+    // granted / already-granted → make sure the run is moving.
+    v3GateRunner.driveDetached(runId);
+    return jsonRes(res, 202, { ok: true, runId, ...outcome });
+});
 function attemptResumeStatus(error) {
     switch (error.error) {
         case 'bad_run_id':
@@ -1421,7 +1639,7 @@ ipcRoute('POST', '/api/workflows/definitions/:id/run', async (req, res, params)
         }
     }
     // Convert JSON-channel params (decoded values) into the shared RawParamInput
-    // map.  String-channel coercion stays on the IM `/workflow run` path.
+    // map.  String-channel coercion stays on the IM `/template run` path.
     const rawParams = {};
     for (const [k, v] of Object.entries(body.params ?? {})) {
         rawParams[k] = { kind: 'json', value: v };
@@ -1656,19 +1874,22 @@ async function maybeAutoBindDefaultOncall(larkAppId, chatId, chatType) {
     return ensureDefaultOncallBound(larkAppId, chatId, chatType);
 }
 /**
- * Resolve this bot's `defaultWorkingDir` for a new-topic spawn, if any.
- * Unlike `defaultOncall`, this is a pure runtime fallback: no state is
- * written to bots.json and the chat is NOT bound to oncall (so the
- * permission model stays unchanged). `/cd <path>` can still switch the
+ * Resolve this bot's effective default working dir for a new-session spawn, if
+ * any (see {@link effectiveDefaultWorkingDir}): `defaultWorkingDir`, or — when
+ * "Oncall 模式" is on — `defaultOncall.workingDir` as the all-sessions fallback.
+ *
+ * Either way this is a pure runtime fallback: no state is written to bots.json
+ * and the chat is NOT bound to oncall here (the group auto-bind, which opens
+ * talk, happens separately upstream at layer 2), so the permission model for
+ * the resolved session stays unchanged. `/cd <path>` can still switch the
  * working dir mid-session; the next new topic falls back to this default.
  *
- * Returns the expanded path when the configured field points to a real
- * directory; logs and returns undefined when the path is missing/invalid
- * so the caller falls through to the repo-select card instead of
- * spawning into a bad cwd.
+ * Returns the expanded path when the chosen source points at a real directory;
+ * logs and returns undefined when the path is missing/invalid so the caller
+ * falls through to the repo-select card instead of spawning into a bad cwd.
  */
 function resolveBotDefaultWorkingDir(larkAppId) {
-    const raw = getBot(larkAppId).config.defaultWorkingDir;
+    const raw = effectiveDefaultWorkingDir(getBot(larkAppId).config);
     if (!raw)
         return undefined;
     const resolved = expandHome(raw);
@@ -1677,7 +1898,7 @@ function resolveBotDefaultWorkingDir(larkAppId) {
             return resolved;
     }
     catch { /* not a dir */ }
-    logger.warn(`[${larkAppId}] defaultWorkingDir invalid (${resolved}); ` +
+    logger.warn(`[${larkAppId}] default working dir invalid (${resolved}); ` +
         `falling back to repo-select card`);
     return undefined;
 }
@@ -1699,7 +1920,11 @@ async function resolvePinnedWorkingDir(ctx) {
         oncallEntry = await maybeAutoBindDefaultOncall(ctx.larkAppId, ctx.chatId, ctx.chatType);
     }
     const inheritedFrom = !oncallEntry
-        ? findInheritablePeer({ scope: ctx.scope, anchor: ctx.anchor, chatId: ctx.chatId, chatType: ctx.chatType, selfAppId: ctx.larkAppId })
+        ? findInheritablePeer({
+            scope: ctx.scope, anchor: ctx.anchor, chatId: ctx.chatId, chatType: ctx.chatType,
+            selfAppId: ctx.larkAppId,
+            botToBotSameDir: getBot(ctx.larkAppId).config.botToBotSameDir !== false,
+        })
         : null;
     const botDefaultWorkingDir = (!oncallEntry && !inheritedFrom)
         ? resolveBotDefaultWorkingDir(ctx.larkAppId)
@@ -1868,13 +2093,32 @@ async function handleNewTopic(data, ctx) {
         msgType: parsed.msgType,
         content,
     });
-    if (parseWorkflowCommand(cmdContent)) {
+    // v3 即兴 grill：`/workflow [new] <目标>`。daemon 不拷问——把目标包成触发
+    // botmux-workflow skill 的 prompt（改写 content，promptContent 随后从 content
+    // 构造），fall-through 到正常 session 创建，让本话题 agent 接管整条链路。
+    // run|cancel 不在此命中（归 v2 legacy，由下面 handleWorkflowCommandIfAny 处理）。
+    const newTopicGrill = parseWorkflowGrillTrigger(cmdContent);
+    if (newTopicGrill) {
         if (await replyGrantRestrictionIfNeeded(larkAppId, chatId, senderOpenId, anchor, '/workflow')) {
             return;
         }
+        if (newTopicGrill.kind === 'usage') {
+            await sessionReply(anchor, WORKFLOW_USAGE, 'text', larkAppId);
+            return;
+        }
+        content = buildWorkflowGrillPrompt(newTopicGrill.goal);
+        // 保留原 cmdContent（"/workflow new …"）供 title/日志；/workflow 非注册命令，
+        // 下面的 parseSlashCommandInvocation 会让它落到正常 spawn 路径。
     }
-    if (await handleWorkflowCommandIfAny(cmdContent, anchor, chatId, larkAppId, senderOpenId)) {
-        return;
+    else {
+        if (parseWorkflowCommand(cmdContent)) {
+            if (await replyGrantRestrictionIfNeeded(larkAppId, chatId, senderOpenId, anchor, '/template')) {
+                return;
+            }
+        }
+        if (await handleWorkflowCommandIfAny(cmdContent, anchor, chatId, larkAppId, senderOpenId)) {
+            return;
+        }
     }
     // Intercept daemon commands in new topics (no session needed for some commands)
     const invocation = parseSlashCommandInvocation(cmdContent);
@@ -2390,7 +2634,9 @@ async function handleThreadReply(data, ctx) {
     const botSenderPrefix = isForeignBot
         ? `${tr('daemon.foreign_bot_mention_prefix', { botName: foreignBotName }, localeForBot(larkAppId))}\n`
         : '';
-    const promptContent = buildQuoteHint(parsed, scope, anchor, localeForBot(larkAppId)) + botSenderPrefix + parsed.content;
+    // `let` (not const): the v3 grill gate below may replace this with a
+    // skill-trigger prompt when the user sends `/workflow [new] <目标>` mid-thread.
+    let promptContent = buildQuoteHint(parsed, scope, anchor, localeForBot(larkAppId)) + botSenderPrefix + parsed.content;
     const existingHookSession = activeSessions.get(sessionKey(anchor, larkAppId));
     emitHookEvent('thread.reply', {
         larkAppId,
@@ -2458,13 +2704,30 @@ async function handleThreadReply(data, ctx) {
             return;
         }
     }
-    if (parseWorkflowCommand(cmdContent)) {
+    // v3 即兴 grill（thread 内）：`/workflow [new] <目标>` → 把目标包成触发
+    // botmux-workflow skill 的 prompt 覆盖 promptContent，fall-through 到下面正常
+    // 转发逻辑，让现有/新建的 agent 接管。run|cancel 归 v2 legacy（走 else）。
+    const threadGrill = parseWorkflowGrillTrigger(cmdContent);
+    if (threadGrill) {
         if (await replyGrantRestrictionIfNeeded(larkAppId, threadChatId, threadSenderOpenId, anchor, '/workflow')) {
             return;
         }
+        if (threadGrill.kind === 'usage') {
+            await sessionReply(anchor, WORKFLOW_USAGE, 'text', larkAppId);
+            return;
+        }
+        promptContent = buildWorkflowGrillPrompt(threadGrill.goal);
+        // fall through to normal forwarding with the rewritten promptContent
     }
-    if (await handleWorkflowCommandIfAny(cmdContent, anchor, threadChatId, larkAppId, threadSenderOpenId)) {
-        return;
+    else {
+        if (parseWorkflowCommand(cmdContent)) {
+            if (await replyGrantRestrictionIfNeeded(larkAppId, threadChatId, threadSenderOpenId, anchor, '/template')) {
+                return;
+            }
+        }
+        if (await handleWorkflowCommandIfAny(cmdContent, anchor, threadChatId, larkAppId, threadSenderOpenId)) {
+            return;
+        }
     }
     // Intercept daemon commands
     const invocation = parseSlashCommandInvocation(cmdContent);
@@ -2593,10 +2856,13 @@ async function handleThreadReply(data, ctx) {
     // 自定义回复拦截：该话题有未结的 ask 时，把这条文字当答案，走 submitCustomReply
     // settle 掉 ask（替代选项语义），不再当作新一轮指令喂给 CLI。此时发起 ask 的 CLI
     // 正阻塞等结果，回什么都得先等 ask 结束，故无副作用。仅拦截纯文字（slash 命令 /
-    // 回调 URL / workflow 已在上方各自 return，可用来中止）。答复权限 = canTalk，由
+    // 回调 URL 已在上方 return，可用来中止）。答复权限 = canTalk，由
     // broker 在 submitCustomReply 内按注入的 canTalkChecker 判定：非授权人返回
     // 'unauthorized'，这里 fall through 到正常路由。卡片由 broker.onSettle 自动 PATCH。
-    if (threadSenderOpenId && threadChatId) {
+    // `!threadGrill`：grill goal 分支只改写 promptContent 后 fall-through（不 return），
+    // cmdContent 仍是字面量 `/workflow new <目标>`；若不排除，待回答 ask 会把它当答案吞掉，
+    // grill 永远不启动。grill 必须穿过拦截器走正常转发。
+    if (threadSenderOpenId && threadChatId && !threadGrill) {
         const askReplyText = cmdContent.trim();
         if (askReplyText) {
             const pendingAsk = findPendingAskByAnchor({ larkAppId, chatId: threadChatId, anchor });
@@ -3184,6 +3450,7 @@ export async function startDaemon(botIndex) {
     // also needs its own copy for SessionRow.botName.
     setBotName(cfg.larkAppId);
     setLarkAppId(cfg.larkAppId);
+    selfV3LarkAppId = cfg.larkAppId; // scope v3 humanGate cold-attach / start to this bot
     // Bind dashboard IPC HTTP server BEFORE publishing the registry descriptor.
     // Otherwise the dashboard process can race-fetch the IPC port from the
     // descriptor and hit ECONNREFUSED before we're listening — that left every
@@ -3420,6 +3687,12 @@ export async function startDaemon(botIndex) {
     }, 120_000);
     sandboxReconcileTimer.unref?.();
     await attachColdWorkflowRuns(cfg.larkAppId);
+    // v3 humanGate cold-attach: re-post pending gate cards + resume healed gates
+    // for runs OWNED BY THIS BOT (codex blocker #1 — owner filter, mirrors
+    // attachColdWorkflowRuns(cfg.larkAppId)).  Best-effort; never blocks startup.
+    await v3GateRunner.coldAttach(cfg.larkAppId).catch((err) => {
+        logger.warn(`[v3] cold-attach failed; continuing daemon startup: ${err instanceof Error ? err.message : String(err)}`);
+    });
     // Start scheduler in every daemon.  Each daemon owns exactly one bot, so
     // each filters to only execute tasks whose `larkAppId` matches its bot
     // (unmatched tasks are handled by the owning bot's daemon instead; a