mixdog 0.9.28 → 0.9.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.28",
+  "version": "0.9.30",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/pending-completion-drop-test.mjs

@@ -0,0 +1,64 @@
+// Proves deferred agent/tool *completion* notifications are DROPPED on drain
+// (never replayed out-of-order on a later session resume) while genuine
+// user/steering messages in the same queue survive with order preserved.
+// Owner decision: out-of-order replay is worse than loss.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// Redirect the pending-message spool to a throwaway dir before import so the
+// real ~/.mixdog/data spool is never touched.
+const dataDir = mkdtempSync(join(tmpdir(), 'mixpend-'));
+process.env.MIXDOG_DATA_DIR = dataDir;
+
+const {
+  enqueuePendingMessage,
+  drainPendingMessages,
+  COMPLETION_NOTIFICATION_KIND,
+  markCompletionEntry,
+} = await import('../src/runtime/agent/orchestrator/session/manager/pending-messages.mjs');
+
+function completionEntry(text) {
+  return { content: text, text, notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: Date.now() };
+}
+
+test('drain drops completion notifications, keeps user messages in order', async () => {
+  const sid = 'sess_drop_test_1';
+  enqueuePendingMessage(sid, 'user first');
+  enqueuePendingMessage(sid, completionEntry('Async agent task xyz finished.\n\nResult:\n> done'));
+  enqueuePendingMessage(sid, 'user second');
+
+  // Let the buffered persist flush to disk so we also verify the on-disk marker
+  // (the shape a later resume would drain).
+  await new Promise((r) => setImmediate(r));
+  await new Promise((r) => setTimeout(r, 30));
+  const store = JSON.parse(readFileSync(join(dataDir, 'session-pending-messages.json'), 'utf8'));
+  const persistedQueue = store.sessions[sid] || [];
+  const marked = persistedQueue.filter((e) => e && typeof e === 'object' && e.notificationKind === COMPLETION_NOTIFICATION_KIND);
+  assert.equal(marked.length, 1, 'completion notification persisted as a marked object');
+  assert.ok(persistedQueue.includes('user first') && persistedQueue.includes('user second'), 'user messages persisted as plain strings');
+
+  const drained = drainPendingMessages(sid).map((m) => (typeof m === 'string' ? m : m.text));
+  assert.deepEqual(drained, ['user first', 'user second'], 'completion dropped; user messages kept in order');
+  assert.ok(!drained.some((t) => /finished/.test(t)), 'no completion prose replayed');
+
+  // A second drain (post-resume) yields nothing — the completion was discarded,
+  // not deferred.
+  assert.deepEqual(drainPendingMessages(sid), []);
+});
+
+test.after(() => {
+  try { rmSync(dataDir, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+// Proves the shared tagger (used by notify.mjs, tool-exec.mjs, runtime-core.mjs)
+// yields entries drain drops, while a real user message survives in order.
+test('markCompletionEntry path is dropped on drain; user message survives', () => {
+  const sid = 'sess_drop_test_2';
+  enqueuePendingMessage(sid, 'real user question');
+  enqueuePendingMessage(sid, markCompletionEntry('Async agent task abc finished.\n\nResult:\n> ok'));
+  const drained = drainPendingMessages(sid).map((m) => (typeof m === 'string' ? m : m.text));
+  assert.deepEqual(drained, ['real user question']);
+});

package/src/rules/lead/lead-tool.md

@@ -5,5 +5,4 @@
   directly.
 - Use the session's current project/workspace. Change the work project only
   when the user asks for another project or a tool call needs another root.
-- Use `agent` for scoped implementation, research, review, and debugging — not
-  for git commit/push/stash or Ship.
+- Use `agent` for scoped implementation, research, review, and debugging.

package/src/rules/shared/01-tool.md

@@ -1,10 +1,12 @@
 # Tool Use
 
-- Every turn carries ALL independent calls you can already specify — a
-  second consecutive single-lookup turn is a defect, not a style choice;
-  serialize only on real data dependency. Merge variants/scopes into ONE
-  call wherever the schema accepts arrays (`pattern[]`, `path[]`,
-  `symbols[]`, `query[]`).
+- BATCH OR IT IS A DEFECT — this is the single hardest rule here. Every turn
+  fires ALL independent calls at once; a second consecutive single-lookup,
+  single-`shell`, or single-`apply_patch` turn is a defect, never a style
+  choice. Serialize ONLY on a real data dependency — nothing else earns a
+  solo call. Merge variants/scopes into ONE call wherever the schema takes
+  arrays (`pattern[]`, `path[]`, `symbols[]`, `query[]`), chain shell with
+  `;`/`&&` or run them in parallel, and put every known edit in ONE patch.
 - Route by what is already known: known symbol/relation → `code_graph`;
   exact text in a known scope → `grep`; unknown location, machine-wide/
   out-of-repo whereabouts, or concept-level question → `explore` (which uses
@@ -33,9 +35,9 @@
   unit (function/section) — over-read once instead of paging the same file
   in small windows across turns; a 3rd window into one file means the first
   should have been wider.
-- Don't mix `apply_patch` with shell or other state-changing calls in one
-  turn; batch independent-file patches in one turn, then verify them all in
-  ONE shell call the next.
-- Consecutive single `shell` or `apply_patch` turns are a batching miss
-  unless output-dependent: chain shell commands with `;`/`&&` or call in
-  parallel; put all known edits in ONE patch.
+- Parallel-first has ONE carve-out: verifying your own edits. Keep an
+  `apply_patch` and the `shell` that checks it in separate turns — not for
+  ordering (same-turn calls run in emit order), but because you must SEE the
+  patch result before verifying: a same-turn shell is already emitted and
+  can't react to a failed or partial patch. Batch the patches this turn,
+  verify them all in ONE shell call the next. Anything else stays parallel.

package/src/runtime/agent/orchestrator/session/loop/tool-exec.mjs

@@ -9,7 +9,7 @@ import { executeBashSessionTool } from '../../tools/bash-session.mjs';
 import { executePatchTool } from '../../tools/patch.mjs';
 import { executeInternalTool, isInternalTool } from '../../internal-tools.mjs';
 import { normalizeToolEnvelope, makeToolEnvelope } from '../tool-envelope.mjs';
-import { getSessionAbortSignal, enqueuePendingMessage } from '../manager.mjs';
+import { getSessionAbortSignal, enqueuePendingMessage, markCompletionEntry } from '../manager.mjs';
 import { createScopedCacheOutcome } from '../cache/scoped-cache-outcome.mjs';
 import { modelVisibleToolCompletionMessage } from '../../../../shared/tool-execution-contract.mjs';
 import { _isScopedCacheableTool } from './tool-classify.mjs';
@@ -68,7 +68,9 @@ export async function executeTool(name, args, cwd, callerSessionId, sessionRef,
             if (!notificationSessionId) return;
             try {
                 const visible = modelVisibleToolCompletionMessage(text, meta);
-                if (visible) enqueuePendingMessage(notificationSessionId, visible);
+                // Inherently a tool-completion notification → tag so a later
+                // resume drops it instead of replaying it as user text.
+                if (visible) enqueuePendingMessage(notificationSessionId, markCompletionEntry(visible));
             } catch { /* best effort */ }
         };
     const completionToolOpts = {

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -11,9 +11,31 @@ const PENDING_MESSAGES_FILE = 'session-pending-messages.json';
 const PENDING_MESSAGES_MODE = 0o600;
 const PENDING_ORPHAN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const PENDING_ORPHAN_GRACE_MS = 60 * 60 * 1000;
+// Marker for deferred agent/tool *completion* notifications. Such entries must
+// never be replayed into a later turn on session resume (out-of-order delivery
+// is worse than loss — owner decision), so drain discards them. Genuine
+// user/steering messages carry no marker and keep full queue + replay behavior.
+export const COMPLETION_NOTIFICATION_KIND = 'completion_notification';
 const _pendingPersistBuffers = new Map();
 let _pendingPersistImmediate = null;
 
+function isCompletionNotificationEntry(entry) {
+    return Boolean(entry) && typeof entry === 'object'
+        && entry.notificationKind === COMPLETION_NOTIFICATION_KIND;
+}
+
+// Canonical completion-enqueue tagger. Every deferred tool/agent completion
+// notification MUST be enqueued through this so drain can discard it on resume
+// (never replay out-of-order). Pass the model-visible completion text (or an
+// existing entry); genuine user/steering messages must NOT be tagged.
+export function markCompletionEntry(text) {
+    const value = typeof text === 'string'
+        ? text
+        : (text && typeof text === 'object' ? (text.text || text.content || '') : '');
+    const content = String(value ?? '');
+    return { content, text: content, notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: Date.now() };
+}
+
 function pendingMessagesPath() {
     return join(resolvePluginData(), PENDING_MESSAGES_FILE);
 }
@@ -53,13 +75,7 @@ function normalizePendingStore(raw) {
         if (!isValidPendingSessionId(sid) || !Array.isArray(value)) continue;
         const q = isTuiSteeringPendingKey(sid)
             ? value.map(normalizeTuiSteeringQueueEntry).filter(Boolean)
-            : value
-                .map((entry) => {
-                    if (typeof entry === 'string') return entry;
-                    if (entry && typeof entry === 'object' && typeof entry.message === 'string') return entry.message;
-                    return '';
-                })
-                .filter(Boolean);
+            : value.map(normalizePersistedEntry).filter(Boolean);
         if (q.length > 0) {
             out.sessions[sid] = q;
             const touched = Number(touchedRaw[sid]);
@@ -85,16 +101,22 @@ function normalizePendingMessageEntry(entry) {
         return { content: entry, text };
     }
     if (!entry || typeof entry !== 'object') return null;
+    const marker = entry.notificationKind === COMPLETION_NOTIFICATION_KIND
+        ? { notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: Number(entry.enqueuedAt) || Date.now() }
+        : null;
     const content = Object.prototype.hasOwnProperty.call(entry, 'content') ? entry.content : null;
     if (content == null) return null;
     const text = typeof entry.text === 'string' ? entry.text.trim() : promptContentText(content).trim();
-    if (Array.isArray(content)) return content.length > 0 ? { content, text } : null;
-    if (typeof content === 'string') {
+    let out = null;
+    if (Array.isArray(content)) out = content.length > 0 ? { content, text } : null;
+    else if (typeof content === 'string') {
         const value = content.trim();
-        return value ? { content: value, text: text || value } : null;
+        out = value ? { content: value, text: text || value } : null;
+    } else {
+        const fallback = promptContentText(content).trim();
+        out = fallback ? { content: fallback, text: text || fallback } : null;
     }
-    const fallback = promptContentText(content).trim();
-    return fallback ? { content: fallback, text: text || fallback } : null;
+    return out && marker ? { ...out, ...marker } : out;
 }
 
 function pendingMessageText(entry) {
@@ -105,14 +127,39 @@ function pendingMessageText(entry) {
 function pendingMessageQueueEntry(entry) {
     const normalized = normalizePendingMessageEntry(entry);
     if (!normalized) return null;
-    if (typeof normalized.content === 'string' && normalized.content === normalized.text) return normalized.content;
-    return { content: normalized.content, text: normalized.text || promptContentText(normalized.content).trim() };
+    const marker = isCompletionNotificationEntry(normalized)
+        ? { notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: normalized.enqueuedAt }
+        : null;
+    if (typeof normalized.content === 'string' && normalized.content === normalized.text && !marker) return normalized.content;
+    const base = { content: normalized.content, text: normalized.text || promptContentText(normalized.content).trim() };
+    return marker ? { ...base, ...marker } : base;
+}
+
+// Canonical persisted-queue entry: a plain string for user/steering messages,
+// or a { message, notificationKind, enqueuedAt } object for completion/task
+// notifications so the marker survives an on-disk round trip. Accepts either an
+// in-memory queue entry (content/text) or an already-persisted entry
+// (string | { message } legacy | marked object); back-compatible with both.
+function normalizePersistedEntry(entry) {
+    if (typeof entry === 'string') { const t = entry.trim(); return t || null; }
+    if (!entry || typeof entry !== 'object') return null;
+    if (isCompletionNotificationEntry(entry)) {
+        const message = (typeof entry.message === 'string' && entry.message.trim())
+            ? entry.message.trim()
+            : pendingMessageText(entry);
+        return message
+            ? { message, notificationKind: COMPLETION_NOTIFICATION_KIND, enqueuedAt: Number(entry.enqueuedAt) || Date.now() }
+            : null;
+    }
+    if (typeof entry.message === 'string') { const t = entry.message.trim(); return t || null; }
+    const t = pendingMessageText(entry);
+    return t || null;
 }
 
 function persistPendingMessages(sessionId, messages) {
     if (!isValidPendingSessionId(sessionId)) return 0;
     const persistedMessages = (Array.isArray(messages) ? messages : [messages])
-        .map(pendingMessageText)
+        .map(normalizePersistedEntry)
         .filter(Boolean);
     if (persistedMessages.length === 0) return 0;
     // Async lock wait: this runs on the lead/TUI main process (tool-exec +
@@ -159,7 +206,7 @@ function flushPendingMessagePersistsSync() {
 
 function schedulePendingMessagePersist(sessionId, message) {
     if (!isValidPendingSessionId(sessionId)) return 0;
-    const persistedMessage = pendingMessageText(message);
+    const persistedMessage = normalizePersistedEntry(message);
     if (!persistedMessage) return 0;
     const q = _pendingPersistBuffers.get(sessionId) || [];
     q.push(persistedMessage);
@@ -192,7 +239,7 @@ function drainPersistedPendingMessages(sessionId) {
         updateJsonAtomicSync(pendingMessagesPath(), (raw) => {
             const next = normalizePendingStore(raw);
             const q = Array.isArray(next.sessions[sessionId]) ? next.sessions[sessionId] : [];
-            drained = q.filter((m) => typeof m === 'string' && m.length > 0);
+            drained = q.filter((m) => (typeof m === 'string' && m.length > 0) || isCompletionNotificationEntry(m));
             if (drained.length === 0) return undefined;
             delete next.sessions[sessionId];
             if (next.sessionTouchedAt) delete next.sessionTouchedAt[sessionId];
@@ -335,8 +382,13 @@ export function drainPendingMessages(sessionId) {
     // first. Reversing this order (buffer before disk) delivered newer
     // buffered sends ahead of older persisted ones after a restart.
     const persisted = [...drainPersistedPendingMessages(sessionId), ...takeBufferedPendingMessages(sessionId)];
-    const memoryVisible = modelVisiblePendingMessages(memory);
-    const persistedVisible = modelVisiblePendingMessages(persisted);
+    // Discard deferred completion/task notifications instead of injecting them
+    // out-of-order into a future turn on resume. Genuine user/steering messages
+    // (plain strings / content entries) carry no marker and are kept in order.
+    const memoryKept = memory.filter((m) => !isCompletionNotificationEntry(m));
+    const persistedKept = persisted.filter((m) => !isCompletionNotificationEntry(m));
+    const memoryVisible = modelVisiblePendingMessages(memoryKept);
+    const persistedVisible = modelVisiblePendingMessages(persistedKept);
     if (memoryVisible.length === 0) return persistedVisible;
     if (persistedVisible.length === 0) return memoryVisible;
     const persistedTexts = persistedVisible.map(pendingMessageText);

package/src/runtime/agent/orchestrator/session/manager.mjs

@@ -63,6 +63,8 @@ export {
     _mergePendingMessageEntries,
     enqueuePendingMessage,
     drainPendingMessages,
+    markCompletionEntry,
+    COMPLETION_NOTIFICATION_KIND,
 } from './manager/pending-messages.mjs';
 export { isInternalRuntimeNotificationText as _isInternalRuntimeNotificationText } from './manager/prompt-utils.mjs';
 

package/src/runtime/channels/backends/discord-access.mjs

@@ -11,9 +11,7 @@ function defaultAccess() {
 function normalizeAccess(parsed) {
   const defaults = defaultAccess();
   return {
-    // Legacy "pairing" policy was removed (its approval flow was never
-    // completable); normalize it to "allowlist" on load.
-    dmPolicy: parsed?.dmPolicy === "pairing" ? "allowlist" : (parsed?.dmPolicy ?? defaults.dmPolicy),
+    dmPolicy: parsed?.dmPolicy ?? defaults.dmPolicy,
     allowFrom: parsed?.allowFrom ?? defaults.allowFrom,
     channels: parsed?.channels ?? defaults.channels,
     mentionPatterns: parsed?.mentionPatterns,

package/src/runtime/channels/backends/telegram.mjs

@@ -56,7 +56,7 @@ function defaultAccess() {
 function normalizeAccess(parsed) {
   const defaults = defaultAccess();
   return {
-    dmPolicy: parsed?.dmPolicy === "pairing" ? "allowlist" : (parsed?.dmPolicy ?? defaults.dmPolicy),
+    dmPolicy: parsed?.dmPolicy ?? defaults.dmPolicy,
     allowFrom: parsed?.allowFrom ?? defaults.allowFrom,
     channels: parsed?.channels ?? defaults.channels,
     mentionPatterns: parsed?.mentionPatterns,

package/src/runtime/channels/lib/config.mjs

@@ -39,27 +39,10 @@ function channelIdForBackend(entry = {}, backend = "discord") {
 }
 
 // Resolve the single active-backend channel id from the config's `channel`
-// section. Backward compat (read-side only, no on-disk migration): when
-// `channel` is absent, fall back to the legacy `channelsConfig[mainChannel]`
-// entry (or the first entry that carries an id).
+// section. Disk config carries a single `channel` object only.
 function resolveChannelId(raw = {}, backend = "discord") {
   const channel = raw.channel && typeof raw.channel === "object" ? raw.channel : null;
   if (channel) return channelIdForBackend(channel, backend);
-  const legacy = raw.channelsConfig && typeof raw.channelsConfig === "object" ? raw.channelsConfig : null;
-  if (legacy) {
-    const mainName = raw.mainChannel ?? "main";
-    const preferred = legacy[mainName];
-    if (preferred && typeof preferred === "object") {
-      const id = channelIdForBackend(preferred, backend);
-      if (id) return id;
-    }
-    for (const entry of Object.values(legacy)) {
-      if (entry && typeof entry === "object") {
-        const id = channelIdForBackend(entry, backend);
-        if (id) return id;
-      }
-    }
-  }
   return "";
 }
 
@@ -96,13 +79,11 @@ async function loadConfig() {
     const backend = raw.backend === "telegram" ? "telegram" : "discord";
     const telegramToken = getTelegramToken();
     const channelId = resolveChannelId(raw, backend);
-    // Drop legacy multi-channel keys from the returned shape; the runtime
-    // reads only the resolved `channelId` now (read-side compat lives in
-    // resolveChannelId — no on-disk migration).
-    const { channelsConfig: _legacyChannels, mainChannel: _legacyMain, ...rawRest } = raw;
+    // The runtime reads only the resolved `channelId`; disk carries a single
+    // `channel` object, so spread `raw` directly.
     return applyDefaults({
       ...DEFAULT_CONFIG,
-      ...rawRest,
+      ...raw,
       backend,
       channelId,
       discord: { ...DEFAULT_CONFIG.discord, ...(({ token: _, ...rest }) => rest)(raw.discord || {}), ...(discordToken && !discordTokenProblem ? { token: discordToken } : {}) },
@@ -111,12 +92,7 @@ async function loadConfig() {
       telegram: { ...DEFAULT_CONFIG.telegram, ...(({ token: _t, ...rest }) => rest)(raw.telegram || {}), ...(telegramToken ? { token: telegramToken } : {}) },
       access: {
         ...DEFAULT_ACCESS,
-        // Drop the retired pairing-era keys at the config layer too (the
-        // Discord backend's normalizeAccess() is the runtime belt): legacy
-        // dmPolicy "pairing" → "allowlist", and the `pending` code store is
-        // gone entirely.
-        ...(({ pending: _pending, ...rest }) => rest)(raw.access || {}),
-        ...(raw.access?.dmPolicy === "pairing" ? { dmPolicy: "allowlist" } : {}),
+        ...(raw.access || {}),
         channels: accessChannels,
       },
       voice: { ...(raw.voice || {}), ...voice }

package/src/runtime/shared/child-guardian.mjs

@@ -1,6 +1,6 @@
 'use strict';
 
-import { spawn, spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { detachedSpawnOpts } from './spawn-flags.mjs';
 
 function positiveInt(value) {
@@ -8,64 +8,12 @@ function positiveInt(value) {
   return Number.isInteger(n) && n > 0 ? n : null;
 }
 
-// On Windows a windowless, orphaned pwsh->cli chain keeps the immediate parent
-// PID alive after its terminal window is closed, so parent-liveness alone never
-// releases the worker. When the session is genuinely interactive (a TTY), the
-// controlling console window is owned by a host process (conhost.exe) that dies
-// with the terminal — monitoring that PID turns "terminal closed" into a fatal
-// orphan signal. Returns null for non-interactive/service/hidden-console starts
-// (no TTY, or no console window) so those are never treated as terminal loss.
-function detectControllingTerminalPid() {
-  if (process.platform !== 'win32') return null;
-  // Gate on a real TTY: a service/pipe/hidden launch has no controlling
-  // terminal, and probing one there would spawn a transient console whose host
-  // dies immediately — a false "terminal lost" that would kill a healthy worker.
-  const interactive = Boolean(
-    (process.stdin && process.stdin.isTTY) || (process.stdout && process.stdout.isTTY),
-  );
-  if (!interactive) return null;
-  try {
-    const systemRoot = process.env.SystemRoot || process.env.WINDIR || 'C:\\Windows';
-    const powershell = systemRoot + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
-    const script = [
-      'Add-Type @"',
-      'using System;',
-      'using System.Runtime.InteropServices;',
-      'public class MixdogTerm {',
-      '  [DllImport("kernel32.dll")] public static extern IntPtr GetConsoleWindow();',
-      '  [DllImport("user32.dll")] public static extern int GetWindowThreadProcessId(IntPtr h, out int pid);',
-      '}',
-      '"@',
-      '$h=[MixdogTerm]::GetConsoleWindow()',
-      'if($h -eq [IntPtr]::Zero){ Write-Output 0 } else { $p=0; [void][MixdogTerm]::GetWindowThreadProcessId($h,[ref]$p); Write-Output $p }',
-    ].join('\n');
-    // NO windowsHide: CREATE_NO_WINDOW gives the probe its own/absent console so
-    // GetConsoleWindow() returns 0 or a foreign hwnd. A plain console app spawned
-    // from a console-attached parent (this runs at the guardian start site, in the
-    // guarded parent) inherits that console with no window flash. Under Windows
-    // Terminal/ConPTY the owner is the tab's conhost (dies on tab close), which is
-    // exactly the pid we want to monitor.
-    const res = spawnSync(powershell, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script], {
-      timeout: 4000,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    });
-    const pid = positiveInt(String((res && res.stdout) || '').trim());
-    // Ignore our own PID: that would make the guardian its own kill trigger.
-    if (pid && pid !== process.pid) return pid;
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-function guardianScript({ parentPid, childPid, childGroupPid, terminalPid, platform, pollMs, orphanGraceMs, forceGraceMs }) {
+function guardianScript({ parentPid, childPid, childGroupPid, platform, pollMs, orphanGraceMs, forceGraceMs }) {
   return `
 const { spawnSync } = require('node:child_process');
 const parentPid = ${JSON.stringify(parentPid)};
 const childPid = ${JSON.stringify(childPid)};
 const childGroupPid = ${JSON.stringify(childGroupPid || childPid)};
-const terminalPid = ${JSON.stringify(terminalPid || 0)};
 const platform = ${JSON.stringify(platform)};
 const pollMs = ${JSON.stringify(pollMs)};
 const orphanGraceMs = ${JSON.stringify(orphanGraceMs)};
@@ -95,12 +43,10 @@ let killing = false;
 let orphanedAt = 0;
 const timer = setInterval(() => {
   if (!alive(childPid)) process.exit(0);
-  // Orphaned when the parent PID dies OR (interactive only) the controlling
-  // terminal's console host dies — the latter catches a windowless pwsh->cli
-  // chain that outlives its closed terminal window. terminalPid is 0 for
-  // non-interactive starts, so those fall back to pure parent-liveness.
-  const terminalLost = terminalPid > 0 && !alive(terminalPid);
-  if (alive(parentPid) && !terminalLost) {
+  // Orphaned when the parent PID dies. Matches Claude Code / pi: no console
+  // probe — a hidden shell spawn (windowsHide) plus tree-kill on cleanup, so
+  // orphan detection is pure parent-liveness.
+  if (alive(parentPid)) {
     orphanedAt = 0;
     return;
   }
@@ -135,7 +81,6 @@ export function startChildGuardian({
         parentPid: parent,
         childPid: child,
         childGroupPid: positiveInt(childGroupPid) || child,
-        terminalPid: detectControllingTerminalPid() || 0,
         platform: process.platform,
         pollMs: Math.max(100, Math.floor(Number(pollMs) || 750)),
         orphanGraceMs: Math.max(100, Math.floor(Number(orphanGraceMs) || Number(graceMs) || 3000)),

package/src/runtime/shared/config.mjs

@@ -315,14 +315,9 @@ export function diagnoseDiscordTokenValue(value, config = {}) {
   const discord = config?.discord && typeof config.discord === 'object' ? config.discord : {}
   const appId = String(discord.applicationId || '').trim()
   if (appId && token === appId) return 'Bot token field contains the Application ID, not the bot token.'
-  // Single main channel: check the `channel` object. Legacy `channelsConfig`
-  // is still read here (read-only) so the diagnostic keeps working on configs
-  // that predate the single-channel collapse.
+  // Single main channel: check the `channel` object.
   const candidateEntries = []
   if (config?.channel && typeof config.channel === 'object') candidateEntries.push(config.channel)
-  if (config?.channelsConfig && typeof config.channelsConfig === 'object') {
-    candidateEntries.push(...Object.values(config.channelsConfig))
-  }
   for (const ch of candidateEntries) {
     if (!ch || typeof ch !== 'object') continue
     for (const id of [ch.channelId, ch.discordChannelId, ch.telegramChatId]) {

package/src/runtime/shared/schedules-db.mjs

@@ -3,10 +3,8 @@
  * schedules (schema `scheduler`, table `scheduler.schedules`).
  *
  * All schedule readers/writers (scheduler.mjs, config.mjs, channel-admin.mjs)
- * go through this module. Legacy `<dataDir>/schedules/<name>/SCHEDULE.md`
- * files are imported once by the migration hook in getDb and the directory is
- * renamed to `schedules.migrated`; the old file-based schedules-store.mjs has
- * been removed.
+ * go through this module. It is the sole store for schedules; the old
+ * file-based schedules-store.mjs has been retired.
  *
  * DDL is idempotent and runs once on the first call per process. All queries
  * fully-qualify `scheduler.schedules` so they are correct regardless of the
@@ -15,9 +13,6 @@
 
 import { ensurePgInstance, withSchemaBootstrapLock } from '../memory/lib/pg/adapter.mjs';
 import { resolvePluginData } from './plugin-paths.mjs';
-import { readdirSync, readFileSync, renameSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { readMarkdownDocument } from './markdown-frontmatter.mjs';
 
 const SCHEMA = 'scheduler';
 
@@ -58,7 +53,6 @@ async function getDb(dataDir = resolvePluginData()) {
     // same cluster-global advisory lock the adapter uses for schema bootstrap,
     // so racing first calls can't run the DDL simultaneously.
     await withSchemaBootstrapLock(pool, () => db.exec(DDL));
-    await migrateLegacySchedules(db, dataDir);
     return db;
   })();
   _ready.set(dataDir, p);
@@ -70,118 +64,6 @@ async function getDb(dataDir = resolvePluginData()) {
   }
 }
 
-// ---------------------------------------------------------------------------
-// One-time legacy SCHEDULE.md migration (additive; runs once per dataDir on
-// first getDb, right after DDL). Imports every `<dataDir>/schedules/<name>/
-// SCHEDULE.md` not already present in the table (by name), using the same
-// days->cron folding as the admin write path, then renames the directory to
-// `schedules.migrated` (never deletes user data). Per-entry failures are
-// isolated and never block store readiness.
-// ---------------------------------------------------------------------------
-
-// Day-name / keyword -> cron day-of-week number (Sun=0 .. Sat=6).
-const MIGRATE_DAY_TO_DOW = {
-  sun: 0, sunday: 0,
-  mon: 1, monday: 1,
-  tue: 2, tues: 2, tuesday: 2,
-  wed: 3, weds: 3, wednesday: 3,
-  thu: 4, thur: 4, thurs: 4, thursday: 4,
-  fri: 5, friday: 5,
-  sat: 6, saturday: 6,
-};
-
-function foldLegacyDaysIntoCron(cron, days) {
-  const parts = String(cron || '').trim().split(/\s+/).filter(Boolean);
-  if (parts.length !== 5 && parts.length !== 6) {
-    throw new Error(`invalid cron "${cron}"`);
-  }
-  const raw = String(days || '').trim().toLowerCase();
-  const dowIndex = parts.length - 1;
-  // days absent -> keep the cron's own day-of-week field ('0 9 * * 1' stays
-  // Monday-only). Only an explicit selector rewrites the dow field.
-  if (!raw) return parts.join(' ');
-  let dow;
-  if (raw === 'daily' || raw === 'everyday' || raw === 'every day') dow = '*';
-  else if (raw === 'weekday' || raw === 'weekdays') dow = '1-5';
-  else if (raw === 'weekend' || raw === 'weekends') dow = '0,6';
-  else {
-    const nums = raw.split(/[\s,]+/).filter(Boolean).map((t) => (
-      /^[0-6]$/.test(t) ? Number(t) : MIGRATE_DAY_TO_DOW[t]
-    ));
-    if (nums.some((n) => n === undefined)) {
-      throw new Error(`days "${days}" is not a recognizable day selector`);
-    }
-    dow = nums.join(',');
-  }
-  parts[dowIndex] = dow;
-  return parts.join(' ');
-}
-
-async function migrateLegacySchedules(db, dataDir) {
-  const dir = join(dataDir, 'schedules');
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return; // no legacy schedules/ dir -> nothing to migrate
-  }
-  let imported = 0;
-  let skipped = 0;
-  const failed = [];
-  for (const ent of entries) {
-    if (!ent.isDirectory()) continue;
-    const name = ent.name;
-    try {
-      const { rows } = await db.query('SELECT 1 FROM scheduler.schedules WHERE name = $1', [name]);
-      if (rows.length) { skipped++; continue; }
-      let md;
-      try { md = readFileSync(join(dir, name, 'SCHEDULE.md'), 'utf8'); }
-      catch { skipped++; continue; }
-      const { frontmatter, body } = readMarkdownDocument(md);
-      const cron = foldLegacyDaysIntoCron(frontmatter.time, frontmatter.days);
-      const channel = String(frontmatter.channel || '').trim();
-      const enabled = frontmatter.enabled !== 'false' && frontmatter.enabled !== false;
-      await db.query(
-        `INSERT INTO scheduler.schedules
-           (name, description, when_cron, timezone, target, channel_id, model, prompt, enabled)
-         VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)
-         ON CONFLICT (name) DO NOTHING`,
-        [
-          name,
-          String(frontmatter.description || '').trim(),
-          cron,
-          frontmatter.timezone ? String(frontmatter.timezone).trim() : null,
-          channel ? 'channel' : 'session',
-          channel || null,
-          frontmatter.model ? String(frontmatter.model).trim() : null,
-          String(body || '').trim(),
-          enabled,
-        ],
-      );
-      imported++;
-    } catch (err) {
-      failed.push(name);
-      console.error(`[schedules] migration failed for "${name}": ${err?.message || err}`);
-    }
-  }
-  if (failed.length) {
-    // Some entries failed to import. Leave schedules/ in place (do NOT rename)
-    // so the next boot retries them; already-imported entries are skipped by
-    // the name check above, so retry is idempotent.
-    console.error(`[schedules] migrated ${imported} legacy schedule(s), ${failed.length} failed (${failed.join(', ')}); leaving schedules/ for retry`);
-    return;
-  }
-  try {
-    let target = `${dir}.migrated`;
-    if (existsSync(target)) target = `${dir}.migrated-${Date.now()}`;
-    renameSync(dir, target);
-  } catch (err) {
-    console.error(`[schedules] migrated ${imported} legacy schedule(s) but could not rename schedules/: ${err?.message || err}`);
-    return;
-  }
-  console.error(`[schedules] migrated ${imported} legacy schedule(s) (${skipped} skipped); renamed schedules/ -> schedules.migrated`);
-}
-
 // ---------------------------------------------------------------------------
 // Row <-> def mapping
 // ---------------------------------------------------------------------------

package/src/runtime/shared/webhooks-db.mjs

@@ -6,11 +6,9 @@
  * This module mirrors schedules-db.mjs: a lazy connection keyed per resolved
  * dataDir runs idempotent DDL exactly once per process, serialized across
  * concurrent first-boot processes on the adapter's schema-bootstrap advisory
- * lock. It covers the file-store API surface currently in
- * channels/lib/webhook/deliveries.mjs (loadEndpointConfig, appendDelivery,
- * deliveryExists, _readEndpointSecret) so call sites can migrate off the
- * per-endpoint WEBHOOK.md + deliveries.jsonl files later. No call-site
- * changes are made in this scope.
+ * lock. It is the sole store for endpoints + delivery dedup; the old
+ * per-endpoint WEBHOOK.md + deliveries.jsonl file store is fully retired
+ * (webhook.mjs reads/writes only through here).
  *
  * All queries fully-qualify their tables so they are correct regardless of
  * the connection search_path.
@@ -18,9 +16,6 @@
 
 import { ensurePgInstance, withSchemaBootstrapLock } from '../memory/lib/pg/adapter.mjs';
 import { resolvePluginData } from './plugin-paths.mjs';
-import { readdirSync, readFileSync, rmSync, rmdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { readMarkdownDocument } from './markdown-frontmatter.mjs';
 
 const SCHEMA = 'webhooks';
 
@@ -67,7 +62,6 @@ async function getDb(dataDir = resolvePluginData()) {
     // same cluster-global advisory lock the adapter uses for schema bootstrap,
     // so racing first calls can't run the DDL simultaneously.
     await withSchemaBootstrapLock(pool, () => db.exec(DDL));
-    await migrateLegacyWebhooks(db, dataDir);
     return db;
   })();
   _ready.set(dataDir, p);
@@ -79,91 +73,6 @@ async function getDb(dataDir = resolvePluginData()) {
   }
 }
 
-// ---------------------------------------------------------------------------
-// One-time legacy WEBHOOK.md migration (additive; runs once per dataDir on
-// first getDb, right after DDL). Imports every `<dataDir>/webhooks/<name>/
-// WEBHOOK.md` (+ its `secret` side file) not already present in the table (by
-// name), then DELETES the webhooks/ directory. The legacy file reading is
-// inlined here on purpose so this migration never depends on the file-store
-// deliveries.mjs module (which another scope may remove). Old per-endpoint
-// deliveries files are intentionally NOT imported — dedup history resets,
-// which is acceptable. Partial failure keeps the directory in place and logs,
-// so the next boot retries the un-imported entries idempotently.
-// ---------------------------------------------------------------------------
-async function migrateLegacyWebhooks(db, dataDir) {
-  const dir = join(dataDir, 'webhooks');
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return; // no legacy webhooks/ dir -> nothing to migrate
-  }
-  let imported = 0;
-  let skipped = 0;
-  const failed = [];
-  // Per-endpoint dirs safe to delete this run: those imported now, or already
-  // present in the table (a prior run imported them). Anything unrecognized —
-  // a dir with no WEBHOOK.md, a stray file, a failed import — is left in place.
-  const removable = [];
-  for (const ent of entries) {
-    if (!ent.isDirectory()) continue;
-    const name = ent.name;
-    try {
-      const { rows } = await db.query('SELECT 1 FROM webhooks.endpoints WHERE name = $1', [name]);
-      if (rows.length) { skipped++; removable.push(name); continue; }
-      let md;
-      try { md = readFileSync(join(dir, name, 'WEBHOOK.md'), 'utf8'); }
-      catch { skipped++; continue; }
-      const { frontmatter, body } = readMarkdownDocument(md);
-      let secret = null;
-      try { secret = String(readFileSync(join(dir, name, 'secret'), 'utf8')).trim() || null; }
-      catch { secret = null; }
-      const channel = String(frontmatter.channel || '').trim();
-      const enabled = frontmatter.enabled !== 'false' && frontmatter.enabled !== false;
-      await db.query(
-        `INSERT INTO webhooks.endpoints
-           (name, description, channel_id, role, model, parser, secret, instructions, enabled)
-         VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)
-         ON CONFLICT (name) DO NOTHING`,
-        [
-          name,
-          String(frontmatter.description || '').trim(),
-          channel || null,
-          'webhook-handler',
-          frontmatter.model ? String(frontmatter.model).trim() : null,
-          frontmatter.parser ? String(frontmatter.parser).trim() : null,
-          secret,
-          String(body || '').trim(),
-          enabled,
-        ],
-      );
-      imported++;
-      removable.push(name);
-    } catch (err) {
-      failed.push(name);
-      console.error(`[webhooks] migration failed for "${name}": ${err?.message || err}`);
-    }
-  }
-  // User chose deletion over a `.migrated` rename. Delete only the recognized
-  // per-endpoint dirs (imported now or already in the table); never blow away
-  // unimported/unrelated entries. Failed imports keep their dir for the next
-  // boot to retry (idempotent via the name check above).
-  for (const name of removable) {
-    try { rmSync(join(dir, name), { recursive: true, force: true }); }
-    catch (err) { console.error(`[webhooks] could not delete migrated dir "${name}": ${err?.message || err}`); }
-  }
-  // Remove the parent webhooks/ only once it is empty — anything unrecognized
-  // (stray files, WEBHOOK.md-less dirs, failed imports) keeps it alive.
-  let parentGone = false;
-  try {
-    if (readdirSync(dir).length === 0) { rmdirSync(dir); parentGone = true; }
-  } catch (err) {
-    console.error(`[webhooks] could not remove empty webhooks/: ${err?.message || err}`);
-  }
-  const tail = failed.length ? `${failed.length} failed (${failed.join(', ')}); ` : '';
-  console.error(`[webhooks] migrated ${imported} legacy webhook(s) (${skipped} skipped); ${tail}${parentGone ? 'removed webhooks/' : 'kept webhooks/ (non-empty)'}`);
-}
-
 // ---------------------------------------------------------------------------
 // Row <-> def mapping
 // ---------------------------------------------------------------------------
@@ -340,30 +249,6 @@ export async function claimDelivery(endpoint, deliveryId, fields = {}, { dataDir
   return { claimed: false, duplicate: true, row: rowToDelivery(existing[0]) };
 }
 
-/**
- * True when a delivery id has already been recorded for the endpoint (any
- * status). Callers wanting terminal-vs-inflight semantics inspect the row via
- * getDelivery; claimDelivery is the race-safe gate.
- */
-export async function deliveryExists(endpoint, deliveryId, { dataDir } = {}) {
-  if (!endpoint || !deliveryId) return false;
-  const db = await getDb(dataDir);
-  const { rows } = await db.query(
-    'SELECT 1 FROM webhooks.deliveries WHERE endpoint = $1 AND delivery_id = $2',
-    [endpoint, deliveryId],
-  );
-  return rows.length > 0;
-}
-
-export async function getDelivery(endpoint, deliveryId, { dataDir } = {}) {
-  const db = await getDb(dataDir);
-  const { rows } = await db.query(
-    `SELECT ${DELIVERY_COLS} FROM webhooks.deliveries WHERE endpoint = $1 AND delivery_id = $2`,
-    [endpoint, deliveryId],
-  );
-  return rowToDelivery(rows[0]);
-}
-
 /**
  * Update the status (and optional event/error) of an existing delivery,
  * keyed by (endpoint, delivery_id). Returns the updated row or null.
@@ -383,23 +268,3 @@ export async function updateDeliveryStatus(endpoint, deliveryId, status, fields
   );
   return rowToDelivery(rows[0]);
 }
-
-/**
- * Append a delivery record (claim-or-update convenience covering the old
- * appendDelivery). First write for an id claims it; a later write with the
- * same id updates its status/fields latest-wins.
- *
- * Returns the claim outcome — { claimed, duplicate, row } — NOT a bare row,
- * so a pre-dispatch caller can detect a concurrent duplicate (claimed:false,
- * duplicate:true) and skip re-dispatching an in-flight delivery. `row` is the
- * freshly claimed row when claimed, else the existing row after the
- * latest-wins status/fields update.
- */
-export async function appendDelivery(endpoint, entry = {}, { dataDir } = {}) {
-  const deliveryId = entry.deliveryId ?? entry.id;
-  if (!endpoint || !deliveryId) throw new Error('appendDelivery: endpoint and deliveryId are required');
-  const claim = await claimDelivery(endpoint, deliveryId, entry, { dataDir });
-  if (claim.claimed) return claim;
-  const row = await updateDeliveryStatus(endpoint, deliveryId, entry.status ?? claim.row?.status, entry, { dataDir });
-  return { claimed: false, duplicate: true, row };
-}

package/src/session-runtime/runtime-core.mjs

@@ -31,6 +31,7 @@ import {
 } from '../runtime/shared/markdown-frontmatter.mjs';
 import { setConfiguredShell } from '../runtime/agent/orchestrator/tools/builtin/shell-runtime.mjs';
 import { hasUserConversationMessage } from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import { markCompletionEntry } from '../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
 import {
   beginOAuthProviderLogin,
   forgetProviderAuth,
@@ -773,7 +774,9 @@ export async function createMixdogSessionRuntime({
         && shouldPersistModelVisibleToolCompletion(text, meta)) {
         try {
           const visible = modelVisibleToolCompletionMessage(text, meta);
-          if (visible) enqueued = mgr.enqueuePendingMessage(callerSessionId, visible) > 0;
+          // Terminal completion (gated by shouldPersistModelVisibleToolCompletion)
+          // → tag so drain discards it on resume rather than replaying out-of-order.
+          if (visible) enqueued = mgr.enqueuePendingMessage(callerSessionId, markCompletionEntry(visible)) > 0;
         } catch {}
       }
       // Headless/API listeners may exist but not consume the event; preserve
@@ -782,7 +785,10 @@ export async function createMixdogSessionRuntime({
         && typeof mgr.enqueuePendingMessage === 'function') {
         try {
           const visible = modelVisibleToolCompletionMessage(text, meta);
-          if (visible) enqueued = mgr.enqueuePendingMessage(callerSessionId, visible) > 0;
+          // modelVisibleToolCompletionMessage only returns non-empty for a
+          // persistable terminal completion, so this fallback is a completion
+          // too → tag it (genuine non-completion notifications yield '' above).
+          if (visible) enqueued = mgr.enqueuePendingMessage(callerSessionId, markCompletionEntry(visible)) > 0;
         } catch {}
       }
       return enqueued || handledByRuntimeListener;

package/src/standalone/agent-tool/notify.mjs

@@ -3,6 +3,7 @@
 // Behavior-preserving: bodies identical to the originals; deps injected.
 import { modelVisibleToolCompletionMessage } from '../../runtime/shared/tool-execution-contract.mjs';
 import { renderBackgroundTask, sanitizeTaskMeta, setBackgroundTaskEnqueueFallback } from '../../runtime/shared/background-tasks.mjs';
+import { markCompletionEntry } from '../../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
 import { clean } from './helpers.mjs';
 
 export function createNotify(mgr) {
@@ -11,7 +12,10 @@ export function createNotify(mgr) {
     if (!target || typeof mgr.enqueuePendingMessage !== 'function') return false;
     try {
       const visible = modelVisibleToolCompletionMessage(text, meta);
-      return Boolean(visible && mgr.enqueuePendingMessage(target, visible) > 0);
+      if (!visible) return false;
+      // Mark this as a deferred completion/task notification so a later session
+      // resume drops it rather than replaying it out-of-order (owner decision).
+      return Boolean(mgr.enqueuePendingMessage(target, markCompletionEntry(visible)) > 0);
     } catch {
       return false;
     }

package/src/standalone/channel-admin.mjs

@@ -102,42 +102,22 @@ function seedBackendChannelIds(entry = {}, backend = 'discord') {
   return next;
 }
 
-// Resolve the single-channel entry from the config: prefer the new `channel`
-// object; fall back (read-side only, no on-disk migration) to the legacy
-// channelsConfig[mainChannel ?? 'main'] entry, then the first entry with an id.
+// Resolve the single-channel entry from the config's `channel` object.
 function resolveChannelEntry(cfg = {}) {
   if (cfg.channel && typeof cfg.channel === 'object'
     && (cfg.channel.channelId || cfg.channel.discordChannelId || cfg.channel.telegramChatId)) {
     return cfg.channel;
   }
-  const legacy = cfg.channelsConfig && typeof cfg.channelsConfig === 'object' ? cfg.channelsConfig : null;
-  if (legacy) {
-    const mainName = cfg.mainChannel ?? 'main';
-    const preferred = legacy[mainName];
-    if (preferred && typeof preferred === 'object'
-      && (preferred.channelId || preferred.discordChannelId || preferred.telegramChatId)) {
-      return preferred;
-    }
-    for (const entry of Object.values(legacy)) {
-      if (entry && typeof entry === 'object'
-        && (entry.channelId || entry.discordChannelId || entry.telegramChatId)) {
-        return entry;
-      }
-    }
-  }
   return cfg.channel && typeof cfg.channel === 'object' ? cfg.channel : {};
 }
 
 function updateChannelsSection(build) {
   let next;
   updateSection('channels', (current) => {
-    // Preserve any legacy channelsConfig/mainChannel that already live on disk
-    // for read-side compat, but never re-emit them from our writers: strip them
-    // out of the returned shape so writes converge on the single `channel`.
+    // Writes converge on the single `channel` object.
     const normalized = normalizeChannelsConfig(current);
     next = build(normalized);
-    const { channelsConfig: _lc, mainChannel: _lm, ...clean } = normalizeChannelsConfig(next);
-    return clean;
+    return normalizeChannelsConfig(next);
   });
   return next;
 }
@@ -151,8 +131,7 @@ async function updateChannelsSectionAsync(build) {
   await updateSectionAsync('channels', (current) => {
     const normalized = normalizeChannelsConfig(current);
     next = build(normalized);
-    const { channelsConfig: _lc, mainChannel: _lm, ...clean } = normalizeChannelsConfig(next);
-    return clean;
+    return normalizeChannelsConfig(next);
   });
   return next;
 }
@@ -168,8 +147,8 @@ function listEntryDirs(dir) {
   }
 }
 
-// Single-channel read: resolves `cfg.channel` (legacy channelsConfig fallback)
-// into the flat shape the settings/TUI layer consumes.
+// Single-channel read: resolves `cfg.channel` into the flat shape the
+// settings/TUI layer consumes.
 export function getChannel(config = {}) {
   const cfg = normalizeChannelsConfig(config);
   const backend = cfg.backend === 'telegram' ? 'telegram' : 'discord';

package/src/tui/display-width.mjs

@@ -38,9 +38,12 @@ const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme
  * markers (agent card ←/→, history ↑/↓): WT draws them 1 cell in
  * Cascadia, and widening them ate the marker's gutter padding space
  * ("←Spawn" rendered glued / shifted vs the ● rows).
+ * Also excludes U+21BB (↻, the statusline quota-reset marker): WT/Cascadia
+ * draws it 1 cell, so widening it reserved a phantom cell that shifted the
+ * right-aligned workflow label one column left when the usage segment appeared.
  */
 export function isProblemCodePoint(cp) {
-  return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2194 && cp <= 0x21ff);
+  return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2194 && cp <= 0x21ff && cp !== 0x21bb);
 }
 
 // Fast precheck for the problem ranges above. Lets the hot path bail before

package/src/tui/dist/index.mjs

@@ -4342,7 +4342,7 @@ import { Box as Box3, Text as Text3, useInput, usePaste, useStdin } from "../../
 import stringWidth from "string-width";
 var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 function isProblemCodePoint(cp) {
-  return cp >= 9312 && cp <= 9471 || cp >= 8596 && cp <= 8703;
+  return cp >= 9312 && cp <= 9471 || cp >= 8596 && cp <= 8703 && cp !== 8635;
 }
 var PROBLEM_RE = /[\u2194-\u21ff\u2460-\u24ff]/;
 function resolveAmbiguousWidePolicy(env = process.env, platform = process.platform) {

package/src/workflows/default/WORKFLOW.md

@@ -23,14 +23,14 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity
 1. Plan — present a draft plan before ANY implementation; if not approved,
    revise and re-present (ping-pong) until an explicit go-ahead.
 2. Delegate — maximize distribution: split the work into as many independent
-   scopes as possible and hand each to its own agent, all spawned in the SAME
-   turn (parallel by default; sequential steps only inside one complex scope,
-   gated build/test-green). This applies to every role alike — worker,
-   heavy-worker, reviewer, debugger: fan them out across agents, never one at
-   a time. Only a genuinely inseparable single scope stays whole, and say so.
-   Briefs per the Lead brief contract. After spawning async agents, END THE
-   TURN.
-3. Review — pair one reviewer 1:1 per implementation scope, same turn.
+   implementation scopes as possible and hand each to its own worker or
+   heavy-worker, all spawned in the SAME turn (parallel by default; sequential
+   steps only inside one complex scope, gated build/test-green). Fan them out
+   across agents, never one at a time. Only a genuinely inseparable single
+   scope stays whole, and say so. Briefs per the Lead brief contract. After
+   spawning async agents, END THE TURN.
+3. Review — spawn one reviewer 1:1 per implementation scope, all reviewers in
+   the same turn once their scopes land.
    Cross-check agent results yourself; send fixes back to the original scope
    and loop fix -> re-verify until clean. Skip only for simple low-risk work.
    Debugger first when the user asks for debugging or a bug survives 2+ fix
@@ -39,7 +39,7 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity
    and how work proceeds, marked in-progress — never as a conclusion.
 4. Report — final report briefs the whole work vs the approved plan and the
    verified result, distinct from interim updates. Never forward raw agent
-   output. Ask about ship/deploy when relevant; deploy/build/commit only
-   after user feedback with no issues.
+   output. Ask about ship/deploy when relevant; deploy/build/commit only on an
+   explicit user request, after feedback with no issues.
 
 On major direction shifts mid-work, pause and re-consult the user.

package/vendor/ink/build/display-width.js

@@ -24,7 +24,9 @@ import stringWidth from 'string-width';
 const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 
 function isProblemCodePoint(cp) {
-    return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2194 && cp <= 0x21ff);
+    // [mixdog fork] U+21BB (↻ quota-reset marker) excluded: WT draws it 1 cell,
+    // so widening it shifted the right-aligned statusline label one col left.
+    return (cp >= 0x2460 && cp <= 0x24ff) || (cp >= 0x2194 && cp <= 0x21ff && cp !== 0x21bb);
 }
 
 // [mixdog fork] Fast precheck for the problem ranges above. Lets the hot path