teamshare-bridge 0.21.76 → 0.21.78

package/dist/bridge/wake-handler.js

@@ -19,12 +19,23 @@ const wake_state_1 = require("../lib/wake-state");
 const presence_1 = require("../lib/workspace/presence");
 const repo_lock_1 = require("../lib/workspace/repo-lock");
 const mirror_1 = require("../lib/workspace/mirror");
+const wake_queue_store_1 = require("./wake-queue-store");
+const git_branch_1 = require("../lib/git/git-branch");
 const git_presence_1 = require("../lib/git/git-presence");
 const session_store_1 = require("../lib/harness/session-store");
-const plan_gate_1 = require("../lib/harness/plan-gate");
 const spawn_1 = require("./spawn");
 const daemon_support_1 = require("./daemon-support");
 const wake_routing_1 = require("./wake-routing");
+/**
+ * Seed recorded in a mirror marker. Task-scoped runs are keyed by the task id
+ * (the PATH is deterministic too, so a retry can adopt the previous tree);
+ * wakes with no task id get a type+random seed and are never adopted.
+ */
+function mirrorSeed(event) {
+    if (event.taskId && wake_routing_1.UUID_RE.test(event.taskId))
+        return event.taskId;
+    return `${event.type.replace(/[^a-z.]/gi, '')}-${Math.random().toString(16).slice(2, 8)}`;
+}
 /** IMP-917: wakes already deferred once for a rate-limit pause (bounded). */
 const rateDeferred = new Set();
 /**
@@ -36,6 +47,8 @@ const rateDeferred = new Set();
  * Covers every delivery path because they all funnel through `handleWake`.
  */
 const inFlightWakes = new Set();
+/** Quiet-hours deferrals (2026-09) - bounded by one timer per wake identity. */
+const quietDeferred = new Set();
 exports.folderWaitQueue = new Map();
 /**
  * Multi-repo: name -> path map of a project's linked git repos (undefined
@@ -77,6 +90,25 @@ async function handleWake(api, agentId, apiKey, event, configInput, extra) {
             }
         }
     }
+    // DUPLICATE AUTOMATED WAKE (2026-09): the hub re-sends a `task.assigned`
+    // wake it never saw acknowledged (empty room during a socket flap, or the
+    // 15s ack watchdog) and delivers the replay on the next reconnect. The 60s
+    // spawn cooldown above does not cover a replay 10 minutes later, and the
+    // 15-minute processed-wake ledger was only ever consulted by the re-sync and
+    // stranded-sweep pumps - never on this live path. So the duplicate sailed
+    // through, queued behind the busy lock, and on flush built a whole mirror for
+    // a task that was already being worked.
+    //
+    // Only AUTOMATED assignment wakes are filtered. `task.run` is a human
+    // pressing "Run task" and must always work, and a resume/continuation wake
+    // is an explicit instruction to pick the task back up.
+    if (event.type === 'task.assigned' &&
+        !event.resume &&
+        event.taskId &&
+        (0, wake_state_1.isRecentlyProcessed)(agentId, 'task.assigned', event.taskId)) {
+        (0, daemon_support_1.log)(`agent ${agentId}: wake task.assigned task=${event.taskId} skipped (already processed recently - duplicate wake)`);
+        return 'skipped';
+    }
     // Usage guard: skip wakes for the same task/message/document within the
     // cooldown window - a reconnect storm must never respawn the same work.
     // The per-agent setting (seconds) overrides the bridge defaults.
@@ -100,8 +132,28 @@ async function handleWake(api, agentId, apiKey, event, configInput, extra) {
     // Quiet hours: the per-agent setting wins; the bridge config is the
     // machine-wide fallback for agents without one.
     if ((0, daemon_support_1.inQuietHours)(settings?.quietHours ?? config.quietHours)) {
-        (0, daemon_support_1.log)(`agent ${agentId}: wake ${event.type} skipped (quiet hours)`);
-        return 'skipped';
+        // DEFERRED, never skipped (2026-09). This used to return 'skipped', and the
+        // inbox pumps stamp anything that is not queued/deferred/blocked as
+        // "processed" - so a chat mention that arrived during quiet hours was
+        // acked by the hub, skipped here, written to the 15-minute ledger, and then
+        // never retried by anyone. It was simply lost.
+        const deferKey = `${agentId}:${event.type}:${(0, wake_routing_1.wakeDedupeKey)(event) ?? `${event.projectId ?? ''}:${event.messageId ?? event.taskId ?? Math.random()}`}`;
+        if (!quietDeferred.has(deferKey)) {
+            quietDeferred.add(deferKey);
+            // Re-check in 30 minutes; a mention waits out quiet hours instead of
+            // disappearing.
+            setTimeout(() => {
+                quietDeferred.delete(deferKey);
+                if ((0, daemon_support_1.inQuietHours)(settings?.quietHours ?? config.quietHours)) {
+                    // Still quiet - re-arm for the next window.
+                    void handleWake(api, agentId, apiKey, event, config, extra);
+                    return;
+                }
+                void handleWake(api, agentId, apiKey, event, config, extra);
+            }, 30 * 60_000);
+            (0, daemon_support_1.log)(`agent ${agentId}: wake ${event.type} deferred (quiet hours) - will retry in 30m until quiet hours end`);
+        }
+        return 'deferred';
     }
     // IN-FLIGHT GUARD (2026-09): the same wake delivered twice while the
     // first copy is still resolving (WS live wake vs stranded-task sweep vs
@@ -138,10 +190,15 @@ async function handleWake(api, agentId, apiKey, event, configInput, extra) {
         const queue = wakeQueue.get(agentId) ?? [];
         queue.push(event);
         wakeQueue.set(agentId, queue);
+        // Persisted (2026-09): a queued wake is often a chat mention or a task
+        // comment - a message addressed to the agent. It must survive a daemon
+        // restart/upgrade; the hub has already been told it was delivered, so there
+        // is no server-side copy to fall back on.
+        (0, wake_queue_store_1.writeWakeQueueFile)(agentId, queue);
         (0, daemon_support_1.log)(`agent ${agentId}: wake ${event.type} queued (busy since ${lock.startedAt}, ${lock.kind}) - ${queue.length} waiting`);
         // Stuck-queue visibility: only a lock with NO live session after 10+
         // minutes is a problem (PID reuse / hung process / orphan). A running
-        // session (sessionRelay has it) is a normal long run — the queue keeps
+        // session (sessionRelay has it) is a normal long run —” the queue keeps
         // waiting (flushInterval) and we never warn. Fingerprint includes the
         // lock's startedAt so all wakes behind the SAME bad lock coalesce.
         const lockAgeMs = Date.now() - new Date(lock.startedAt).getTime();
@@ -156,7 +213,7 @@ async function handleWake(api, agentId, apiKey, event, configInput, extra) {
                     message: `wake ${event.type} queued behind a ${lock.kind} lock held over 10 minutes with no live session (since ${lock.startedAt}, pid ${lock.pid}) - if the pid is orphaned: teamshare-bridge clear-lock --agent ${agentId}`,
                 });
             }
-            // Session running: stay quiet — the wake is queued and will spawn on free.
+            // Session running: stay quiet —” the wake is queued and will spawn on free.
         }
         return 'queued';
     }
@@ -180,14 +237,14 @@ async function handleWake(api, agentId, apiKey, event, configInput, extra) {
 }
 /**
  * NO-GIT NOTICE (2026-09): tell the user, ON THE TASK, why this run is not
- * isolated. Without this the only symptom is "the agent behaves differently" —
+ * isolated. Without this the only symptom is "the agent behaves differently" —”
  * a silent downgrade is indistinguishable from a bug. Deduped per
  * (agent, project, task) so a retried task is not spammed, and best-effort:
  * a failed notice must never block the run.
  */
 async function announceGitUnavailable(api, agentId, projectId, taskId, detail) {
     if (!taskId) {
-        // No task to comment on (e.g. a document/board mention) — the daemon log
+        // No task to comment on (e.g. a document/board mention) —” the daemon log
         // already carries the reason and `doctor` reports it.
         return;
     }
@@ -329,7 +386,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
     (0, daemon_support_1.log)(`agent ${agentId}: wake ${event.type} -> working folder ${cwd}`);
     // Plain chat (mention with NO task reference) is a READ-ONLY plan-mode
     // session: it never edits local files and runs no git, so it needs no
-    // isolation — it runs in the linked folder IMMEDIATELY (no mirror, no
+    // isolation —” it runs in the linked folder IMMEDIATELY (no mirror, no
     // folder queue) even while other runs are active. Task-linked chat DOES run
     // the git flow and gets a mirror. Computed here because the isolation gate
     // and the folder gate both need it.
@@ -337,7 +394,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
     const plainChat = event.type === 'chat.mention' && !linkedTaskId;
     // Task wake PRE-CHECKS (2026-09): fetch once and apply the SKIP guards
     // BEFORE isolation, so a wake that will be skipped (part of a combined run,
-    // suspended, or a closed task.assigned) never builds a mirror — that used to
+    // suspended, or a closed task.assigned) never builds a mirror —” that used to
     // leave an orphan mirror + 5 worktrees. The fetched task is reused by the
     // plan/build routing below (no second GET).
     let routedTask = null;
@@ -348,7 +405,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
         try {
             const task = await api.getTask(event.taskId);
             // Combined-run lock: a member folded into a combined run is never spawned
-            // on its own — the combined (group) task IS its run.
+            // on its own —” the combined (group) task IS its run.
             if (task.combinedIntoId) {
                 (0, daemon_support_1.log)(`agent ${agentId}: wake ${event.type} task=${event.taskId} SKIPPED - part of a combined run`);
                 return 'skipped';
@@ -367,12 +424,94 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
             routedTask = task;
         }
         catch {
-            // fetch failed — fall through; claim will fail if truly non-open
+            // fetch failed —” fall through; claim will fail if truly non-open
+        }
+    }
+    // PRE-FLIGHT (2026-09): decide whether this wake can spawn, and whether it
+    // needs a private mirror, BEFORE anything is created. Every skip decision
+    // used to live BELOW the isolation block, so a wake that decided not to run
+    // had already built 5 worktrees (~45 MB) and left them behind for hours.
+    //
+    // `preflightWake` relocates those decisions - it adds no new skip reason, so
+    // it can never strand work that would previously have run. The
+    // folder-serialization gate deliberately stays BELOW isolation (it must keep
+    // testing the EFFECTIVE cwd, where a successful mirror has no presence).
+    const preflight = (0, wake_routing_1.preflightWake)({
+        event,
+        task: routedTask,
+        hasLocalPlanSession: event.taskId
+            ? (0, session_store_1.hasHarnessSession)(agentId, event.taskId, 'plan')
+            : false,
+        hasLocalRunSession: event.taskId
+            ? (0, session_store_1.hasHarnessSession)(agentId, event.taskId, 'run')
+            : false,
+        hasLocalBuildSession: event.taskId
+            ? (0, session_store_1.hasHarnessSession)(agentId, event.taskId, 'build')
+            : false,
+        hasBuildState: false,
+        plainChat,
+    });
+    if (preflight.outcome === 'stop') {
+        // Defensive: handleWake normally intercepts stop signals before here.
+        if (projectId) {
+            try {
+                (0, node_fs_1.mkdirSync)(daemon_support_1.STOP_DIR, { recursive: true });
+                (0, node_fs_1.writeFileSync)((0, node_path_1.join)(daemon_support_1.STOP_DIR, `${agentId}.stop`), new Date().toISOString(), 'utf8');
+                (0, daemon_support_1.log)(`agent ${agentId}: ${event.type} -> stop file written (pre-flight)`);
+            }
+            catch (err) {
+                (0, daemon_support_1.log)(`agent ${agentId}: ${event.type} stop file failed: ${(0, config_1.msg)(err)}`);
+            }
         }
+        return 'spawned';
+    }
+    if (preflight.outcome === 'skip') {
+        (0, daemon_support_1.log)(`agent ${agentId}: ${event.type} task=${event.taskId ?? ''} -> skipped (${preflight.reason}${preflight.detail ? `, ${preflight.detail}` : ''})`);
+        if (event.type === 'task.assigned' && event.taskId) {
+            (0, wake_state_1.recordProcessed)(agentId, 'task.assigned', event.taskId);
+        }
+        return 'skipped';
     }
-    // ALWAYS-ISOLATE (2026-09): every code run gets its OWN private mirror —
+    // DETERMINISTIC MENTION CLAIM (2026-09).
+    //
+    // Every mention wake (chat, task comment, document comment, board comment, AI
+    // edit) now carries the hub's AgentMention id. Claiming it HERE - once, in the
+    // one place every mention passes through - is what makes "answered" a fact
+    // rather than a guess. Previously the bridge decided with a name-scan behind a
+    // moving cursor and a "is my reply in the newest 50?" window, so a replayed
+    // wake (a PendingWake redelivery, a reconnect re-sync, a stranded sweep) could
+    // start a SECOND session on a question that was already answered.
+    //
+    // `claimed: false` means another session already has it, or it is answered ->
+    // do not spawn. An older hub without the endpoint logs and proceeds, so this
+    // is additive, never a new way to drop a mention.
+    if (event.mentionId) {
+        try {
+            const claim = await api.triggerMention(agentId, event.mentionId);
+            if (claim && claim.claimed === false) {
+                const state = claim.mention?.answeredAt
+                    ? 'already answered'
+                    : 'already being handled';
+                (0, daemon_support_1.log)(`agent ${agentId}: mention ${event.mentionId} (${event.type}) is ${state} - not starting a second session`);
+                if (event.type === 'task.assigned') {
+                    (0, wake_state_1.recordProcessed)(agentId, 'task.assigned', event.taskId ?? event.mentionId);
+                }
+                return 'skipped';
+            }
+            if (claim?.claimed) {
+                (0, daemon_support_1.log)(`agent ${agentId}: claimed mention ${event.mentionId} (${event.type})`);
+            }
+        }
+        catch (err) {
+            (0, daemon_support_1.log)(`agent ${agentId}: could not claim mention ${event.mentionId} (${(0, config_1.msg)(err)}) - proceeding`);
+        }
+    }
+    // Past the folder guard `cwd` is always a real path. Keep a non-null alias
+    // for the dispatch chain below - it is reassigned by the mirror block.
+    let runDir = cwd;
+    // ALWAYS-ISOLATE (2026-09): every code run gets its OWN private mirror —”
     // a container-root worktree plus one worktree per pre-existing nested repo
-    // — so concurrent agents never share a working tree and EACH repo commits
+    // —” so concurrent agents never share a working tree and EACH repo commits
     // its own changes on its own branch (never a mixed commit or a gitlink
     // instead of the nested repo's work). The container root repo is
     // initialized on demand (never nested repos). Exempt: orchestrator-owned
@@ -382,29 +521,12 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
     // Opt out per project: `teamshare-agent link --project <id> --auto-worktree
     // false`.
     //
-    // PLAN RUNS ARE NOT ISOLATED (2026-09): a planning pass never runs the git
-    // pipeline — `cmdPlan` creates no branch and no commit, it only enriches the
-    // task and writes documents via MCP — so a mirror/worktree buys it nothing
-    // while costing 5 worktrees per pass. Planning therefore works in the linked
-    // folder, serialized by presence (cmdPlan registers it) so it still never
-    // overlaps another session. The decision is computed HERE, before the gate,
-    // because the routing gate below runs after it.
-    const planRunWake = event.type === 'plan.trigger' ||
-        (routedTask ? (0, wake_routing_1.planModeRoute)(event, routedTask) === 'plan' : false);
-    const isolationExempt = plainChat ||
-        Boolean(event.worktreePath) ||
-        event.type === 'question.answered' ||
-        event.type === 'question.expired' ||
-        event.type === 'tool.trigger' ||
-        event.type === 'document.job' ||
-        planRunWake;
-    if (!isolationExempt && cwd && projectId &&
-        config.projects[projectId]?.autoWorktree !== false) {
-        const seedBase = (event.taskId ?? `${event.type}-${Date.now()}`)
-            .replace(/-/g, '')
-            .slice(0, 8);
-        // Unique per run so a retry never tears down an earlier run's mirror.
-        const seed = `${seedBase}-${Math.random().toString(16).slice(2, 6)}`;
+    // The exemption decision now comes from the pre-flight (`needsMirror`), so
+    // plan runs are excluded here for the same reason as before: a planning
+    // pass never runs the git pipeline, so a mirror buys it nothing while
+    // costing 5 worktrees per pass. `cmdPlan` registers presence instead, so
+    // the folder-serialization gate below still keeps it to one at a time.
+    if (preflight.needsMirror && !event.worktreePath && projectId && config.projects[projectId]?.autoWorktree !== false) {
         // NO-GIT FALLBACK (2026-09): a machine without Git cannot have a mirror at
         // all (no container-root `git init`, no `git worktree add`). Don't burn a
         // doomed attempt on it: run in the linked folder and let the folder
@@ -418,17 +540,60 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
         }
         else {
             try {
-                const info = await (0, mirror_1.createIsolationMirror)(cwd, seed, agentId, projectId);
-                if (info) {
-                    cwd = info.path;
-                    (0, daemon_support_1.log)(`agent ${agentId}: isolated in ${info.path} (${info.repos.length} repo(s): ${info.repos
+                // Base the tree on the task's own branch when it exists, so a retry
+                // CONTINUES the previous attempt instead of landing on a clean
+                // default-branch checkout and doing the same job twice.
+                //
+                // The inputs MUST mirror `cmdRun`'s `prepareRunGitAsync` call exactly
+                // (taskId + project.name + title, no branchName): if the two derive
+                // different names, the mirror bases on a branch the run never commits
+                // to and the continuation silently misses.
+                const result = await (0, mirror_1.createIsolationMirror)(cwd, mirrorSeed(event), agentId, projectId, {
+                    taskId: routedTask?.id ?? event.taskId,
+                    baseBranch: routedTask
+                        ? (0, git_branch_1.desiredBranch)({
+                            taskId: routedTask.id,
+                            projectSlug: routedTask.project?.name,
+                            taskTitle: routedTask.title,
+                        })
+                        : null,
+                });
+                if (result.ok) {
+                    runDir = result.mirror.path;
+                    const adopted = result.mirror.adopted
+                        ? ` (adopted previous tree, ${result.mirror.dirtyFiles ?? 0} uncommitted file(s) carried over)`
+                        : '';
+                    (0, daemon_support_1.log)(`agent ${agentId}: isolated in ${runDir} (${result.mirror.repos.length} repo(s): ${result.mirror.repos
                         .map((r) => r.name)
-                        .join(', ')})`);
+                        .join(', ')})${adopted}`);
+                }
+                else if (result.reason === 'blocked') {
+                    // Someone is genuinely using this task's tree. Refuse rather than
+                    // touch it, and make the refusal visible - a same-task double wake is
+                    // a duplicate-wake bug, not a normal state.
+                    // A same-task double wake reached the mirror guard: this task's tree
+                    // is genuinely in use. Queue for real (the pre-2026 code returned
+                    // 'queued' WITHOUT queueing, so the wake was referenced nowhere: no
+                    // retry, no server copy, no reply) - and say so loudly.
+                    const queue = extra.wakeQueue?.get(agentId) ?? [];
+                    queue.push(event);
+                    extra.wakeQueue?.set(agentId, queue);
+                    (0, wake_queue_store_1.writeWakeQueueFile)(agentId, queue);
+                    (0, daemon_support_1.log)(`agent ${agentId}: mirror for ${event.type} task=${event.taskId ?? ''} is owned by a live session (${result.detail ?? 'busy'}) - queued ${queue.length} waiting`);
+                    (0, diagnostics_1.reportDiagnosticSafe)({
+                        kind: 'wake_failure',
+                        severity: 'warning',
+                        agentId,
+                        errorCode: 'TASK_MIRROR_OWNED',
+                        message: `wake ${event.type} for task ${event.taskId ?? '(no task)'} found its isolation mirror already owned by a live session (${result.detail ?? 'busy'}) - queued for retry`,
+                        includeDoctor: false,
+                    });
+                    return 'queued';
                 }
                 else {
-                    // Isolation unavailable (no base branch / init failed) — the
+                    // Isolation unavailable (no base branch / init failed) —” the
                     // serialization gate below queues instead of sharing the folder.
-                    (0, daemon_support_1.log)(`agent ${agentId}: isolation unavailable - will queue if the linked folder is occupied`);
+                    (0, daemon_support_1.log)(`agent ${agentId}: isolation unavailable (${result.detail ?? 'unknown'}) - will queue if the linked folder is occupied`);
                 }
             }
             catch (err) {
@@ -436,59 +601,47 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
             }
         }
     }
-    // Task-scoped routing gate (POST-isolation): the task was fetched and the
-    // skip guards applied BEFORE the mirror was created, so nothing here can
-    // leave an orphan mirror. Only tool/research + plan routing remain, using
-    // the ISOLATED cwd.
-    if (routedTask) {
+    // Task-scoped routing dispatch. The SKIP half of this decision was made in
+    // the pre-flight above the mirror block, so reaching here can only spawn.
+    if (routedTask && (preflight.kind === 'tool' || preflight.kind === 'plan')) {
         const task = routedTask;
         // Tools-as-tasks: a research/tool task must run through the spec-driven
         // research session (recipe + column contract), NOT the code agent loop.
-        if ((event.type === 'task.assigned' || event.type === 'task.run') &&
-            (task.kind === 'tool' || task.kind === 'research') &&
-            task.toolRunId) {
+        if (preflight.kind === 'tool') {
+            // The pre-flight only returns 'tool' when toolRunId is set; String()
+            // keeps the spawn signature honest without a cast.
+            const toolRunId = String(task.toolRunId ?? '');
             (0, daemon_support_1.log)(`agent ${agentId}: task.assigned task=${event.taskId} -> research session (${task.toolKey ?? task.kind})`);
-            (0, spawn_1.spawnResearchSession)(agentId, apiKey, projectId ?? task.projectId, task.toolRunId, task.toolKey ?? 'tool', extra.settings, undefined, cwd);
+            (0, spawn_1.spawnResearchSession)(agentId, apiKey, projectId ?? task.projectId, toolRunId, task.toolKey ?? 'tool', extra.settings, undefined, runDir);
             (0, wake_state_1.recordProcessed)(agentId, 'tool.trigger', String(task.toolRunId));
             return 'spawned';
         }
-        // Plan mode: a PLANNING pass (enrich, never execute), not the code loop.
-        if ((0, wake_routing_1.planModeRoute)(event, task) === 'plan') {
-            const planGate = (0, plan_gate_1.automatedPlanGate)(task, (0, session_store_1.hasHarnessSession)(agentId, task.id, 'plan'));
-            if (planGate.action === 'skip') {
-                (0, daemon_support_1.log)(`agent ${agentId}: ${event.type} task=${event.taskId} -> planning skipped (${planGate.reason}, planRuns=${planGate.planRuns})`);
-                if (event.type === 'task.assigned') {
-                    (0, wake_state_1.recordProcessed)(agentId, 'task.assigned', task.id);
-                }
-                return 'skipped';
-            }
-            (0, daemon_support_1.log)(`agent ${agentId}: ${event.type} task=${event.taskId} -> planning session (plan mode)`);
-            const planDedupeKey = (0, wake_routing_1.wakeDedupeKey)(event);
-            if (planDedupeKey)
-                extra.recentSpawns?.set(planDedupeKey, Date.now());
-            (0, spawn_1.spawnPlanSession)(agentId, apiKey, task.id, projectId ?? task.projectId, extra.settings, undefined, cwd, { auto: true });
-            if (event.type === 'task.assigned') {
-                (0, wake_state_1.recordProcessed)(agentId, 'task.assigned', task.id);
-            }
-            return 'spawned';
+        (0, daemon_support_1.log)(`agent ${agentId}: ${event.type} task=${event.taskId} -> planning session (plan mode)`);
+        const planDedupeKey = (0, wake_routing_1.wakeDedupeKey)(event);
+        if (planDedupeKey)
+            extra.recentSpawns?.set(planDedupeKey, Date.now());
+        (0, spawn_1.spawnPlanSession)(agentId, apiKey, task.id, projectId ?? task.projectId, extra.settings, undefined, runDir, { auto: true });
+        if (event.type === 'task.assigned') {
+            (0, wake_state_1.recordProcessed)(agentId, 'task.assigned', task.id);
         }
+        return 'spawned';
     }
     // FOLDER SERIALIZATION (safety net): when this wake could not get its own
     // worktree (creation refused/failed) and another session occupies the
     // linked folder, defer the wake until the folder becomes free. Covers
     // runs, build/plan/tool triggers, document mentions and TASK-linked chat.
-    // Excluded: plain chat (read-only — never edits files, runs immediately),
+    // Excluded: plain chat (read-only —” never edits files, runs immediately),
     // resume wakes queue here by design, stop signals return earlier in
     // handleWake, and worktree-scoped wakes bypass it (they are isolated).
     if (!event.worktreePath && !plainChat) {
-        const folderKey = (0, repo_lock_1.canonicalDir)(cwd);
-        const occupants = (0, presence_1.listPresent)(cwd).filter((p) => p.agentId !== agentId || p.pid !== process.pid);
+        const folderKey = (0, repo_lock_1.canonicalDir)(runDir);
+        const occupants = (0, presence_1.listPresent)(runDir).filter((p) => p.agentId !== agentId || p.pid !== process.pid);
         if (occupants.length > 0) {
             const queue = exports.folderWaitQueue.get(folderKey) ?? [];
             queue.push({ agentId, apiKey, event, enqueuedAt: Date.now() });
             exports.folderWaitQueue.set(folderKey, queue);
             const blocking = occupants.map((o) => `${o.agentId ?? 'pid:' + o.pid}`).join(', ');
-            (0, daemon_support_1.log)(`agent ${agentId}: wake ${event.type} queued behind ${blocking} in folder ${folderKey} — ${queue.length} waiting`);
+            (0, daemon_support_1.log)(`agent ${agentId}: wake ${event.type} queued behind ${blocking} in folder ${folderKey} —” ${queue.length} waiting`);
             return 'queued';
         }
     }
@@ -518,10 +671,10 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
             const repoMap = buildRepoMap(event.projectId);
             (0, daemon_support_1.log)(`agent ${agentId}: chat.mention task-linked -> ${linkedTaskId}` +
                 `${repoMap ? ` (${Object.keys(repoMap).length} repos)` : ''}`);
-            (0, spawn_1.spawnChatSession)(agentId, apiKey, event.projectId, event.mention ?? '', extra.settings, undefined, cwd, event.messageId, linkedTaskId, repoMap);
+            (0, spawn_1.spawnChatSession)(agentId, apiKey, event.projectId, event.mention ?? '', extra.settings, undefined, runDir, event.messageId, event.mentionId ?? undefined, linkedTaskId, repoMap);
             return 'spawned';
         }
-        (0, spawn_1.spawnChatSession)(agentId, apiKey, event.projectId, event.mention ?? '', extra.settings, undefined, cwd, event.messageId);
+        (0, spawn_1.spawnChatSession)(agentId, apiKey, event.projectId, event.mention ?? '', extra.settings, undefined, runDir, event.messageId, event.mentionId ?? undefined);
         return 'spawned';
     }
     if (event.type === 'document.mention') {
@@ -533,7 +686,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
         // IMP-9xx: pass the waking comment id so the loop answers ONLY that
         // comment (answer-once guard still applies) instead of rescanning
         // every historical mention in the thread.
-        (0, spawn_1.spawnDocumentSession)(agentId, apiKey, event.documentId, event.mention ?? '', extra.settings, undefined, cwd, event.commentId);
+        (0, spawn_1.spawnDocumentSession)(agentId, apiKey, event.documentId, event.mention ?? '', extra.settings, undefined, runDir, event.commentId);
         return 'spawned';
     }
     if (event.type === 'document.edit_request') {
@@ -545,10 +698,10 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
         // The agent reads the document, applies the edit instruction, and
         // replies with what changed.
         const editCtx = event.editRequest
-            ? ` [EDIT REQUEST: "${event.editRequest.instruction}" on page ${event.editRequest.pageNumber ?? 'N/A'} — quoted: "${event.editRequest.quote.slice(0, 200)}"]`
+            ? ` [EDIT REQUEST: "${event.editRequest.instruction}" on page ${event.editRequest.pageNumber ?? 'N/A'} —” quoted: "${event.editRequest.quote.slice(0, 200)}"]`
             : '';
         (0, daemon_support_1.log)(`agent ${agentId}: document.edit_request doc=${event.documentId} comment=${event.commentId ?? 'none'}${editCtx}`);
-        (0, spawn_1.spawnDocumentSession)(agentId, apiKey, event.documentId, event.mention ?? '', extra.settings, undefined, cwd, event.commentId);
+        (0, spawn_1.spawnDocumentSession)(agentId, apiKey, event.documentId, event.mention ?? '', extra.settings, undefined, runDir, event.commentId);
         return 'spawned';
     }
     if (event.type === 'board.mention') {
@@ -558,7 +711,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
         }
         // Board assistant: read the board, draw/edit with the board MCP tools,
         // reply as a board comment (mirrors the document assistant).
-        (0, spawn_1.spawnBoardSession)(agentId, apiKey, event.whiteboardId, event.mention ?? '', extra.settings, undefined, cwd, event.commentId);
+        (0, spawn_1.spawnBoardSession)(agentId, apiKey, event.whiteboardId, event.mention ?? '', extra.settings, undefined, runDir, event.commentId);
         return 'spawned';
     }
     if (event.type === 'build.trigger') {
@@ -567,7 +720,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
             return 'skipped';
         }
         // Build mode: start (or restart) the project's build run.
-        (0, spawn_1.spawnBuildSession)(agentId, apiKey, event.projectId, extra.settings, undefined, cwd);
+        (0, spawn_1.spawnBuildSession)(agentId, apiKey, event.projectId, extra.settings, undefined, runDir);
         return 'spawned';
     }
     if (event.type === 'build.stop') {
@@ -594,7 +747,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
             return 'skipped';
         }
         (0, daemon_support_1.log)(`agent ${agentId}: plan.trigger task=${event.taskId} -> planning session`);
-        (0, spawn_1.spawnPlanSession)(agentId, apiKey, event.taskId, event.projectId ?? undefined, extra.settings, undefined, cwd);
+        (0, spawn_1.spawnPlanSession)(agentId, apiKey, event.taskId, event.projectId ?? undefined, extra.settings, undefined, runDir);
         return 'spawned';
     }
     if (event.type === 'tool.trigger') {
@@ -603,7 +756,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
             return 'skipped';
         }
         // Tools-as-tasks: spawn the research/data-collection session for this run.
-        (0, spawn_1.spawnResearchSession)(agentId, apiKey, event.projectId, event.runId, event.toolKey ?? 'tool', extra.settings, undefined, cwd);
+        (0, spawn_1.spawnResearchSession)(agentId, apiKey, event.projectId, event.runId, event.toolKey ?? 'tool', extra.settings, undefined, runDir);
         // Mark this run as worked so a later reconnect re-sync does not spawn a
         // duplicate research session for the same run.
         (0, wake_state_1.recordProcessed)(agentId, 'tool.trigger', String(event.runId));
@@ -657,7 +810,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
             catch {
                 /* best-effort */
             }
-            (0, spawn_1.spawnBuildSession)(agentId, apiKey, event.projectId, extra.settings, undefined, cwd);
+            (0, spawn_1.spawnBuildSession)(agentId, apiKey, event.projectId, extra.settings, undefined, runDir);
             spawned = true;
         }
         else if (event.taskId) {
@@ -667,7 +820,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
             // has no record here, so nothing is spawned - the next run is fresh.
             //
             // workMode-aware (2026-09): a task in build mode must NEVER resume a
-            // plan session (the plan conversation opens with "PLAN MODE … must NOT
+            // plan session (the plan conversation opens with "PLAN MODE —¦ must NOT
             // execute" and the model inherits that read-only claim). Tool/research
             // tasks are always build-mode and skip the plan branch entirely.
             let workMode;
@@ -677,21 +830,21 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
                 workMode = t.workMode;
                 taskKind = t.kind;
             }
-            catch { /* best-effort — fall through to session-only logic */ }
+            catch { /* best-effort —” fall through to session-only logic */ }
             const isToolTask = taskKind === 'research' || taskKind === 'tool';
             const planAllowed = !isToolTask && workMode !== 'build';
             if ((0, session_store_1.hasHarnessSession)(agentId, event.taskId, 'run')) {
                 (0, daemon_support_1.log)(`agent ${agentId}: question.answered -> resuming run session for task ${event.taskId}`);
-                (0, spawn_1.spawnAgentSession)(agentId, apiKey, event.taskId, extra.settings, undefined, cwd);
+                (0, spawn_1.spawnAgentSession)(agentId, apiKey, event.taskId, extra.settings, undefined, runDir);
                 spawned = true;
             }
             else if (planAllowed && (0, session_store_1.hasHarnessSession)(agentId, event.taskId, 'plan')) {
                 (0, daemon_support_1.log)(`agent ${agentId}: question.answered -> resuming plan session for task ${event.taskId}`);
-                (0, spawn_1.spawnPlanSession)(agentId, apiKey, event.taskId, event.projectId ?? undefined, extra.settings, undefined, cwd);
+                (0, spawn_1.spawnPlanSession)(agentId, apiKey, event.taskId, event.projectId ?? undefined, extra.settings, undefined, runDir);
                 spawned = true;
             }
             else if ((0, session_store_1.hasHarnessSession)(agentId, event.taskId, 'build')) {
-                (0, spawn_1.spawnBuildSession)(agentId, apiKey, event.projectId, extra.settings, undefined, cwd);
+                (0, spawn_1.spawnBuildSession)(agentId, apiKey, event.projectId, extra.settings, undefined, runDir);
                 spawned = true;
             }
             else {
@@ -701,7 +854,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
         return spawned ? 'spawned' : 'skipped';
     }
     if (event.type === 'question.expired') {
-        // Expired-on-timeout: same wake path as question.answered — the agent
+        // Expired-on-timeout: same wake path as question.answered —” the agent
         // needs to know the question timed out so it can retry, escalate, or
         // skip the task. The backend already marked the question expired; we
         // just wake the agent loop so it picks up the new state.
@@ -726,7 +879,7 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
             catch {
                 /* best-effort */
             }
-            (0, spawn_1.spawnBuildSession)(agentId, apiKey, event.projectId, extra.settings, undefined, cwd);
+            (0, spawn_1.spawnBuildSession)(agentId, apiKey, event.projectId, extra.settings, undefined, runDir);
             spawned = true;
         }
         else if (event.taskId) {
@@ -743,15 +896,15 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
             const isToolTask = taskKind === 'research' || taskKind === 'tool';
             const planAllowed = !isToolTask && workMode !== 'build';
             if ((0, session_store_1.hasHarnessSession)(agentId, event.taskId, 'run')) {
-                (0, spawn_1.spawnAgentSession)(agentId, apiKey, event.taskId, extra.settings, undefined, cwd);
+                (0, spawn_1.spawnAgentSession)(agentId, apiKey, event.taskId, extra.settings, undefined, runDir);
                 spawned = true;
             }
             else if (planAllowed && (0, session_store_1.hasHarnessSession)(agentId, event.taskId, 'plan')) {
-                (0, spawn_1.spawnPlanSession)(agentId, apiKey, event.taskId, event.projectId ?? undefined, extra.settings, undefined, cwd);
+                (0, spawn_1.spawnPlanSession)(agentId, apiKey, event.taskId, event.projectId ?? undefined, extra.settings, undefined, runDir);
                 spawned = true;
             }
             else if ((0, session_store_1.hasHarnessSession)(agentId, event.taskId, 'build')) {
-                (0, spawn_1.spawnBuildSession)(agentId, apiKey, event.projectId, extra.settings, undefined, cwd);
+                (0, spawn_1.spawnBuildSession)(agentId, apiKey, event.projectId, extra.settings, undefined, runDir);
                 spawned = true;
             }
         }
@@ -761,8 +914,8 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
         // Comment mentions on tasks spawn a task session (agent responds in
         // the task thread). Document comment mentions spawn the doc assistant.
         if (event.documentId) {
-            if (projectId && cwd) {
-                (0, spawn_1.spawnDocumentSession)(agentId, apiKey, event.documentId, event.mention ?? '', extra.settings, undefined, cwd, event.commentId);
+            if (projectId && runDir) {
+                (0, spawn_1.spawnDocumentSession)(agentId, apiKey, event.documentId, event.mention ?? '', extra.settings, undefined, runDir, event.commentId, event.mentionId ?? undefined, projectId ?? undefined);
                 return 'spawned';
             }
             return 'skipped';
@@ -776,16 +929,16 @@ async function spawnWake(api, agentId, apiKey, event, config, extra = {}) {
     }
     // Multi-repo: build repoMap from config for spawned sessions.
     const repoMap = buildRepoMap(projectId);
-    // IMP-810: Worker mode — spawn the worker loop for orchestrator subtasks
+    // IMP-810: Worker mode —” spawn the worker loop for orchestrator subtasks
     if (event.role === 'worker') {
         (0, daemon_support_1.log)(`agent ${agentId}: spawning worker session for task ${taskId}`);
-        (0, spawn_1.spawnWorkerSession)(agentId, apiKey, taskId, event.orchestratorTaskId, extra.settings, undefined, cwd, repoMap);
+        (0, spawn_1.spawnWorkerSession)(agentId, apiKey, taskId, event.orchestratorTaskId, extra.settings, undefined, runDir, repoMap);
         return 'spawned';
     }
     // `task.run` is an explicit human "Run task": it must run exactly like an
     // open task (status bypass) AND, on success, end in `in_review` regardless
     // of the prior status (including closed/resolved). Flag it for the CLI.
-    (0, spawn_1.spawnAgentSession)(agentId, apiKey, taskId, extra.settings, undefined, cwd, repoMap, event.type === 'task.run');
+    (0, spawn_1.spawnAgentSession)(agentId, apiKey, taskId, extra.settings, undefined, runDir, repoMap, event.type === 'task.run');
     return 'spawned';
 }
 //# sourceMappingURL=wake-handler.js.map