@jingyi0605/codingns4dsh 0.2.0-beta.2 → 0.2.0-rc.3

package/data/build/dist/host/cli-adapters/command-code-driver.js

@@ -1,12 +1,15 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { copyFileSync, existsSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { homedir, tmpdir } from 'node:os';
-import { basename, dirname, join } from 'node:path';
+import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, readSync, realpathSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 import readline from 'node:readline';
 import { firstToolText, serializeToolValue } from './tool-observation.js';
 import { usageChunk } from './rpc-driver-utils.js';
 import { commandEnvironment, resolveCommandPath, terminateChildProcess } from './process-utils.js';
 import { promptWithAttachmentPaths } from './attachment-utils.js';
+import { commandCodeBridgeArgs, commandCodeBridgeEnvironment } from '../cli-bridge/injections.js';
+import { getSubagentBridge } from '../cli-bridge/bridge-holder.js';
+import { CommandCodeHistory, } from './command-code-history.js';
 const WINDOWS = process.platform === 'win32';
 const COMMAND_CODE_BINARIES = WINDOWS
     ? ['command-code', 'commandcode', 'cmdc']
@@ -91,6 +94,60 @@ const CATALOG_EFFORTS = new Map([
     ['xai/grok-4.5', ['low', 'medium', 'high']],
     ['xai/grok-4.7', ['low', 'medium', 'high', 'xhigh']],
 ]);
+/**
+ * 按模型名的最后一段回退查找思考强度。
+ *
+ * BYOK 提供者的模型 id 带自定义前缀（如 `mcgrox/deepseek-v4.1-flash`），
+ * 而 CATALOG_EFFORTS 的键是 Command Code 内置目录 id（`deepseek/deepseek-v4.1-flash`），
+ * 直接查表会落空，导致菜单只剩 Default。表内 77 个键的最后一段互不重复，
+ * 因此可以安全地按末段匹配；命中多个时按歧义处理并返回空，避免误判。
+ */
+function catalogEffortsFor(id) {
+    const key = id.toLowerCase();
+    const direct = CATALOG_EFFORTS.get(key);
+    if (direct !== undefined)
+        return direct;
+    const bare = key.includes('/') ? key.slice(key.lastIndexOf('/') + 1) : key;
+    if (bare === key)
+        return [];
+    let matched;
+    for (const [candidate, efforts] of CATALOG_EFFORTS) {
+        if (!candidate.endsWith(`/${bare}`))
+            continue;
+        if (matched !== undefined)
+            return []; // 末段歧义，宁可不给强度也不猜
+        matched = efforts;
+    }
+    return matched ?? [];
+}
+/**
+ * 读取 BYOK 提供者在 `~/.commandcode/providers.json` 里声明的思考强度。
+ *
+ * 这是 BYOK 模型强度的权威来源：用户在 providers.json 的模型条目上写
+ * `reasoningEfforts: [...]`，Command Code 据此校验 `--effort`。内置目录查不到
+ * 的自定义模型只能从这里拿到强度。键为 `提供者/模型` 小写形式，空 Map 表示无声明。
+ */
+function readDeclaredEfforts(homeDirectory) {
+    const declared = new Map();
+    const config = readJson(join(homeDirectory, 'providers.json'));
+    if (config === null)
+        return declared;
+    const providers = isRecord(config.provider) ? config.provider : isRecord(config.providers) ? config.providers : null;
+    if (providers === null)
+        return declared;
+    for (const [providerId, provider] of Object.entries(providers)) {
+        if (!isRecord(provider) || !isRecord(provider.models))
+            continue;
+        for (const [modelName, entry] of Object.entries(provider.models)) {
+            if (!isRecord(entry) || !Array.isArray(entry.reasoningEfforts))
+                continue;
+            const efforts = entry.reasoningEfforts.filter((value) => typeof value === 'string' && VALID_EFFORTS.has(value));
+            if (efforts.length > 0)
+                declared.set(`${providerId}/${modelName}`.toLowerCase(), efforts);
+        }
+    }
+    return declared;
+}
 /**
  * CLI 的 `--max-turns` 默认只有 100，复杂任务经常在半途被截断。
  *
@@ -101,8 +158,22 @@ const DEFAULT_AUTO_CONTINUE_ATTEMPTS = 3;
 const AUTO_CONTINUE_PROMPT = '继续';
 /** CLI 在 -p 模式撞到 --max-turns 时的退出码（MAX_TURNS_REACHED）。 */
 const COMMAND_CODE_MAX_TURNS_EXIT_CODE = 8;
+/** 发送 SIGINT 后等待 CLI 自己收尾的时间；超时再强制清理进程树。 */
+const COMMAND_CODE_INTERRUPT_GRACE_MS = 1_500;
+/** 将 DSH 权限状态映射为 Command Code 参数；未知状态保持 CLI 默认审批。 */
+function commandCodePermissionArgs(permission) {
+    if (permission?.sandboxMode === 'danger-full-access' && permission.approvalPolicy === 'never')
+        return ['--yolo'];
+    if (permission?.sandboxMode === 'workspace-write' && permission.approvalPolicy === 'never')
+        return ['--permission-mode', 'accept-edits'];
+    if (permission?.sandboxMode === 'read-only')
+        return ['--plan'];
+    return [];
+}
 /**
- * Command Code 驱动：沿用 `--session + -p + --output-format json` 的 NDJSON 事件流。
+ * Command Code 驱动：使用 `--session` 建立首轮输入，随后绑定 Provider 原生会话并用
+ * `--resume + -p + --output-format json` 续接。首轮历史只作为 CLI 的输入快照，不能替代
+ * Provider 自己维护的 canonical transcript。
  *
  * 与 Codex 驱动保持同一套消息优化：正文/推理增量携带 assistant 消息身份，工具完成后
  * 的下一条 assistant 消息之前结束当前 DSH step，因此一个 Provider 运行会被切成多个
@@ -114,7 +185,7 @@ export class CommandCodeDriver {
         id: 'command-code',
         name: 'Command Code',
         protocol: 'command',
-        capabilities: ['models', 'stream', 'resume', 'interrupt', 'tool-events', 'reasoning', 'usage'],
+        capabilities: ['models', 'stream', 'resume', 'interrupt', 'tool-events', 'reasoning', 'usage', 'history'],
     };
     /** 驱动自己维护 Provider turn 边界，Host 可以把工具边界映射为 DSH step。 */
     supportsSegmentedTurns = true;
@@ -125,6 +196,7 @@ export class CommandCodeDriver {
     maxTurns;
     autoContinueMaxAttempts;
     autoContinuePrompt;
+    history;
     cachedBinary = null;
     cachedEnvironment;
     processes = new Set();
@@ -137,6 +209,54 @@ export class CommandCodeDriver {
         this.maxTurns = normalizePositiveInteger(options.maxTurns ?? readOptionalIntegerEnv('CODINGNS_COMMAND_CODE_MAX_TURNS'), DEFAULT_MAX_TURNS);
         this.autoContinueMaxAttempts = normalizeNonNegativeInteger(options.autoContinueMaxAttempts ?? readOptionalIntegerEnv('CODINGNS_COMMAND_CODE_AUTO_CONTINUE_ATTEMPTS'), DEFAULT_AUTO_CONTINUE_ATTEMPTS);
         this.autoContinuePrompt = options.autoContinuePrompt?.trim() || AUTO_CONTINUE_PROMPT;
+        const readStatus = options.readStatus ?? ((workspacePath) => this.readCommandCodeStatus(workspacePath));
+        this.history = new CommandCodeHistory(this.homeDirectory, { readStatus });
+    }
+    /** 读取 Command Code 原生会话目录，供 Provider History 层使用。 */
+    detectSessions(workspacePath) {
+        return this.history.detectSessions(workspacePath);
+    }
+    detectSessionsDetailed(workspacePath) {
+        return this.history.detectSessionsDetailed(workspacePath);
+    }
+    startSession(workspacePath, options = {}) {
+        return this.history.startSession(workspacePath, options);
+    }
+    resumeSession(providerSessionId, rawStoreRef) {
+        return this.history.resumeSession(providerSessionId, rawStoreRef);
+    }
+    sendMessage(providerSessionId, rawStoreRef, content) {
+        return this.history.sendMessage(providerSessionId, rawStoreRef, content);
+    }
+    readSessionHistory(providerSessionId, rawStoreRef, cursor, limit, direction = 'forward') {
+        return this.history.readSessionHistory(providerSessionId, rawStoreRef, cursor, limit, direction);
+    }
+    readSessionHistoryDelta(providerSessionId, rawStoreRef, cursor, limit, direction = 'forward') {
+        return this.history.readSessionHistoryDelta(providerSessionId, rawStoreRef, cursor, limit, direction);
+    }
+    subscribeSession(providerSessionId, rawStoreRef, cursor, limit, onEvent) {
+        return this.history.subscribeSession(providerSessionId, rawStoreRef, cursor, limit, onEvent);
+    }
+    readSessionTitle(providerSessionId, rawStoreRef) {
+        return this.history.readSessionTitle(providerSessionId, rawStoreRef);
+    }
+    renameSessionTitle(providerSessionId, rawStoreRef, title) {
+        return this.history.renameSessionTitle(providerSessionId, rawStoreRef, title);
+    }
+    updateSessionArchiveState(providerSessionId, rawStoreRef, isArchived) {
+        return this.history.updateSessionArchiveState(providerSessionId, rawStoreRef, isArchived);
+    }
+    deleteSession(providerSessionId, rawStoreRef) {
+        return this.history.deleteSession(providerSessionId, rawStoreRef);
+    }
+    readContextUsage(providerSessionId, rawStoreRef) {
+        return this.history.readContextUsage(providerSessionId, rawStoreRef);
+    }
+    readSessionStats(providerSessionId, rawStoreRef) {
+        return this.history.readSessionStats(providerSessionId, rawStoreRef);
+    }
+    forkSession(providerSessionId, workspacePath, options) {
+        return this.history.forkSession(providerSessionId, workspacePath, options);
     }
     async detect() {
         for (const command of this.binaries) {
@@ -187,6 +307,7 @@ export class CommandCodeDriver {
             return emptyCatalog();
         }
         const groups = [];
+        const declared = readDeclaredEfforts(this.homeDirectory);
         let currentGroup;
         for (const rawLine of stdout.split(/\r?\n/u)) {
             const line = rawLine.trim();
@@ -202,20 +323,101 @@ export class CommandCodeDriver {
                 continue;
             const id = match[1];
             const description = match[2].trim();
-            currentGroup.models.push({ id, name: id, ...(description ? { description } : {}), efforts: CATALOG_EFFORTS.get(id.toLowerCase()) ?? [] });
+            // BYOK 模型以 providers.json 的声明为准，内置目录作为回退；
+            // 目录回退按末段匹配，使 `mcgrox/deepseek-v4.1-flash` 也能拿到内置强度。
+            const efforts = declared.get(id.toLowerCase()) ?? catalogEffortsFor(id);
+            currentGroup.models.push({ id, name: id, ...(description ? { description } : {}), efforts });
         }
         const config = readJson(join(this.homeDirectory, 'config.json'));
-        const currentModel = typeof config?.model === 'string' ? config.model : null;
+        // status --json 反映 CLI 当前真实模型；配置文件可能仍是旧值，优先使用运行时状态。
+        let statusModel = null;
+        try {
+            const status = this.runSpawnSync(detection.command, ['status', '--json'], { encoding: 'utf8', timeout: 5_000, windowsHide: true, shell: WINDOWS, ...(this.cachedEnvironment === undefined ? {} : { env: this.cachedEnvironment }) });
+            const parsed = parseJson(status.stdout ?? '');
+            statusModel = typeof parsed?.model === 'string' && parsed.model.trim() !== '' ? parsed.model.trim() : null;
+        }
+        catch { /* 状态读取失败时回退配置文件 */ }
+        const currentModel = statusModel ?? (typeof config?.model === 'string' ? config.model : null);
         const configuredEffort = currentModel !== null && isRecord(config?.reasoningEffort) ? config.reasoningEffort[currentModel] : undefined;
         const currentEffort = typeof configuredEffort === 'string' && VALID_EFFORTS.has(configuredEffort) ? configuredEffort : null;
         const result = { groups, currentModel, currentEffort };
         return result;
     }
-    async probeSession(_input) {
-        return {
-            state: 'ephemeral',
-            reason: 'Command Code 当前使用单轮临时 transcript，不存在可恢复的 Provider 原始会话',
-        };
+    /** 读取 Provider 当前 status；历史层只在模型一致时使用其中的上下文窗口。 */
+    async readCommandCodeStatus(workspacePath) {
+        const command = this.cachedBinary ?? this.binaries[0];
+        if (command === undefined)
+            return null;
+        try {
+            const result = this.runSpawnSync(command, ['status', '--json'], {
+                cwd: workspacePath,
+                encoding: 'utf8',
+                timeout: 5_000,
+                windowsHide: true,
+                shell: WINDOWS,
+                env: this.cachedEnvironment ?? commandEnvironment(command),
+            });
+            return parseJson(result.stdout ?? '');
+        }
+        catch {
+            return null;
+        }
+    }
+    async probeSession(input) {
+        throwIfCommandCodeProbeAborted(input.signal);
+        const providerSessionId = input.providerSessionId?.trim();
+        if (!providerSessionId)
+            return { state: 'unknown', reason: '缺少 Provider 会话标识' };
+        const candidates = new Set();
+        const rawStoreRef = input.rawStoreRef?.trim();
+        const safeRawStoreRef = rawStoreRef !== undefined && isSafeCommandCodeTranscriptPath(rawStoreRef, this.homeDirectory)
+            ? rawStoreRef
+            : undefined;
+        if (safeRawStoreRef !== undefined)
+            candidates.add(safeRawStoreRef);
+        const discovered = resolveCanonicalTranscriptPath(join(this.homeDirectory, 'projects', `${providerSessionId}.jsonl`), this.homeDirectory, input.cwd);
+        if (discovered !== null)
+            candidates.add(discovered);
+        const checkpoint = resolveCommandCodeCheckpointPath(this.homeDirectory, input.cwd ?? process.cwd(), providerSessionId);
+        if (checkpoint !== null)
+            candidates.add(checkpoint);
+        if (candidates.size === 0)
+            return { state: 'missing', reason: 'Command Code 原生会话文件不存在' };
+        let lastFailure;
+        for (const candidate of candidates) {
+            throwIfCommandCodeProbeAborted(input.signal);
+            if (!existsSync(candidate))
+                continue;
+            try {
+                if (!statSync(candidate).isFile()) {
+                    lastFailure = { state: 'missing', reason: 'Command Code 原生会话路径不是文件', rawStoreRef: candidate };
+                    continue;
+                }
+                // 探测只需验证首条记录；CLI 正在追加时末尾可能存在半行，不能因此拒绝
+                // 一个仍可由 --resume 找到的会话。完整历史解析由独立的读取入口负责。
+                const firstRecord = readFirstJsonRecord(candidate);
+                if (firstRecord === null) {
+                    lastFailure = { state: 'corrupt', reason: 'Command Code 原生会话首条记录不是有效 JSONL', rawStoreRef: candidate };
+                    continue;
+                }
+                if (candidate.endsWith('.checkpoints.jsonl')) {
+                    // checkpoint 只保存回退点，Command Code 的 --resume 索引仍要求同名
+                    // `.jsonl` transcript。仅有 checkpoint 的旧会话不能宣称可恢复。
+                    lastFailure = { state: 'missing', reason: 'Command Code 只有 checkpoint，没有可恢复 transcript', rawStoreRef: candidate };
+                    continue;
+                }
+                const recordedId = textValue(firstRecord.id ?? firstRecord.sessionId).trim();
+                if (recordedId !== '' && recordedId !== providerSessionId) {
+                    lastFailure = { state: 'corrupt', reason: 'Command Code 原生会话标识与绑定不一致', rawStoreRef: candidate };
+                    continue;
+                }
+                return { state: 'available', reason: 'Command Code 原生会话可用', rawStoreRef: candidate };
+            }
+            catch (error) {
+                lastFailure = { state: 'unreachable', reason: `无法读取 Command Code 原生会话：${error instanceof Error ? error.message : String(error)}`, rawStoreRef: candidate };
+            }
+        }
+        return lastFailure ?? { state: 'missing', reason: 'Command Code 原生会话文件不存在', ...(safeRawStoreRef ? { rawStoreRef: safeRawStoreRef } : {}) };
     }
     async *executeTurn(input) {
         const binary = this.cachedBinary ?? (await this.detect()).command;
@@ -224,7 +426,7 @@ export class CommandCodeDriver {
         const segmented = input.splitToolSteps === true;
         const turn = segmented ? this.acquireTurn(input, binary) : this.startTurn(input, binary);
         let suspended = false;
-        const onAbort = () => { turn.aborted = true; this.disposeTurn(turn); };
+        const onAbort = () => { this.requestGracefulStop(turn); };
         input.signal?.addEventListener('abort', onAbort, { once: true });
         if (input.signal?.aborted)
             onAbort();
@@ -267,12 +469,35 @@ export class CommandCodeDriver {
         return turn;
     }
     startTurn(input, binary) {
-        const transcriptPath = join(tmpdir(), `codingns4dsh-cc-${safeId(input.sessionId)}.jsonl`);
-        writeTranscript(transcriptPath, input);
+        const cwd = input.cwd ?? process.cwd();
+        const requestedProviderSessionId = input.providerSessionId?.trim() || undefined;
+        // 旧 synthetic ID 可能只对应 checkpoint；回退时必须以当前 DSH 会话 ID
+        // 作为文件名，保证后续 session-binding、索引和 --resume 使用同一个标识。
+        const canonicalKey = requestedProviderSessionId !== undefined
+            && !isLegacySyntheticSessionId(requestedProviderSessionId)
+            ? requestedProviderSessionId
+            : input.sessionId;
+        const canonicalPath = resolveCommandCodeTranscriptPath(this.homeDirectory, cwd, canonicalKey);
+        const hasCanonicalTranscript = existsSync(canonicalPath) && isSafeCommandCodeTranscriptPath(canonicalPath, this.homeDirectory);
+        const hasRequestedRawTranscript = input.rawStoreRef?.trim() !== undefined
+            && existsSync(input.rawStoreRef.trim())
+            && isSafeCommandCodeTranscriptPath(input.rawStoreRef.trim(), this.homeDirectory);
+        // 旧版本会把只有 checkpoint 的外部路径登记成 synthetic session ID；该 ID
+        // 无法被 Command Code 的 --resume 索引解析。没有可读 JSONL 时重新从 DSH
+        // 历史建立 canonical transcript，避免把坏绑定继续传给 Provider。
+        const canResume = requestedProviderSessionId !== undefined
+            && (hasCanonicalTranscript || hasRequestedRawTranscript || !isLegacySyntheticSessionId(requestedProviderSessionId));
+        const providerSessionId = canResume ? requestedProviderSessionId : input.sessionId;
+        const transcriptPath = canResume ? undefined : canonicalPath;
+        if (transcriptPath !== undefined)
+            writeTranscript(transcriptPath, input);
         const turn = {
             sessionId: input.sessionId,
             child: undefined,
             transcriptPath,
+            providerSessionId,
+            rawStoreRef: canResume ? input.rawStoreRef?.trim() || undefined : transcriptPath,
+            cwd,
             queue: createEventQueue(),
             currentMessageId: undefined,
             sawCompletedTool: false,
@@ -285,7 +510,15 @@ export class CommandCodeDriver {
             attempt: 0,
             maxTurnsReached: false,
             messageSequence: 0,
+            stderrTail: '',
         };
+        // 首轮固定使用 canonical transcript；CLI 事件里的 checkpoint ID 不可用于
+        // --resume，因此先登记稳定的 DSH 会话 ID，后续回合沿用同一路径恢复。
+        if (!canResume && transcriptPath !== undefined) {
+            turn.queue.push({ type: 'session-binding', providerSessionId: providerSessionId, rawStoreRef: transcriptPath });
+        }
+        // 普通回合也登记活动 turn；Registry 的 interrupt 不应只对分段回合生效。
+        this.turns.set(input.sessionId, turn);
         void this.runTurnAttempts(turn, input, binary);
         return turn;
     }
@@ -302,22 +535,28 @@ export class CommandCodeDriver {
         try {
             while (true) {
                 turn.attempt += 1;
+                turn.stderrTail = '';
                 // 自动续跑是同一个 DSH 运行里的下一段；消息序号必须跨尝试连续，
                 // 否则新进程会从 command-code-message-1 重新编号，公共投影层会把它
                 // 当成同一条消息继续追加，而不是开启新段。
-                const state = createStreamState(() => turn.aborted, turn.messageSequence);
+                const state = createStreamState(() => turn.aborted, turn.messageSequence, turn.providerSessionId ?? null, turn.sessionId);
                 const child = this.spawnAttempt(turn, input, binary);
                 const code = await this.readAttempt(turn, child, state);
                 turn.messageSequence = state.messageSequence;
+                // 首轮使用临时 `--session` 文件。Provider 会话 ID 在流中确认后，必须在
+                // 本次尝试结束时把临时 transcript 提升到 canonical 路径；否则下一轮拿着
+                // 已登记的 ID 执行 `--resume` 时，Command Code 找不到对应原生会话。
+                if (turn.transcriptPath !== undefined && turn.providerSessionId !== undefined) {
+                    syncCommandCodeTranscript(turn.transcriptPath, this.homeDirectory, input.cwd, turn.providerSessionId);
+                }
                 if (turn.disposed || turn.finished)
                     return;
                 const capped = state.maxTurnsReached || code === COMMAND_CODE_MAX_TURNS_EXIT_CODE;
                 const autoContinueUsed = turn.attempt - 1;
-                if (capped && !turn.aborted && !turn.terminal && autoContinueUsed < this.autoContinueMaxAttempts) {
+                if (capped && !turn.aborted && !turn.terminal && turn.providerSessionId !== undefined && autoContinueUsed < this.autoContinueMaxAttempts) {
                     // 续跑必须落在同一个会话上。CLI 可能把 transcript 写回会话文件、也可能
                     // 写进按 cwd 归档的 canonical 目录；两种落点都要先归位到同一个文件，
                     // 否则“继续”会开出一个没有上文的新会话，等于白跑一轮预算。
-                    syncCommandCodeTranscript(turn.transcriptPath, this.homeDirectory, input.cwd);
                     continue;
                 }
                 if (capped && !turn.aborted && !turn.terminal) {
@@ -338,29 +577,81 @@ export class CommandCodeDriver {
     /** 启动一次 CLI 尝试；首次写入 transcript，续跑沿用同一会话文件。 */
     spawnAttempt(turn, input, binary) {
         const args = this.buildTurnArgs(input, turn);
-        const child = this.runSpawn(binary, args, { cwd: input.cwd ?? process.cwd(), env: this.cachedEnvironment ?? commandEnvironment(binary), stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: WINDOWS });
+        const bridgeEnvironment = commandCodeBridgeEnvironment(input.sessionId, this.descriptor.id);
+        const child = this.runSpawn(binary, args, {
+            cwd: input.cwd ?? process.cwd(),
+            env: { ...(this.cachedEnvironment ?? commandEnvironment(binary)), ...(input.runtimeEnv ?? {}), ...bridgeEnvironment },
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            shell: WINDOWS,
+        });
         // 自动续跑会替换活动进程；已退出的旧尝试不能继续留在进程表里等待 terminate。
         if (turn.child !== undefined)
             this.processes.delete(turn.child);
         this.processes.add(child);
-        // 必须消费 stderr，错误内容不能回传给 DSH，避免泄露命令参数或文件片段。
-        child.stderr?.on('data', () => undefined);
+        // 必须消费 stderr，错误内容只保留尾部用于诊断，避免泄露整段命令输出。
+        child.stderr?.on('data', (chunk) => {
+            turn.stderrTail = `${turn.stderrTail}${chunk.toString()}`.slice(-512);
+        });
         turn.child = child;
         return child;
     }
     buildTurnArgs(input, turn) {
-        // 续跑沿用同一个 transcript 文件，只把输入换成续跑提示；不能再次写入历史，
+        // 续跑沿用同一个 Provider 会话，只把输入换成续跑提示；不能再次写入历史，
         // 否则会把 CLI 已经落盘的进度覆盖成空会话。
         const prompt = turn.attempt > 1 ? this.autoContinuePrompt : promptWithAttachmentPaths(input.prompt, input.attachments ?? []);
-        const args = ['--session', turn.transcriptPath, '-p', prompt, '--output-format', 'json', '--tools-all', '--yolo', '--max-turns', String(this.maxTurns)];
+        const args = turn.transcriptPath !== undefined && turn.attempt === 1
+            ? ['--session', turn.transcriptPath, '-p', prompt, '--output-format', 'json', '--skip-onboarding', '--max-turns', String(this.maxTurns)]
+            : turn.providerSessionId !== undefined
+                ? ['-p', prompt, '--output-format', 'json', '--skip-onboarding', '--max-turns', String(this.maxTurns), '--resume', turn.providerSessionId]
+                : ['--session', turn.transcriptPath, '-p', prompt, '--output-format', 'json', '--skip-onboarding', '--max-turns', String(this.maxTurns)];
+        // 只有 Host 明确确认“完全访问且永不询问”时才允许 --yolo。
+        // 权限状态缺省表示尚未读取，必须保持 CLI 的保守默认，不能把未知状态升级为完全访问。
+        args.push(...commandCodePermissionArgs(input.permission));
+        if (input.plan === true && !args.includes('--plan'))
+            args.push('--plan');
+        // Command Code 只允许从已有 --resume 会话分叉；首轮临时 transcript 不能带该参数。
+        if (input.forkSession === true && turn.providerSessionId !== undefined)
+            args.push('--fork-session');
+        if (input.enableAskUserQuestion === true || input.runtimeEnv?.CMD_TOOLS_ASK_USER_QUESTION_ENABLE === 'true') {
+            args.push('--tools-enable', 'ask_user_question');
+        }
+        // 子代理托管开启时加载桥接 mod：内建 agent 调用会被转投成 DSH 原生子会话。
+        args.push(...commandCodeBridgeArgs(input.sessionId));
         for (const directory of new Set((input.attachments ?? []).map((attachment) => dirname(attachment.path))))
             args.push('--add-dir', directory);
-        if (input.modelId)
-            args.push('-m', input.modelId);
-        if (input.effortId && input.effortId !== 'default' && input.effortId !== 'Default')
-            args.push('--effort', input.effortId);
+        if (input.modelId && input.modelId !== 'provider-default')
+            args.push('--model', input.modelId);
+        const effort = input.effortId?.trim().toLowerCase();
+        if (effort !== undefined && VALID_EFFORTS.has(effort))
+            args.push('--effort', effort);
         return args;
     }
+    /** 中断当前会话并清理 CLI 进程；不存在活动运行时视为幂等成功。 */
+    async interrupt(sessionId) {
+        const turn = this.turns.get(sessionId);
+        if (turn === undefined)
+            return;
+        this.requestGracefulStop(turn);
+    }
+    /** 先让 CLI 保存检查点并自行退出，超时后才清理进程树。 */
+    requestGracefulStop(turn) {
+        turn.aborted = true;
+        const child = turn.child;
+        if (child === undefined) {
+            this.disposeTurn(turn);
+            return;
+        }
+        try {
+            child.kill('SIGINT');
+        }
+        catch { /* 进程可能已经退出 */ }
+        const timer = setTimeout(() => {
+            if (!turn.disposed)
+                this.disposeTurn(turn);
+        }, COMMAND_CODE_INTERRUPT_GRACE_MS);
+        timer.unref?.();
+    }
     /** 读取一次尝试的 stdout，直到进程结束；队列在整个运行结束前保持打开。 */
     async readAttempt(turn, child, state) {
         // 测试替身可能只提供 stdout/kill，没有 ChildProcess 的事件接口。
@@ -368,6 +659,7 @@ export class CommandCodeDriver {
             ? child
             : null;
         let exitCode = null;
+        let exitSignal = null;
         let resolveClose = null;
         const closed = new Promise((resolve) => { resolveClose = resolve; });
         if (emitter !== null) {
@@ -378,8 +670,9 @@ export class CommandCodeDriver {
                 turn.failure ??= error;
                 resolveClose?.();
             });
-            emitter.on('close', (code) => {
+            emitter.on('close', (code, signal) => {
                 exitCode = code;
+                exitSignal = signal ?? null;
                 if (state.maxTurnsReached)
                     turn.maxTurnsReached = true;
                 resolveClose?.();
@@ -387,15 +680,32 @@ export class CommandCodeDriver {
         }
         try {
             const lines = readline.createInterface({ input: child.stdout });
+            let lineNumber = 0;
             try {
                 for await (const line of lines) {
                     if (!line.trim())
                         continue;
+                    lineNumber += 1;
                     const item = parseJson(line);
-                    if (item === null)
+                    if (item === null) {
+                        // CLI 升级后可能输出非对象或损坏的 NDJSON；保留行号诊断，不能静默吞掉。
+                        console.warn(`[codingns4dsh] Command Code 忽略非法 NDJSON（第 ${lineNumber} 行）`);
                         continue;
+                    }
                     const event = item.type === 'event' && isRecord(item.event) ? item.event : item;
-                    for (const chunk of commandCodeEventChunks(event, state)) {
+                    for (const rawChunk of commandCodeEventChunks(event, state)) {
+                        let chunk = rawChunk;
+                        if (rawChunk.type === 'session-binding') {
+                            // `--session <path>` 模式下 CLI 发出的 sessionId 是 checkpoint
+                            // 内部 ID，不是可供 --resume 查找的 transcript ID；保持 Host 绑定。
+                            if (turn.transcriptPath !== undefined)
+                                continue;
+                            turn.providerSessionId = rawChunk.providerSessionId;
+                            turn.rawStoreRef = resolveCommandCodeTranscriptPath(this.homeDirectory, turn.cwd, rawChunk.providerSessionId);
+                            // Provider ID 一旦确认就立即暴露 canonical 路径；文件可能稍后才落盘，
+                            // 但 Registry 必须先保存稳定绑定，冷恢复时才能直接定位原生会话。
+                            chunk = { ...rawChunk, rawStoreRef: turn.rawStoreRef };
+                        }
                         if (chunk.type === 'finish')
                             turn.terminal = true;
                         turn.queue.push(chunk);
@@ -417,6 +727,23 @@ export class CommandCodeDriver {
         else {
             await closed;
         }
+        if (!turn.terminal && !state.maxTurnsReached) {
+            if (turn.aborted || exitSignal === 'SIGINT' || exitSignal === 'SIGTERM') {
+                turn.terminal = true;
+                turn.queue.push({ type: 'finish', reason: 'cancel' });
+            }
+            else if (turn.failure !== null || (exitCode !== null && exitCode !== 0) || exitSignal !== null) {
+                const message = turn.failure?.message
+                    || (turn.stderrTail.trim() !== '' ? `Command Code 执行失败：${turn.stderrTail.trim()}` : `Command Code 进程退出（代码 ${exitCode ?? exitSignal ?? 'unknown'}）`);
+                turn.failure = null;
+                turn.terminal = true;
+                turn.queue.push({
+                    type: 'finish',
+                    reason: 'error',
+                    failure: { message, code: exitCode === null ? 'COMMAND_CODE_SPAWN_ERROR' : `COMMAND_CODE_EXIT_${exitCode}` },
+                });
+            }
+        }
         return exitCode;
     }
     async *consumeTurn(turn, input, segmented, suspend) {
@@ -479,13 +806,10 @@ export class CommandCodeDriver {
             this.processes.delete(child);
             terminateChildProcess(child);
         }
-        try {
-            rmSync(turn.transcriptPath, { force: true });
-        }
-        catch { /* 临时文件清理尽力而为 */ }
+        // 首轮 transcript 已经是 canonical 文件，必须保留给下一轮 --resume 及冷恢复。
     }
 }
-function createStreamState(aborted, messageSequence = 0) {
+function createStreamState(aborted, messageSequence = 0, sessionId = null, bridgeSessionId = '') {
     return {
         messageSequence,
         messageId: null,
@@ -494,9 +818,11 @@ function createStreamState(aborted, messageSequence = 0) {
         sawText: false,
         perRequestUsageSeen: false,
         turnUsageSeen: false,
-        sessionId: null,
+        sessionId,
+        bridgeSessionId,
         aborted,
         maxTurnsReached: false,
+        terminalEmitted: false,
     };
 }
 function createEventQueue() {
@@ -550,6 +876,16 @@ function commandCodeEventChunks(event, state) {
         chunks.push({ type: 'session-binding', providerSessionId: sessionId });
     }
     switch (type) {
+        case 'run_start':
+        case 'run-start':
+        case 'session_created':
+        case 'session-created':
+        case 'model_request_start':
+        case 'model-request-start':
+        case 'model_trace':
+        case 'model-trace':
+            // 这些事件只标记 Provider 生命周期，不应制造正文或终态。
+            break;
         case 'turn_start':
         case 'turn-start':
             beginMessage(state);
@@ -614,19 +950,36 @@ function commandCodeEventChunks(event, state) {
         }
         case 'run_end':
         case 'run-end':
-            // run_end 只是“CLI 侧整个 run 收尾了”，最终结算仍以紧随其后的 result 行为准。
-            // 这里只识别轮次上限：上限不是终态，等进程退出后决定续跑还是报错。
-            if (isMaxTurnsOutcome(event))
+            if (!state.sawText) {
+                const finalText = readFinalText(event);
+                if (finalText) {
+                    ensureMessage(state);
+                    state.sawText = true;
+                    state.emittedText = finalText;
+                    chunks.push(textDelta(finalText, state));
+                }
+            }
+            if (isMaxTurnsOutcome(event)) {
+                // 撞到 CLI 的轮次上限不是终态，但 run_end 可能同时携带本次已生成的
+                // 最后一段正文。正文必须先投影出去，续跑只负责继续执行，不能吞掉这段结果。
                 state.maxTurnsReached = true;
+                break;
+            }
+            if (!state.terminalEmitted) {
+                state.terminalEmitted = true;
+                chunks.push({ type: 'finish', reason: state.aborted() ? 'cancel' : resultReason(event) });
+            }
             break;
         case 'result': {
+            if (state.terminalEmitted)
+                break;
             if (!state.perRequestUsageSeen) {
                 const usage = usageChunk(recordValue(event.usage));
                 if (usage !== null)
                     chunks.push(usage);
             }
             if (!state.sawText) {
-                const finalText = textValue(event.finalText ?? recordValue(event.result)?.finalText ?? (typeof event.result === 'string' ? event.result : undefined));
+                const finalText = readFinalText(event);
                 if (finalText) {
                     ensureMessage(state);
                     state.sawText = true;
@@ -640,10 +993,28 @@ function commandCodeEventChunks(event, state) {
                 state.maxTurnsReached = true;
                 break;
             }
-            chunks.push({ type: 'finish', reason: state.aborted() ? 'cancel' : resultReason(event) });
+            const reason = state.aborted() ? 'cancel' : resultReason(event);
+            state.terminalEmitted = true;
+            chunks.push({
+                type: 'finish',
+                reason,
+                ...(reason === 'error' ? { failure: commandCodeFailure(event) } : {}),
+            });
             break;
         }
+        case 'error':
+        case 'fatal_error':
+        case 'run_error':
+            if (!state.terminalEmitted) {
+                state.terminalEmitted = true;
+                chunks.push({ type: 'finish', reason: state.aborted() ? 'cancel' : 'error', ...(state.aborted() ? {} : { failure: commandCodeFailure(event) }) });
+            }
+            break;
         default:
+            if (type !== '' && !isToolStart(type) && !isToolResult(type)) {
+                // 未知事件不应改变正常流，但必须留下可定位的升级诊断。
+                console.warn(`[codingns4dsh] Command Code 忽略未知事件：${type}`);
+            }
             break;
     }
     if (isToolStart(type)) {
@@ -652,7 +1023,10 @@ function commandCodeEventChunks(event, state) {
             chunks.push(tool);
     }
     else if (isToolResult(type)) {
-        const failed = type.includes('error') || type.includes('fail') || type.includes('denied') || type.includes('blocked');
+        // 子代理托管命中时，mod 用 block 结束内建 agent 调用，真正的执行已经发生在
+        // DSH 原生子会话里；这里必须投影成完成态，而不是普通 hook 拦截的失败态。
+        const redirected = type.includes('blocked') && consumeBridgeRedirect(state, event);
+        const failed = !redirected && (type.includes('error') || type.includes('fail') || type.includes('denied') || type.includes('blocked'));
         const tool = readToolChunk(event, failed ? 'failed' : 'completed');
         if (tool !== null) {
             chunks.push(tool);
@@ -664,6 +1038,30 @@ function commandCodeEventChunks(event, state) {
     }
     return chunks;
 }
+function readFinalText(event) {
+    const result = recordValue(event.result);
+    return textValue(event.finalText
+        ?? result?.finalText
+        ?? result?.output
+        ?? result?.text
+        ?? (typeof event.result === 'string' ? event.result : undefined)
+        ?? event.output
+        ?? event.text);
+}
+/** 该 blocked 事件是否来自桥接转投；命中后消费一次记录，避免重复投影。 */
+function consumeBridgeRedirect(state, event) {
+    if (state.bridgeSessionId === '')
+        return false;
+    const callId = firstToolText(event.callId, event.call_id, event.toolCallId, event.tool_call_id, event.toolUseId, event.tool_use_id, event.id);
+    if (callId === undefined || callId === '')
+        return false;
+    try {
+        return getSubagentBridge()?.consumeRedirect(state.bridgeSessionId, callId) !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
 function beginMessage(state) {
     state.messageSequence += 1;
     state.messageId = `command-code-message-${state.messageSequence}`;
@@ -691,8 +1089,17 @@ function reasoningDelta(text, state) {
 function appendContentFallback(chunks, content, state) {
     if (!Array.isArray(content))
         return;
-    let text = '';
-    let reasoning = '';
+    let snapshotText = '';
+    let snapshotReasoning = '';
+    let pendingKind = null;
+    let pendingDelta = '';
+    const flushPending = () => {
+        if (pendingKind === null || pendingDelta === '')
+            return;
+        chunks.push(pendingKind === 'text' ? textDelta(pendingDelta, state) : reasoningDelta(pendingDelta, state));
+        pendingKind = null;
+        pendingDelta = '';
+    };
     for (const block of content) {
         const value = recordValue(block);
         if (value === null)
@@ -700,31 +1107,43 @@ function appendContentFallback(chunks, content, state) {
         const blockType = textValue(value.type).toLowerCase();
         const isReasoning = blockType.includes('thinking') || blockType.includes('reasoning')
             || typeof value.thinking === 'string' || typeof value.reasoning === 'string';
-        if (isReasoning)
-            reasoning += textValue(value.thinking ?? value.reasoning ?? value.text ?? value.content);
-        else
-            text += textValue(value.text ?? value.content);
-    }
-    if (text.length > state.emittedText.length) {
-        const delta = text.slice(state.emittedText.length);
-        ensureMessage(state);
-        state.emittedText = text;
-        state.sawText = true;
-        chunks.push(textDelta(delta, state));
-    }
-    if (reasoning.length > state.emittedReasoning.length) {
-        const delta = reasoning.slice(state.emittedReasoning.length);
-        ensureMessage(state);
-        state.emittedReasoning = reasoning;
-        chunks.push(reasoningDelta(delta, state));
+        const blockText = textValue(isReasoning
+            ? value.thinking ?? value.reasoning ?? value.text ?? value.content
+            : value.text ?? value.content);
+        if (isReasoning) {
+            snapshotReasoning += blockText;
+            if (snapshotReasoning.length > state.emittedReasoning.length) {
+                const delta = snapshotReasoning.slice(state.emittedReasoning.length);
+                ensureMessage(state);
+                state.emittedReasoning = snapshotReasoning;
+                if (pendingKind !== 'reasoning')
+                    flushPending();
+                pendingKind = 'reasoning';
+                pendingDelta += delta;
+            }
+        }
+        else {
+            snapshotText += blockText;
+            if (snapshotText.length > state.emittedText.length) {
+                const delta = snapshotText.slice(state.emittedText.length);
+                ensureMessage(state);
+                state.emittedText = snapshotText;
+                state.sawText = true;
+                if (pendingKind !== 'text')
+                    flushPending();
+                pendingKind = 'text';
+                pendingDelta += delta;
+            }
+        }
     }
+    flushPending();
 }
 function readToolChunk(event, status) {
     const callId = firstToolText(event.callId, event.call_id, event.toolCallId, event.tool_call_id, event.toolUseId, event.tool_use_id, event.id);
     const fn = recordValue(event.function);
     const toolName = textValue(event.name ?? event.toolName ?? event.tool_name ?? event.tool ?? fn?.name) || 'tool';
     const error = textValue(event.error ?? event.reason ?? event.message);
-    const output = textValue(event.output ?? event.result ?? event.content);
+    const output = textValue(event.output ?? event.result ?? event.content ?? event.hookOutput);
     const input = event.input ?? fn?.arguments ?? event.arguments;
     const agentId = firstToolText(event.agentId, event.agent_id);
     const detail = serializeToolValue(event.detail ?? event.metadata ?? event.description);
@@ -759,6 +1178,15 @@ function resultReason(event) {
         return 'cancel';
     return 'stop';
 }
+function commandCodeFailure(event) {
+    const result = recordValue(event.result);
+    const candidate = event.error ?? event.errorMessage ?? event.error_message ?? result?.error ?? result?.errorMessage ?? result?.message ?? event.message;
+    const message = textValue(candidate) ?? (typeof candidate === 'string' ? candidate.trim() : '');
+    const codeValue = result?.code ?? result?.errorCode ?? event.code ?? event.errorCode;
+    const code = typeof codeValue === 'string' && codeValue.trim() !== '' ? codeValue.trim() : undefined;
+    const actual = message.trim() || 'Command Code Provider 未返回具体失败信息。';
+    return code === undefined ? { message: actual } : { message: actual, code };
+}
 /**
  * 读取 CLI 的结束原因。
  *
@@ -783,20 +1211,36 @@ function isMaxTurnsOutcome(event) {
  *
  * 实测 CLI 的落盘位置取决于会话文件里是否已有历史：空会话（只有 session 头）时
  * 会把消息写进 `~/.commandcode/projects/<slug>/<id>.jsonl`，带上历史时则写回
- * `--session` 指定的文件。两种落点都要先归位，否则自动续跑的“继续”会落在一个
- * 没有上文的会话上。归位只做“canonical 比本地新”的单向复制，不覆盖更新的本地文件。
+ * `--session` 指定的文件。两种落点都要统一，否则下一轮恢复会落在一个没有上文的
+ * 会话上。两边都存在时按修改时间同步最新内容，首轮则创建 canonical 文件。
  */
-function syncCommandCodeTranscript(transcriptPath, homeDirectory, cwd) {
-    const canonicalPath = resolveCanonicalTranscriptPath(transcriptPath, homeDirectory, cwd);
+function syncCommandCodeTranscript(transcriptPath, homeDirectory, cwd, providerSessionId) {
+    const canonicalPath = providerSessionId === undefined
+        ? resolveCanonicalTranscriptPath(transcriptPath, homeDirectory, cwd)
+        : resolveCommandCodeTranscriptPath(homeDirectory, cwd ?? process.cwd(), providerSessionId);
     if (canonicalPath === null)
         return;
+    if (providerSessionId !== undefined && !isSafeCommandCodeTranscriptTarget(canonicalPath, homeDirectory))
+        return;
     try {
-        if (statSync(canonicalPath).mtimeMs <= statSync(transcriptPath).mtimeMs)
+        if (!existsSync(transcriptPath) || !statSync(transcriptPath).isFile())
+            return;
+        const sourceMtime = statSync(transcriptPath).mtimeMs;
+        if (!existsSync(canonicalPath)) {
+            mkdirSync(dirname(canonicalPath), { recursive: true });
+            copyFileSync(transcriptPath, canonicalPath);
+            return;
+        }
+        if (!statSync(canonicalPath).isFile())
             return;
-        copyFileSync(canonicalPath, transcriptPath);
+        const canonicalMtime = statSync(canonicalPath).mtimeMs;
+        if (sourceMtime > canonicalMtime)
+            copyFileSync(transcriptPath, canonicalPath);
+        else if (canonicalMtime > sourceMtime)
+            copyFileSync(canonicalPath, transcriptPath);
     }
     catch {
-        // transcript 归位是续跑优化；文件缺失或不可读时保持现状即可。
+        // transcript 归位是恢复前的必要同步；文件竞态或不可读时保持当前运行结果。
     }
 }
 /** 按 CLI 的 `<cwd slug>/<session id>` 规则定位 canonical transcript。 */
@@ -826,6 +1270,86 @@ function resolveCanonicalTranscriptPath(transcriptPath, homeDirectory, cwd) {
     }
     return null;
 }
+/** 按 Provider 会话 ID 计算 Command Code 的 canonical transcript 路径。 */
+function resolveCommandCodeTranscriptPath(homeDirectory, cwd, providerSessionId) {
+    return join(homeDirectory, 'projects', workspaceSlug(cwd), `${safeId(providerSessionId)}.jsonl`);
+}
+/** Provider 索引只能指向 Command Code 项目目录中的 JSONL，避免旧配置污染探测边界。 */
+function isSafeCommandCodeTranscriptPath(candidate, homeDirectory) {
+    const projectsRootPath = resolve(join(homeDirectory, 'projects'));
+    let projectsRoot = projectsRootPath;
+    try {
+        if (existsSync(projectsRootPath))
+            projectsRoot = realpathSync(projectsRootPath);
+    }
+    catch {
+        return false;
+    }
+    const resolvedCandidate = resolve(candidate);
+    let actualCandidate = resolvedCandidate;
+    try {
+        if (existsSync(resolvedCandidate))
+            actualCandidate = realpathSync(resolvedCandidate);
+    }
+    catch {
+        return false;
+    }
+    const relativePath = relative(projectsRoot, actualCandidate);
+    const segments = relativePath.split(/[\\/]+/u).filter(Boolean);
+    return relativePath !== ''
+        && !relativePath.startsWith('..')
+        && segments.length === 2
+        && actualCandidate.endsWith('.jsonl')
+        // checkpoint 不是 --resume 使用的 transcript，即使扩展名同为 .jsonl
+        // 也不能把它当作可恢复会话绑定。
+        && !actualCandidate.endsWith('.checkpoints.jsonl');
+}
+/** 允许同步创建的 canonical transcript 目标，路径必须严格位于 projects/<slug>/*.jsonl。 */
+function isSafeCommandCodeTranscriptTarget(candidate, homeDirectory) {
+    const projectsRoot = resolve(join(homeDirectory, 'projects'));
+    const resolvedCandidate = resolve(candidate);
+    const relativePath = relative(projectsRoot, resolvedCandidate);
+    const segments = relativePath.split(/[\\/]+/u).filter(Boolean);
+    return relativePath !== ''
+        && !relativePath.startsWith('..')
+        && segments.length === 2
+        && resolvedCandidate.endsWith('.jsonl')
+        && !resolvedCandidate.endsWith('.checkpoints.jsonl');
+}
+/** 只读 JSONL 首条记录，避免探测大 transcript 时把整份文件载入内存。 */
+function readFirstJsonRecord(path) {
+    const descriptor = openSync(path, 'r');
+    try {
+        const buffer = Buffer.allocUnsafe(64 * 1024);
+        const bytes = readSync(descriptor, buffer, 0, buffer.length, 0);
+        const firstLine = buffer.subarray(0, bytes).toString('utf8').split(/\r?\n/u).find((line) => line.trim() !== '');
+        return firstLine === undefined ? null : parseJson(firstLine);
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+/**
+ * Command Code 的 `--session <临时路径>` 在部分版本只落检查点文件，不创建主 transcript。
+ * 检查点足以证明会话仍可被 `--resume` 找到，但不包含完整消息历史，因此只用于探测回退。
+ */
+function resolveCommandCodeCheckpointPath(homeDirectory, cwd, providerSessionId) {
+    const expected = join(homeDirectory, 'projects', workspaceSlug(cwd), `${providerSessionId}.checkpoints.jsonl`);
+    if (existsSync(expected))
+        return expected;
+    const projectsRoot = join(homeDirectory, 'projects');
+    try {
+        for (const entry of readdirSync(projectsRoot)) {
+            const candidate = join(projectsRoot, entry, `${providerSessionId}.checkpoints.jsonl`);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    catch {
+        // projects 目录不存在说明 CLI 还没写过检查点。
+    }
+    return null;
+}
 /** CLI 的 canonical 目录名：绝对路径去掉前导分隔符，非字母数字统一换成连字符并转小写。 */
 function workspaceSlug(workspacePath) {
     return workspacePath.replace(/[\\/]+$/, '')
@@ -864,6 +1388,14 @@ function readSessionId(event) {
     const value = textValue(event.sessionId ?? event.session_id ?? recordValue(event.session)?.id ?? recordValue(event.result)?.sessionId).trim();
     return value === '' ? null : value;
 }
+/** 会话探测由 Registry 控制超时；文件扫描期间也必须尊重取消信号。 */
+function throwIfCommandCodeProbeAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    const error = new Error('Command Code 会话探测已取消');
+    error.name = 'AbortError';
+    throw error;
+}
 function textValue(value) {
     return typeof value === 'string' ? value : value === undefined || value === null ? '' : structuredText(value);
 }
@@ -881,22 +1413,97 @@ function recordValue(value) {
     return isRecord(value) ? value : null;
 }
 function writeTranscript(path, input) {
+    mkdirSync(dirname(path), { recursive: true });
     const history = input.messages.length > 0 ? input.messages.slice(0, -1) : [];
     let parentId = null;
     const lines = [JSON.stringify({ type: 'session', version: 3, id: input.sessionId, timestamp: new Date().toISOString(), cwd: input.cwd ?? process.cwd() })];
     history.forEach((message, index) => {
-        if (message.role !== 'user' && message.role !== 'assistant')
+        if (message.role !== 'user' && message.role !== 'assistant' && message.role !== 'tool')
+            return;
+        const content = extractText(message.content, message);
+        if (content.length === 0)
             return;
         const id = message.id ?? `message-${index}`;
-        lines.push(JSON.stringify({ type: 'message', id, parentId, timestamp: new Date().toISOString(), message: { role: message.role, content: [{ type: 'text', text: extractText(message.content) }] } }));
+        const role = message.role === 'tool' ? 'user' : message.role;
+        lines.push(JSON.stringify({ type: 'message', id, parentId, timestamp: new Date().toISOString(), message: { role, content } }));
         parentId = id;
     });
     writeFileSync(path, `${lines.join('\n')}\n`, 'utf8');
 }
-function extractText(content) { if (typeof content === 'string')
-    return content; if (!Array.isArray(content))
-    return ''; return content.filter(isRecord).map((part) => typeof part.text === 'string' ? part.text : '').join('\n').trim(); }
+/** 把 DSH 消息块转换为 Command Code 原生 transcript 块，保留工具和推理语义。 */
+function extractText(content, message) {
+    if (message.role === 'tool') {
+        const toolCallId = message.toolCallId ?? message.source?.callId;
+        if (toolCallId === undefined || toolCallId.trim() === '')
+            return [];
+        return [{ type: 'tool_result', tool_use_id: toolCallId, content: extractToolResultContent(content) }];
+    }
+    if (typeof content === 'string')
+        return content === '' ? [] : [{ type: 'text', text: content }];
+    if (!Array.isArray(content))
+        return [];
+    const blocks = [];
+    for (const part of content) {
+        if (!isRecord(part))
+            continue;
+        if (part.type === 'tool-call') {
+            const id = typeof part.id === 'string' ? part.id.trim() : '';
+            const name = typeof part.name === 'string' ? part.name.trim() : '';
+            if (id === '' || name === '')
+                continue;
+            blocks.push({ type: 'tool_use', id, name, input: parseToolInput(part.arguments ?? part.input) });
+            continue;
+        }
+        if (part.type === 'tool-result') {
+            const toolUseId = firstText(part.toolCallId, part.tool_use_id, part.toolUseId);
+            if (toolUseId !== '')
+                blocks.push({ type: 'tool_result', tool_use_id: toolUseId, content: extractToolResultContent(part.content ?? part.output ?? part.result) });
+            continue;
+        }
+        if (part.type === 'thinking' || part.type === 'reasoning') {
+            const thinking = firstText(part.thinking, part.reasoning, part.text, part.content);
+            if (thinking !== '')
+                blocks.push({ type: 'thinking', thinking });
+            continue;
+        }
+        const text = typeof part.text === 'string' ? part.text : '';
+        if (text !== '')
+            blocks.push({ type: 'text', text });
+    }
+    return blocks;
+}
+function extractToolResultContent(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    if (Array.isArray(content)) {
+        const parts = content.filter(isRecord).map((part) => {
+            if (typeof part.text === 'string')
+                return { type: 'text', text: part.text };
+            return null;
+        }).filter((part) => part !== null);
+        if (parts.length > 0)
+            return parts;
+    }
+    return [{ type: 'text', text: structuredText(content) }];
+}
+function parseToolInput(value) {
+    if (typeof value !== 'string')
+        return value ?? {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function firstText(...values) {
+    return values.find((value) => typeof value === 'string' && value !== '') ?? '';
+}
 function safeId(value) { return value.replace(/[^a-zA-Z0-9._-]+/gu, '_').slice(0, 96) || 'default'; }
+/** 旧驱动生成的 Host synthetic ID；没有 canonical transcript 时必须放弃 --resume。 */
+function isLegacySyntheticSessionId(value) {
+    return value.startsWith('codingns4dsh-cc-session-') || value.startsWith('dsh-codingns-cc-session-');
+}
 function parseJson(value) { try {
     const parsed = JSON.parse(value);
     return isRecord(parsed) ? parsed : null;