dominds 0.7.0 → 0.7.2

package/dist/agent-priming.js

@@ -57,6 +57,26 @@ const BASELINE_ENV_SNAPSHOT_CMD = 'uname -a';
 const PRIMING_VCS_SESSION_SLUG = 'rtws-vcs-inventory';
 const cacheByAgentId = new Map();
 const inflightByAgentId = new Map();
+class AgentPrimingInterruptedError extends Error {
+    constructor(reason) {
+        super(`Agent Priming interrupted: ${reason}`);
+        this.name = 'AgentPrimingInterruptedError';
+        this.reason = reason;
+    }
+}
+function isAgentPrimingInterruptedError(error) {
+    return error instanceof AgentPrimingInterruptedError;
+}
+function throwIfAgentPrimingStopped(dlg, abortSignal) {
+    if (!abortSignal.aborted) {
+        return;
+    }
+    const reason = (0, dialog_run_state_1.getStopRequestedReason)(dlg.id);
+    if (reason === 'emergency_stop' || reason === 'user_stop') {
+        throw new AgentPrimingInterruptedError(reason);
+    }
+    throw new AgentPrimingInterruptedError('user_stop');
+}
 async function emitSayingEventsAndPersist(dlg, content) {
     const calls = await (0, driver_entry_1.emitSayingEvents)(dlg, content);
     const genseq = dlg.activeGenSeqOrUndefined;
@@ -156,8 +176,23 @@ function scheduleAgentPrimingForNewDialog(dlg, options) {
             }
             // mode === 'do': wait for in-flight then run again for this dialog.
             if (options.mode === 'do') {
-                return runAgentPrimingLive(dlg).then((next) => {
+                return runAgentPrimingLive(dlg)
+                    .then((next) => {
                     cacheByAgentId.set(agentId, next);
+                })
+                    .catch((err) => {
+                    if (isAgentPrimingInterruptedError(err)) {
+                        log_1.log.info('Agent Priming interrupted; will retry on next dialog', undefined, {
+                            agentId,
+                            reason: err.reason,
+                        });
+                    }
+                    else {
+                        log_1.log.warn('Agent Priming live run failed; will retry on next dialog', err, {
+                            agentId,
+                        });
+                    }
+                    return undefined;
                 });
             }
             return Promise.resolve();
@@ -170,7 +205,15 @@ function scheduleAgentPrimingForNewDialog(dlg, options) {
     })
         .catch((err) => {
         // Best-effort: avoid unhandled rejections; the dialog itself is already marked interrupted.
-        log_1.log.warn('Agent Priming live run failed; will retry on next dialog', err, { agentId });
+        if (isAgentPrimingInterruptedError(err)) {
+            log_1.log.info('Agent Priming interrupted; will retry on next dialog', undefined, {
+                agentId,
+                reason: err.reason,
+            });
+        }
+        else {
+            log_1.log.warn('Agent Priming live run failed; will retry on next dialog', err, { agentId });
+        }
         return null;
     })
         .finally(() => {
@@ -834,7 +877,7 @@ function formatFbrTellaskBody(language, snapshotText, options) {
     ].join('\n');
 }
 async function generatePrimingNoteViaMainlineAgent(options) {
-    const { dlg, shellSnapshotText, shellResponseText, vcsRound1Text, vcsRound2Text, fbrResponses, fbrTellaskHead, fbrCallId, } = options;
+    const { dlg, shellSnapshotText, shellResponseText, vcsRound1Text, vcsRound2Text, fbrResponses, fbrTellaskHead, fbrCallId, assertNotStopped, } = options;
     // Trigger a normal drive and rely on driver.ts context assembly.
     // Agent Priming must not trigger Diligence Push (“鞭策”); it should be best-effort
     // one-shot distillation with no keep-going injection.
@@ -949,6 +992,7 @@ async function generatePrimingNoteViaMainlineAgent(options) {
             ].join('\n');
         // IMPORTANT: this is an internal (non-persisted) prompt. driver.ts will inject it into
         // the LLM context for this drive only, without polluting dialog history.
+        assertNotStopped?.();
         await (0, driver_entry_1.driveDialogStream)(dlg, {
             content: internalPrompt,
             msgId: (0, id_1.generateShortId)(),
@@ -956,6 +1000,7 @@ async function generatePrimingNoteViaMainlineAgent(options) {
             persistMode: 'internal',
             skipTaskdoc: true,
         }, true);
+        assertNotStopped?.();
         const afterMsgs = dlg.msgs.length;
         if (afterMsgs <= beforeMsgs) {
             throw new Error('Agent Priming distillation produced no new messages.');
@@ -1077,15 +1122,24 @@ function buildCoursePrefixMsgs(entry) {
     return out;
 }
 async function replayAgentPriming(dlg, entry) {
+    const hadActiveRunBefore = (0, dialog_run_state_1.hasActiveRun)(dlg.id);
+    const primingAbortSignal = (0, dialog_run_state_1.createActiveRun)(dlg.id);
+    const ownsActiveRun = !hadActiveRunBefore;
+    const assertNotStopped = () => {
+        throwIfAgentPrimingStopped(dlg, primingAbortSignal);
+    };
     const release = await dlg.acquire();
+    let interruptedRunState = null;
     try {
         const language = (0, runtime_language_1.getWorkLanguage)();
         dlg.setCoursePrefixMsgs(buildCoursePrefixMsgs(entry));
         await (0, dialog_run_state_1.setDialogRunState)(dlg.id, { kind: 'proceeding' });
+        assertNotStopped();
         // Phase 1: shell ask (and optional prelude intro)
         let shellCallId = null;
         let shellTellaskHead = null;
         try {
+            assertNotStopped();
             await dlg.notifyGeneratingStart();
             await emitUiOnlyMarkdownEventsAndPersist(dlg, formatPreludeIntro(language, true, entry.shellPolicy, entry.shell.kind === 'specialist_tellask' ? entry.shell.specialistId : null));
             if (entry.shell.kind === 'specialist_tellask') {
@@ -1115,6 +1169,7 @@ async function replayAgentPriming(dlg, entry) {
         }
         // Phase 2: shell response (separate bubble)
         if (entry.shell.kind === 'specialist_tellask' && shellCallId && shellTellaskHead) {
+            assertNotStopped();
             await dlg.receiveTeammateResponse(entry.shell.specialistId, shellTellaskHead, 'completed', dlg.id, {
                 response: entry.shell.responseText,
                 agentId: entry.shell.specialistId,
@@ -1129,6 +1184,7 @@ async function replayAgentPriming(dlg, entry) {
             let round2CallId = null;
             let round2TellaskHead = null;
             try {
+                assertNotStopped();
                 await dlg.notifyGeneratingStart();
                 const round1Content = [
                     `!?@${entry.vcs.specialistId} !tellaskSession ${entry.vcs.sessionSlug}`,
@@ -1151,6 +1207,7 @@ async function replayAgentPriming(dlg, entry) {
                 }
             }
             if (round1CallId && round1TellaskHead) {
+                assertNotStopped();
                 await dlg.receiveTeammateResponse(entry.vcs.specialistId, round1TellaskHead, 'completed', dlg.id, {
                     response: entry.vcs.round1.responseText,
                     agentId: entry.vcs.specialistId,
@@ -1159,6 +1216,7 @@ async function replayAgentPriming(dlg, entry) {
                 });
             }
             try {
+                assertNotStopped();
                 await dlg.notifyGeneratingStart();
                 const round2Content = [
                     `!?@${entry.vcs.specialistId} !tellaskSession ${entry.vcs.sessionSlug}`,
@@ -1181,6 +1239,7 @@ async function replayAgentPriming(dlg, entry) {
                 }
             }
             if (round2CallId && round2TellaskHead) {
+                assertNotStopped();
                 await dlg.receiveTeammateResponse(entry.vcs.specialistId, round2TellaskHead, 'completed', dlg.id, {
                     response: entry.vcs.round2.responseText,
                     agentId: entry.vcs.specialistId,
@@ -1191,6 +1250,7 @@ async function replayAgentPriming(dlg, entry) {
         }
         else {
             try {
+                assertNotStopped();
                 await dlg.notifyGeneratingStart();
                 await emitSayingEventsAndPersist(dlg, entry.vcs.round1NoteMarkdown);
             }
@@ -1203,6 +1263,7 @@ async function replayAgentPriming(dlg, entry) {
                 }
             }
             try {
+                assertNotStopped();
                 await dlg.notifyGeneratingStart();
                 await emitSayingEventsAndPersist(dlg, entry.vcs.round2NoteMarkdown);
             }
@@ -1221,6 +1282,7 @@ async function replayAgentPriming(dlg, entry) {
         const effort = Math.max(0, Math.floor(entry.fbr.effort));
         if (effort >= 1 && entry.fbr.responses.length > 0) {
             try {
+                assertNotStopped();
                 await dlg.notifyGeneratingStart();
                 const fbrCallBody = [entry.fbr.selfTeaser, '', entry.fbr.tellaskBody].join('\n');
                 const fbrCallContent = [
@@ -1248,6 +1310,7 @@ async function replayAgentPriming(dlg, entry) {
                 const normalized = Math.max(1, effort);
                 const responses = entry.fbr.responses.slice(0, normalized);
                 for (let i = 0; i < responses.length; i++) {
+                    assertNotStopped();
                     const raw = responses[i] ?? '';
                     await dlg.receiveTeammateResponse(entry.fbr.responderAgentId, fbrTellaskHead, 'completed', dlg.id, {
                         response: raw,
@@ -1260,6 +1323,7 @@ async function replayAgentPriming(dlg, entry) {
         }
         // Phase 5: summary bubble
         try {
+            assertNotStopped();
             await dlg.notifyGeneratingStart();
             await emitSayingEventsAndPersist(dlg, entry.primingNote);
         }
@@ -1273,25 +1337,55 @@ async function replayAgentPriming(dlg, entry) {
         }
     }
     catch (err) {
-        log_1.log.warn('Agent Priming replay failed (best-effort)', err, { dialogId: dlg.id.valueOf() });
+        if (isAgentPrimingInterruptedError(err)) {
+            interruptedRunState = {
+                kind: 'interrupted',
+                reason: { kind: err.reason },
+            };
+            log_1.log.info('Agent Priming replay interrupted by stop request', undefined, {
+                dialogId: dlg.id.valueOf(),
+                reason: err.reason,
+            });
+        }
+        else {
+            log_1.log.warn('Agent Priming replay failed (best-effort)', err, { dialogId: dlg.id.valueOf() });
+        }
     }
     finally {
-        let nextIdle = { kind: 'idle_waiting_user' };
         try {
-            nextIdle = await (0, dialog_run_state_1.computeIdleRunState)(dlg);
+            if (interruptedRunState) {
+                await (0, dialog_run_state_1.setDialogRunState)(dlg.id, interruptedRunState);
+            }
+            else {
+                let nextIdle = { kind: 'idle_waiting_user' };
+                try {
+                    nextIdle = await (0, dialog_run_state_1.computeIdleRunState)(dlg);
+                }
+                catch (err) {
+                    log_1.log.warn('Failed to compute idle runState after Agent Priming replay; falling back', err, {
+                        dialogId: dlg.id.valueOf(),
+                    });
+                }
+                await (0, dialog_run_state_1.setDialogRunState)(dlg.id, nextIdle);
+            }
         }
-        catch (err) {
-            log_1.log.warn('Failed to compute idle runState after Agent Priming replay; falling back', err, {
-                dialogId: dlg.id.valueOf(),
-            });
+        finally {
+            if (ownsActiveRun) {
+                (0, dialog_run_state_1.clearActiveRun)(dlg.id);
+            }
+            release();
         }
-        await (0, dialog_run_state_1.setDialogRunState)(dlg.id, nextIdle);
-        release();
     }
 }
 async function runAgentPrimingLive(dlg) {
     const createdAt = (0, time_1.formatUnifiedTimestamp)(new Date());
     const language = (0, runtime_language_1.getWorkLanguage)();
+    const hadActiveRunBefore = (0, dialog_run_state_1.hasActiveRun)(dlg.id);
+    const primingAbortSignal = (0, dialog_run_state_1.createActiveRun)(dlg.id);
+    const ownsActiveRun = !hadActiveRunBefore;
+    const assertNotStopped = () => {
+        throwIfAgentPrimingStopped(dlg, primingAbortSignal);
+    };
     const prevDisableDiligencePush = dlg.disableDiligencePush;
     // Agent Priming is a bounded bootstrap routine; no keep-going injection should appear
     // during the priming lifecycle (including any auto-revive drives triggered by subdialog replies).
@@ -1319,7 +1413,9 @@ async function runAgentPrimingLive(dlg) {
     const fbrResponsesForInjection = [];
     try {
         await (0, dialog_run_state_1.setDialogRunState)(dlg.id, { kind: 'proceeding' });
+        assertNotStopped();
         const team = await team_1.Team.load();
+        assertNotStopped();
         const member = team.getMember(dlg.agentId);
         const specialists = team.shellSpecialists
             .filter((s) => typeof s === 'string')
@@ -1339,6 +1435,7 @@ async function runAgentPrimingLive(dlg) {
         // Phase 1: shell ask (and optional prelude intro)
         if (shellPolicy === 'specialist_only' && specialistId !== null) {
             shellTellaskBody = formatShellTellaskBody(language, specialistId);
+            assertNotStopped();
             await dlg.withLock(async () => {
                 try {
                     await dlg.notifyGeneratingStart();
@@ -1372,6 +1469,7 @@ async function runAgentPrimingLive(dlg) {
             // In both cases we skip the shell Tellask step and let the runtime capture a baseline snapshot.
             // Keep it safe and deterministic: no network, no writes.
             const unameOutput = await runUnameA();
+            assertNotStopped();
             shellResponseText = unameOutput;
             snapshotText = unameOutput;
             const directNote = (() => {
@@ -1401,6 +1499,7 @@ async function runAgentPrimingLive(dlg) {
                     ].join('\n');
             })();
             directNoteMarkdown = directNote;
+            assertNotStopped();
             await dlg.withLock(async () => {
                 try {
                     await dlg.notifyGeneratingStart();
@@ -1435,6 +1534,7 @@ async function runAgentPrimingLive(dlg) {
                 throw new Error('Missing shell tellaskHead');
             }
             const tellaskBody = shellTellaskBodyForSubdialog ?? shellTellaskBody;
+            assertNotStopped();
             const sub = await dlg.withLock(async () => {
                 return await dlg.createSubDialog(ensuredSpecialistId, ensuredShellTellaskHead, tellaskBody, {
                     originMemberId: dlg.agentId,
@@ -1452,6 +1552,7 @@ async function runAgentPrimingLive(dlg) {
                 collectiveTargets: [ensuredSpecialistId],
             });
             await (0, driver_entry_1.driveDialogStream)(sub, { content: initPrompt, msgId: (0, id_1.generateShortId)(), grammar: 'markdown', skipTaskdoc: true }, true);
+            assertNotStopped();
             shellResponseText = extractLastAssistantSaying(sub.msgs);
             const toolResult = extractLastShellCmdResultText(sub.msgs);
             snapshotText = toolResult ? toolResult : shellResponseText;
@@ -1459,7 +1560,9 @@ async function runAgentPrimingLive(dlg) {
                 // Specialist produced no usable output (misconfigured tools, provider issues, etc.).
                 // Fall back to a runtime-executed `uname -a` so we can still proceed to FBR.
                 snapshotText = await runUnameA();
+                assertNotStopped();
             }
+            assertNotStopped();
             await dlg.withLock(async () => {
                 await dlg.receiveTeammateResponse(ensuredSpecialistId, ensuredShellTellaskHead, 'completed', sub.id, {
                     response: shellResponseText,
@@ -1503,6 +1606,7 @@ async function runAgentPrimingLive(dlg) {
                         }
                     }
                 });
+                assertNotStopped();
                 const round1Sub = await dlg.withLock(async () => {
                     return await dlg.createSubDialog(ensuredSpecialistId, round1TellaskHead, round1TellaskBodyForSubdialog || vcsRound1Body, {
                         originMemberId: dlg.agentId,
@@ -1514,6 +1618,7 @@ async function runAgentPrimingLive(dlg) {
                 });
                 const rootDialog = dlg instanceof dialog_1.RootDialog ? dlg : dlg instanceof dialog_1.SubDialog ? dlg.rootDialog : undefined;
                 if (rootDialog) {
+                    assertNotStopped();
                     rootDialog.registerSubdialog(round1Sub);
                     await rootDialog.saveSubdialogRegistry();
                 }
@@ -1531,10 +1636,12 @@ async function runAgentPrimingLive(dlg) {
                     grammar: 'markdown',
                     skipTaskdoc: true,
                 }, true);
+                assertNotStopped();
                 vcsRound1ResponseText = extractLastAssistantSaying(round1Sub.msgs).trim();
                 if (!vcsRound1ResponseText) {
                     throw new Error('Specialist VCS session round-1 returned empty output');
                 }
+                assertNotStopped();
                 await dlg.withLock(async () => {
                     await dlg.receiveTeammateResponse(ensuredSpecialistId, round1TellaskHead, 'completed', round1Sub.id, {
                         response: vcsRound1ResponseText,
@@ -1587,10 +1694,12 @@ async function runAgentPrimingLive(dlg) {
                     grammar: 'markdown',
                     skipTaskdoc: true,
                 }, true);
+                assertNotStopped();
                 vcsRound2ResponseText = extractLastAssistantSaying(round1Sub.msgs).trim();
                 if (!vcsRound2ResponseText) {
                     throw new Error('Specialist VCS session round-2 returned empty output');
                 }
+                assertNotStopped();
                 await dlg.withLock(async () => {
                     await dlg.receiveTeammateResponse(ensuredSpecialistId, round2TellaskHead, 'completed', round1Sub.id, {
                         response: vcsRound2ResponseText,
@@ -1609,6 +1718,7 @@ async function runAgentPrimingLive(dlg) {
             }
         }
         const runtimeInventory = await collectRtwsGitInventory();
+        assertNotStopped();
         const runtimeRound1Text = formatRtwsGitInventoryRound1(language, runtimeInventory);
         const runtimeRound2Text = formatRtwsGitInventoryRound2(language, runtimeInventory);
         const runtimeInventoryText = [runtimeRound1Text, '', runtimeRound2Text].join('\n');
@@ -1630,6 +1740,7 @@ async function runAgentPrimingLive(dlg) {
             vcsRound1NoteMarkdown = formatRuntimeVcsRoundNote(language, 1, vcsRound1ResponseText);
             vcsRound2NoteMarkdown = formatRuntimeVcsRoundNote(language, 2, vcsRound2ResponseText);
             vcsInventoryText = runtimeInventoryText;
+            assertNotStopped();
             await dlg.withLock(async () => {
                 try {
                     await dlg.notifyGeneratingStart();
@@ -1644,6 +1755,7 @@ async function runAgentPrimingLive(dlg) {
                     }
                 }
             });
+            assertNotStopped();
             await dlg.withLock(async () => {
                 try {
                     await dlg.notifyGeneratingStart();
@@ -1683,6 +1795,7 @@ async function runAgentPrimingLive(dlg) {
         let fbrTellaskHead = null;
         // Phase 3: FBR ask (call bubble)
         if (fbrEffort >= 1) {
+            assertNotStopped();
             await dlg.withLock(async () => {
                 try {
                     await dlg.notifyGeneratingStart();
@@ -1718,6 +1831,7 @@ async function runAgentPrimingLive(dlg) {
             const ensuredFbrTellaskHead = fbrTellaskHead;
             const perInstance = Array.from({ length: fbrEffort }, (_, idx) => idx + 1);
             const created = await Promise.all(perInstance.map(async (i) => {
+                assertNotStopped();
                 const instanceBody = fbrEffort > 1
                     ? [
                         fbrCallBody,
@@ -1727,6 +1841,7 @@ async function runAgentPrimingLive(dlg) {
                             : 'Hint: try to provide a distinct angle vs other FBR drafts (e.g. security/constraints/verifiability/risk).',
                     ].join('\n')
                     : fbrCallBody;
+                assertNotStopped();
                 const sub = await dlg.withLock(async () => {
                     return await dlg.createSubDialog(dlg.agentId, ensuredFbrTellaskHead, instanceBody, {
                         originMemberId: dlg.agentId,
@@ -1749,10 +1864,13 @@ async function runAgentPrimingLive(dlg) {
                     grammar: 'markdown',
                     skipTaskdoc: true,
                 }, true);
+                assertNotStopped();
                 const responseText = extractLastAssistantSaying(sub.msgs);
                 return { sub, responseText };
             }));
+            assertNotStopped();
             for (const r of created) {
+                assertNotStopped();
                 const responseText = r.responseText;
                 fbrResponsesForCache.push(responseText);
                 fbrResponsesForInjection.push({ subdialogId: r.sub.id.selfId, response: responseText });
@@ -1783,7 +1901,9 @@ async function runAgentPrimingLive(dlg) {
             fbrResponses: fbrResponsesForInjection,
             fbrTellaskHead: fbrTellaskHead,
             fbrCallId: fbrCallId,
+            assertNotStopped,
         });
+        assertNotStopped();
         const entry = {
             createdAt,
             workLanguage: language,
@@ -1844,6 +1964,17 @@ async function runAgentPrimingLive(dlg) {
         return entry;
     }
     catch (err) {
+        if (isAgentPrimingInterruptedError(err)) {
+            fatalRunState = {
+                kind: 'interrupted',
+                reason: { kind: err.reason },
+            };
+            log_1.log.info('Agent Priming live run interrupted by stop request', undefined, {
+                dialogId: dlg.id.valueOf(),
+                reason: err.reason,
+            });
+            throw err;
+        }
         const errText = err instanceof Error ? (err.stack ?? err.message) : String(err);
         const errTextTrimmed = errText.trim().slice(0, 4000);
         fatalRunState = {
@@ -1882,20 +2013,27 @@ async function runAgentPrimingLive(dlg) {
     }
     finally {
         dlg.disableDiligencePush = prevDisableDiligencePush;
-        if (fatalRunState) {
-            await (0, dialog_run_state_1.setDialogRunState)(dlg.id, fatalRunState);
-        }
-        else {
-            let nextIdle = { kind: 'idle_waiting_user' };
-            try {
-                nextIdle = await (0, dialog_run_state_1.computeIdleRunState)(dlg);
+        try {
+            if (fatalRunState) {
+                await (0, dialog_run_state_1.setDialogRunState)(dlg.id, fatalRunState);
             }
-            catch (err) {
-                log_1.log.warn('Failed to compute idle runState after Agent Priming live run; falling back', err, {
-                    dialogId: dlg.id.valueOf(),
-                });
+            else {
+                let nextIdle = { kind: 'idle_waiting_user' };
+                try {
+                    nextIdle = await (0, dialog_run_state_1.computeIdleRunState)(dlg);
+                }
+                catch (err) {
+                    log_1.log.warn('Failed to compute idle runState after Agent Priming live run; falling back', err, {
+                        dialogId: dlg.id.valueOf(),
+                    });
+                }
+                await (0, dialog_run_state_1.setDialogRunState)(dlg.id, nextIdle);
+            }
+        }
+        finally {
+            if (ownsActiveRun) {
+                (0, dialog_run_state_1.clearActiveRun)(dlg.id);
             }
-            await (0, dialog_run_state_1.setDialogRunState)(dlg.id, nextIdle);
         }
     }
 }

package/dist/docs/dialog-system.md

@@ -60,7 +60,8 @@ A **subdlg.yaml** file indexes pending subdialogs that a supdialog is waiting fo
 
 ### Subdialog Registry
 
-The **subdialog registry** is a root dialog-scoped Map that maintains persistent references to registered subdialogs. The registry uses `agentId!tellaskSession` as its key format and is never deleted during the dialog lifecycle. It moves with the root to `done/` when the root completes, and is rebuilt on root load by scanning done/ subdialog YAMLs.
+The **subdialog registry** is a root dialog-scoped Map that maintains persistent references to registered subdialogs. The registry uses `agentId!tellaskSession` as its key format. It moves with the root to `done/` when the root completes, and is rebuilt on root load by scanning done/ subdialog YAMLs.
+If a sideline dialog is declared dead, its Type B registry entry is removed so the same `agentId!tellaskSession` can start a brand-new sideline dialog on the next Tellask.
 
 ### Teammate Tellask
 
@@ -367,6 +368,7 @@ flowchart TD
 7. **State Preservation Contract**:
    - `clear_mind`: Clears messages, clears Q4H index, preserves reminders, preserves registry
    - Subdialog completion: Writes response to supdialog, removes from pending list (registry unchanged)
+   - Subdialog declared dead: marks runState dead and removes its Type B registry entry; same slug can be reused as a fresh sideline dialog
    - Q4H answer: Clears the answered question from index, continues the dialog
 
 ---
@@ -770,14 +772,14 @@ The **subdialog registry** is a root-dialog-scoped data structure that maintains
 
 ### Key Characteristics
 
-| Aspect          | Description                                            |
-| --------------- | ------------------------------------------------------ |
-| **Scope**       | Root dialog only (not accessible to subdialogs)        |
-| **Key Format**  | `agentId!tellaskSession` (single-level Map)            |
-| **Storage**     | `registry.yaml` in root dialog directory               |
-| **Lifecycle**   | Never deleted during dialog lifetime                   |
-| **Persistence** | Moves with root to `done/` when root completes         |
-| **Restoration** | Rebuilt on root load by scanning done/ subdialog YAMLs |
+| Aspect          | Description                                                     |
+| --------------- | --------------------------------------------------------------- |
+| **Scope**       | Root dialog only (not accessible to subdialogs)                 |
+| **Key Format**  | `agentId!tellaskSession` (single-level Map)                     |
+| **Storage**     | `registry.yaml` in root dialog directory                        |
+| **Lifecycle**   | Retained during normal runs; dead subdialog entries are removed |
+| **Persistence** | Moves with root to `done/` when root completes                  |
+| **Restoration** | Rebuilt on root load by scanning done/ subdialog YAMLs          |
 
 ### Registry Operations
 
@@ -1310,13 +1312,13 @@ The Dominds dialog system provides a robust framework for hierarchical, human-in
 
 ### Four Core Mechanisms
 
-| Mechanism              | Purpose                       | Survives Clarity | Cleared By    |
-| ---------------------- | ----------------------------- | ---------------- | ------------- |
-| **Dialog Hierarchy**   | Parent-child task delegation  | N/A              | N/A           |
-| **Q4H**                | Human input requests          | No               | clear_mind    |
-| **Mental Clarity**     | Context reset tools           | N/A              | N/A           |
-| **Reminders**          | Persistent working memory     | Yes              | N/A           |
-| **Subdialog Registry** | Registered subdialog tracking | Yes              | Never deleted |
+| Mechanism              | Purpose                       | Survives Clarity | Cleared By                                   |
+| ---------------------- | ----------------------------- | ---------------- | -------------------------------------------- |
+| **Dialog Hierarchy**   | Parent-child task delegation  | N/A              | N/A                                          |
+| **Q4H**                | Human input requests          | No               | clear_mind                                   |
+| **Mental Clarity**     | Context reset tools           | N/A              | N/A                                          |
+| **Reminders**          | Persistent working memory     | Yes              | N/A                                          |
+| **Subdialog Registry** | Registered subdialog tracking | Yes              | dead-entry prune on `declare_subdialog_dead` |
 
 ### Three Types of Teammate Tellasks
 

package/dist/docs/dialog-system.zh.md

@@ -60,7 +60,7 @@
 
 ### 子对话注册表
 
-**子对话注册表** 是根对话作用域的 Map，维护对已注册子对话的持久引用。注册表使用 `agentId!tellaskSession` 作为其键格式，在对话生命周期中永远不会被删除。当根完成时，它随根移动到 `done/`，并在根加载时通过扫描 done/ 子对话 YAML 重建。
+**子对话注册表** 是根对话作用域的 Map，维护对已注册子对话的持久引用。注册表使用 `agentId!tellaskSession` 作为其键格式。当根完成时，它随根移动到 `done/`，并在根加载时通过扫描 done/ 子对话 YAML 重建。若某个支线对话被宣布卡死，其对应的 TYPE B 注册表条目会被移除，以便后续可用同一 `agentId!tellaskSession` 创建全新的支线对话。
 
 ### 队友 Tellask
 
@@ -225,7 +225,7 @@ LLM 发出：!?@orchestrator 我应该如何处理数据库迁移？
 
 - 每次 Tellask 都会执行注册表查找
 - 支持**恢复**先前的子对话
-- 已注册的子对话在注册表中持久存在直到根完成
+- 已注册的子对话在正常流程中会保留；若支线被宣布卡死，其条目会从注册表移除
 - 注册表是根对话作用域的（子对话无法访问）
 
 **示例**：
@@ -358,6 +358,7 @@ flowchart TD
 7. **状态保留契约**：
    - `clear_mind`：清除消息，清除 Q4H 索引，保留提醒，保留注册表
    - 子对话完成：向父对话写入响应，从待处理列表中删除（注册表不变）
+   - 子对话宣布卡死：将 runState 标记为 dead，并移除对应 TYPE B 注册表条目；同一 slug 可作为全新支线重新发起
    - Q4H 回答：从索引中清除已回答的问题，继续对话
 
 ---
@@ -755,14 +756,14 @@ async function checkSubdialogRevival(supdialog: Dialog): Promise<void> {
 
 ### 关键特征
 
-| 方面         | 描述                                      |
-| ------------ | ----------------------------------------- |
-| **作用域**   | 仅限根对话（子对话无法访问）              |
-| **键格式**   | `agentId!tellaskSession`（单级 Map）      |
-| **存储**     | 根对话目录中的 `registry.yaml`            |
-| **生命周期** | 在对话生命周期中永远不会被删除            |
-| **持久化**   | 根完成时随根移动到 `done/`                |
-| **恢复**     | 在根加载时通过扫描 done/ 子对话 YAML 重建 |
+| 方面         | 描述                                       |
+| ------------ | ------------------------------------------ |
+| **作用域**   | 仅限根对话（子对话无法访问）               |
+| **键格式**   | `agentId!tellaskSession`（单级 Map）       |
+| **存储**     | 根对话目录中的 `registry.yaml`             |
+| **生命周期** | 正常流程保留；被宣布卡死的子对话条目会移除 |
+| **持久化**   | 根完成时随根移动到 `done/`                 |
+| **恢复**     | 在根加载时通过扫描 done/ 子对话 YAML 重建  |
 
 ### 注册表操作
 
@@ -917,7 +918,7 @@ interface RegistryMethods {
 
 **导航**：每个子对话都保持对其父级的引用，向上遍历到主对话。
 
-**注册表**：已注册的子对话（TYPE B Tellask）在根对话的注册表中跟踪，并在重启后持久化。
+**注册表**：已注册的子对话（TYPE B Tellask）在根对话的注册表中跟踪，并在重启后持久化；若子对话被宣布卡死，其条目会被裁剪，不再参与后续同 slug 复用。
 
 ### 生命周期管理
 
@@ -1309,13 +1310,13 @@ Dominds 对话系统为层次化、人在回路的 AI 协作提供了一个强
 
 ### 四个核心机制
 
-| 机制             | 目的             | 存活于清晰度 | 清除方式   |
-| ---------------- | ---------------- | ------------ | ---------- |
-| **对话层次结构** | 父子任务委托     | N/A          | N/A        |
-| **Q4H**          | 人机交互请求     | 否           | clear_mind |
-| **心智清晰度**   | 上下文重置工具   | N/A          | N/A        |
-| **提醒项**       | 持久化工作内存   | 是           | N/A        |
-| **子对话注册表** | 已注册子对话跟踪 | 是           | 永不删除   |
+| 机制             | 目的             | 存活于清晰度 | 清除方式                                  |
+| ---------------- | ---------------- | ------------ | ----------------------------------------- |
+| **对话层次结构** | 父子任务委托     | N/A          | N/A                                       |
+| **Q4H**          | 人机交互请求     | 否           | clear_mind                                |
+| **心智清晰度**   | 上下文重置工具   | N/A          | N/A                                       |
+| **提醒项**       | 持久化工作内存   | 是           | N/A                                       |
+| **子对话注册表** | 已注册子对话跟踪 | 是           | `declare_subdialog_dead` 时裁剪 dead 条目 |
 
 ### 三种队友 Tellask 类型
 
@@ -1334,5 +1335,5 @@ Dominds 对话系统为层次化、人在回路的 AI 协作提供了一个强
 
 - **Q4H**：持久化，由清晰度操作清除
 - **提醒项**：持久化，在清晰度操作中存活
-- **注册表**：持久化，在清晰度操作中存活，完成时移至 done/
+- **注册表**：持久化，在清晰度操作中存活，完成时移至 done/；dead 条目会在宣布卡死时被裁剪
 - **子对话**：已注册的子对话在注册表中持久化；临时子对话不会被注册