dominds 0.6.2 → 0.6.4

package/dist/agent-priming.js

@@ -36,6 +36,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAgentPrimingCacheStatus = getAgentPrimingCacheStatus;
 exports.resolveInheritedSubdialogAgentPrimingMode = resolveInheritedSubdialogAgentPrimingMode;
 exports.scheduleAgentPrimingForNewDialog = scheduleAgentPrimingForNewDialog;
+/**
+ * Module: agent-priming
+ *
+ * Best-effort Agent Priming prelude generation for new dialogs.
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const dialog_1 = require("./dialog");
 const dialog_run_state_1 = require("./dialog-run-state");
 const driver_1 = require("./llm/driver");
 const log_1 = require("./log");
@@ -45,6 +54,7 @@ const inter_dialog_format_1 = require("./shared/utils/inter-dialog-format");
 const time_1 = require("./shared/utils/time");
 const team_1 = require("./team");
 const BASELINE_ENV_SNAPSHOT_CMD = 'uname -a';
+const PRIMING_VCS_SESSION_SLUG = 'rtws-vcs-inventory';
 const cacheByAgentId = new Map();
 const inflightByAgentId = new Map();
 async function emitSayingEventsAndPersist(dlg, content) {
@@ -220,9 +230,8 @@ function extractLastShellCmdResultText(messages) {
     return null;
 }
 async function runUnameA() {
-    const { spawn } = await Promise.resolve().then(() => __importStar(require('child_process')));
     return await new Promise((resolveUname) => {
-        const child = spawn('uname', ['-a'], { stdio: ['ignore', 'pipe', 'pipe'] });
+        const child = (0, node_child_process_1.spawn)('uname', ['-a'], { stdio: ['ignore', 'pipe', 'pipe'] });
         let out = '';
         let err = '';
         child.stdout.on('data', (buf) => {
@@ -246,6 +255,335 @@ async function runUnameA() {
         });
     });
 }
+async function runCommand(command, args, cwd) {
+    return await new Promise((resolveExec) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let out = '';
+        let err = '';
+        child.stdout.on('data', (buf) => {
+            out += buf.toString();
+        });
+        child.stderr.on('data', (buf) => {
+            err += buf.toString();
+        });
+        child.on('close', (code) => {
+            resolveExec({
+                ok: code === 0,
+                stdout: out.trim(),
+                stderr: err.trim(),
+                exitCode: code,
+            });
+        });
+        child.on('error', (e) => {
+            resolveExec({
+                ok: false,
+                stdout: out.trim(),
+                stderr: err.trim(),
+                exitCode: null,
+                errorText: e instanceof Error ? e.message : String(e),
+            });
+        });
+    });
+}
+async function runGit(args, cwd) {
+    return await runCommand('git', args, cwd);
+}
+async function isGitRepo(dir) {
+    const res = await runGit(['rev-parse', '--is-inside-work-tree'], dir);
+    return res.ok && res.stdout === 'true';
+}
+async function inspectRtwsRootGitPosition(rtws) {
+    // Equivalent to comparing:
+    // - `git rev-parse --show-toplevel`
+    // - `pwd`
+    // to determine whether rtws itself is repo root vs a subdirectory of a repo.
+    const showTopRes = await runGit(['rev-parse', '--show-toplevel'], rtws);
+    if (!showTopRes.ok || !showTopRes.stdout) {
+        return { kind: 'not_git' };
+    }
+    const rtwsAbs = path.resolve(rtws);
+    const topLevelAbsPath = path.resolve(showTopRes.stdout);
+    if (topLevelAbsPath === rtwsAbs) {
+        return { kind: 'repo_root', topLevelAbsPath };
+    }
+    const relFromTopLevel = path.relative(topLevelAbsPath, rtwsAbs).replace(/\\/g, '/');
+    return {
+        kind: 'repo_subdir',
+        topLevelAbsPath,
+        relFromTopLevel: relFromTopLevel || '.',
+    };
+}
+async function listSubmoduleRelPaths(rootDir) {
+    const out = new Set();
+    const res = await runGit(['submodule', 'status', '--recursive'], rootDir);
+    if (!res.ok || !res.stdout)
+        return out;
+    const lines = res.stdout.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const m = trimmed.match(/^[+\-U ]?[0-9a-fA-F]+\s+([^\s]+)/);
+        if (!m)
+            continue;
+        const rel = (m[1] ?? '').trim();
+        if (!rel)
+            continue;
+        out.add(rel.replace(/\\/g, '/'));
+    }
+    return out;
+}
+async function findGitMarkerDirs(rootDir) {
+    const skipDirs = new Set([
+        '.git',
+        'node_modules',
+        '.pnpm-store',
+        '.yarn',
+        '.next',
+        'dist',
+        'build',
+        'out',
+        'target',
+        '.cache',
+    ]);
+    const queue = [rootDir];
+    const found = new Set();
+    const maxVisited = 20000;
+    let visited = 0;
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current)
+            continue;
+        visited += 1;
+        if (visited > maxVisited)
+            break;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        const hasGitMarker = entries.some((e) => e.name === '.git' && (e.isDirectory() || e.isFile()));
+        if (hasGitMarker) {
+            found.add(current);
+            if (current !== rootDir) {
+                // Treat a nested repo as its own boundary to keep traversal bounded.
+                continue;
+            }
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (skipDirs.has(entry.name))
+                continue;
+            const next = path.join(current, entry.name);
+            queue.push(next);
+        }
+    }
+    return Array.from(found);
+}
+async function collectRtwsGitInventory() {
+    const rtws = process.cwd();
+    const rootGitPosition = await inspectRtwsRootGitPosition(rtws);
+    const rootIsRepo = rootGitPosition.kind === 'repo_root';
+    const markerDirs = await findGitMarkerDirs(rtws);
+    const submoduleSet = rootIsRepo ? await listSubmoduleRelPaths(rtws) : new Set();
+    const repoAbsSet = new Set();
+    if (rootGitPosition.kind === 'repo_root' || rootGitPosition.kind === 'repo_subdir') {
+        repoAbsSet.add(rtws);
+    }
+    for (const candidate of markerDirs) {
+        if (candidate === rtws)
+            continue;
+        if (await isGitRepo(candidate)) {
+            repoAbsSet.add(candidate);
+        }
+    }
+    const allRepoAbs = Array.from(repoAbsSet).sort();
+    const allRepoRel = allRepoAbs.map((abs) => {
+        const rel = path.relative(rtws, abs).replace(/\\/g, '/');
+        return rel === '' ? '.' : rel;
+    });
+    const submoduleRelPaths = allRepoRel.filter((rel) => submoduleSet.has(rel));
+    const nestedRepoRelPaths = allRepoRel.filter((rel) => rel !== '.' && !submoduleSet.has(rel));
+    const repoStatuses = [];
+    const maxRepos = 40;
+    for (let i = 0; i < Math.min(allRepoAbs.length, maxRepos); i++) {
+        const repoAbs = allRepoAbs[i];
+        const rel = allRepoRel[i] ?? '.';
+        const branchRes = await runGit(['branch', '--show-current'], repoAbs);
+        const headRes = await runGit(['rev-parse', '--short', 'HEAD'], repoAbs);
+        const upstreamRes = await runGit(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'], repoAbs);
+        const remoteRes = await runGit(['remote', '-v'], repoAbs);
+        const dirtyRes = await runGit(['status', '--porcelain'], repoAbs);
+        const remotes = (() => {
+            if (!remoteRes.ok || !remoteRes.stdout)
+                return [];
+            const lines = remoteRes.stdout.split('\n');
+            const items = new Set();
+            for (const line of lines) {
+                const m = line.match(/^([^\s]+)\s+([^\s]+)\s+\((fetch|push)\)$/);
+                if (!m)
+                    continue;
+                const name = m[1] ?? '';
+                const url = m[2] ?? '';
+                const kind = m[3] ?? '';
+                if (!name || !url || !kind)
+                    continue;
+                items.add(`${name}:${kind}=${url}`);
+            }
+            return Array.from(items).sort();
+        })();
+        const dirtyCount = (() => {
+            if (!dirtyRes.ok || !dirtyRes.stdout)
+                return 0;
+            return dirtyRes.stdout
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0).length;
+        })();
+        const statusErrorParts = [];
+        if (!branchRes.ok)
+            statusErrorParts.push(`branch: ${branchRes.errorText ?? branchRes.stderr}`);
+        if (!headRes.ok)
+            statusErrorParts.push(`head: ${headRes.errorText ?? headRes.stderr}`);
+        if (!remoteRes.ok)
+            statusErrorParts.push(`remote: ${remoteRes.errorText ?? remoteRes.stderr}`);
+        if (!dirtyRes.ok)
+            statusErrorParts.push(`status: ${dirtyRes.errorText ?? dirtyRes.stderr}`);
+        repoStatuses.push({
+            relPath: rel,
+            branch: branchRes.ok && branchRes.stdout ? branchRes.stdout : '(detached-or-unknown)',
+            upstream: upstreamRes.ok && upstreamRes.stdout ? upstreamRes.stdout : '(no-upstream-or-unavailable)',
+            remotes,
+            dirtyCount,
+            headShort: headRes.ok && headRes.stdout ? headRes.stdout : '(unknown)',
+            statusError: statusErrorParts.length > 0 ? statusErrorParts.join('; ') : undefined,
+        });
+    }
+    return {
+        rootIsRepo,
+        rootGitPosition,
+        submoduleRelPaths,
+        nestedRepoRelPaths,
+        repoStatuses,
+    };
+}
+function formatRtwsGitInventoryRound1(language, inventory) {
+    const relationLineZh = (() => {
+        if (inventory.rootGitPosition.kind === 'repo_root') {
+            return '- rtws 与 git 关系：rtws 本身就是 repo 根路径';
+        }
+        if (inventory.rootGitPosition.kind === 'repo_subdir') {
+            return [
+                '- rtws 与 git 关系：rtws 是某个 repo 的子目录（rtws 本身不是 repo 根）',
+                `- 上级 repo 顶层：${inventory.rootGitPosition.topLevelAbsPath}`,
+                `- rtws 相对上级 repo 路径：${inventory.rootGitPosition.relFromTopLevel}`,
+            ].join('\n');
+        }
+        return '- rtws 与 git 关系：不在任何 git worktree 内';
+    })();
+    const relationLineEn = (() => {
+        if (inventory.rootGitPosition.kind === 'repo_root') {
+            return '- rtws vs git: rtws itself is the repo root';
+        }
+        if (inventory.rootGitPosition.kind === 'repo_subdir') {
+            return [
+                '- rtws vs git: rtws is a subdirectory inside a repo (rtws itself is not the repo root)',
+                `- enclosing repo top-level: ${inventory.rootGitPosition.topLevelAbsPath}`,
+                `- rtws path relative to repo root: ${inventory.rootGitPosition.relFromTopLevel}`,
+            ].join('\n');
+        }
+        return '- rtws vs git: not inside any git worktree';
+    })();
+    if (language === 'zh') {
+        const submoduleText = inventory.submoduleRelPaths.length < 1
+            ? '无'
+            : inventory.submoduleRelPaths.map((p) => `- ${p}`).join('\n');
+        const nestedText = inventory.nestedRepoRelPaths.length < 1
+            ? '无'
+            : inventory.nestedRepoRelPaths.map((p) => `- ${p}`).join('\n');
+        return [
+            'VCS 长线诉请 Round-1（rtws 仓库拓扑）',
+            '',
+            `- 根路径是否 git repo：${inventory.rootIsRepo ? '是' : '否'}`,
+            relationLineZh,
+            `- submodule 数量：${inventory.submoduleRelPaths.length}`,
+            `- 子目录独立 repo 数量：${inventory.nestedRepoRelPaths.length}`,
+            '',
+            'submodule 列表：',
+            submoduleText,
+            '',
+            '子目录独立 repo 列表：',
+            nestedText,
+        ].join('\n');
+    }
+    const submoduleText = inventory.submoduleRelPaths.length < 1
+        ? 'none'
+        : inventory.submoduleRelPaths.map((p) => `- ${p}`).join('\n');
+    const nestedText = inventory.nestedRepoRelPaths.length < 1
+        ? 'none'
+        : inventory.nestedRepoRelPaths.map((p) => `- ${p}`).join('\n');
+    return [
+        'VCS Tellask Session Round-1 (rtws repo topology)',
+        '',
+        `- Root path is git repo: ${inventory.rootIsRepo ? 'yes' : 'no'}`,
+        relationLineEn,
+        `- Submodule count: ${inventory.submoduleRelPaths.length}`,
+        `- Nested independent repo count: ${inventory.nestedRepoRelPaths.length}`,
+        '',
+        'Submodule list:',
+        submoduleText,
+        '',
+        'Nested independent repo list:',
+        nestedText,
+    ].join('\n');
+}
+function formatRtwsGitInventoryRound2(language, inventory) {
+    const rows = inventory.repoStatuses.map((repo, idx) => {
+        const remotes = repo.remotes.length < 1 ? '(none)' : repo.remotes.join(', ');
+        if (language === 'zh') {
+            return [
+                `${idx + 1}. repo: ${repo.relPath}`,
+                `   - head: ${repo.headShort}`,
+                `   - branch: ${repo.branch}`,
+                `   - upstream: ${repo.upstream}`,
+                `   - dirty: ${repo.dirtyCount > 0 ? `yes (${repo.dirtyCount})` : 'no'}`,
+                `   - remotes: ${remotes}`,
+                repo.statusError ? `   - errors: ${repo.statusError}` : '',
+            ]
+                .filter((line) => line !== '')
+                .join('\n');
+        }
+        return [
+            `${idx + 1}. repo: ${repo.relPath}`,
+            `   - head: ${repo.headShort}`,
+            `   - branch: ${repo.branch}`,
+            `   - upstream: ${repo.upstream}`,
+            `   - dirty: ${repo.dirtyCount > 0 ? `yes (${repo.dirtyCount})` : 'no'}`,
+            `   - remotes: ${remotes}`,
+            repo.statusError ? `   - errors: ${repo.statusError}` : '',
+        ]
+            .filter((line) => line !== '')
+            .join('\n');
+    });
+    if (language === 'zh') {
+        return [
+            'VCS 长线诉请 Round-2（每个 repo 的 remote / branch 现状）',
+            '',
+            rows.length < 1 ? '未发现可报告的 repo。' : rows.join('\n\n'),
+        ].join('\n');
+    }
+    return [
+        'VCS Tellask Session Round-2 (remote / branch status per repo)',
+        '',
+        rows.length < 1 ? 'No repos available to report.' : rows.join('\n\n'),
+    ].join('\n');
+}
 function formatPreludeIntro(language, reused, shellPolicy, shellSpecialistId) {
     const shellSpecialistMention = shellSpecialistId && shellSpecialistId.trim()
         ? `@${shellSpecialistId.trim()}`
@@ -258,13 +596,12 @@ function formatPreludeIntro(language, reused, shellPolicy, shellSpecialistId) {
         : shellPolicy === 'self_is_specialist'
             ? [
                 '本次对话主理人属于 `shell_specialists`，将略去 shell 诉请环节。',
-                '由 Dominds 运行时执行一个基线命令：`uname -a`，随后进入 `!?@self` FBR。',
+                '由 Dominds 运行时获取标准环境事实（`uname -a` + rtws git 现状），随后进入 `!?@self` FBR。',
             ]
             : [
                 '本团队未配置 shell 专员。',
-                '规则：此智能体必须**不执行任何 shell 命令**（不能“自己跑一下看看”）。',
-                '后续只能通过文件读写等非 shell 工具推进；同时要结合环境快照留意系统相关注意事项。',
-                '由 Dominds 运行时仅执行一个基线命令：`uname -a`，随后进入 `!?@self` FBR。',
+                '这是标准支持模式：由 Dominds 运行时主动获取环境事实（`uname -a` + rtws git 现状）并用于后续 FBR。',
+                '规则：此智能体仍然不得自行执行任意 shell 命令。',
             ];
     const shellPolicyLinesEn = shellPolicy === 'specialist_only'
         ? [
@@ -274,13 +611,12 @@ function formatPreludeIntro(language, reused, shellPolicy, shellSpecialistId) {
         : shellPolicy === 'self_is_specialist'
             ? [
                 'The dialog owner is a member of `shell_specialists`, so we skip the shell Tellask step.',
-                'Dominds runtime runs one baseline command: `uname -a`, then we enter `!?@self` FBR.',
+                'Dominds runtime collects standard environment facts (`uname -a` + rtws git state), then we enter `!?@self` FBR.',
             ]
             : [
                 'This team has no configured shell specialist.',
-                'Rule: this agent must **not run any shell commands** (no “just try it locally”).',
-                'We can only proceed with non-shell tools like file read/write; still, we must watch out for environment-specific constraints.',
-                'Dominds runtime runs one baseline command only: `uname -a`, then we enter `!?@self` FBR.',
+                'This is a standard support mode: Dominds runtime proactively collects environment facts (`uname -a` + rtws git state) for FBR.',
+                'Rule: this agent still must not run arbitrary shell commands directly.',
             ];
     if (language === 'zh') {
         return reused
@@ -288,6 +624,7 @@ function formatPreludeIntro(language, reused, shellPolicy, shellSpecialistId) {
                 '## Prelude：智能体启动（复用缓存）',
                 '',
                 '这段序幕用于把“诉请 + 回传 + FBR + 综合提炼”变成体感（引导祂做给自己看）。',
+                '关键时序：`!?@self` 只表示发起；必须等待 FBR 支线回贴返回后，才在主线做综合决策。',
                 '本次对话复用了本进程内缓存：未重复执行命令。',
                 '',
                 ...shellPolicyLinesZh,
@@ -297,6 +634,7 @@ function formatPreludeIntro(language, reused, shellPolicy, shellSpecialistId) {
                 '## Prelude：智能体启动',
                 '',
                 '这段序幕用于把“诉请 + 回传 + FBR + 综合提炼”变成体感（引导祂做给自己看）。',
+                '关键时序：`!?@self` 只表示发起；必须等待 FBR 支线回贴返回后，才在主线做综合决策。',
                 '',
                 ...shellPolicyLinesZh,
                 '',
@@ -307,6 +645,7 @@ function formatPreludeIntro(language, reused, shellPolicy, shellSpecialistId) {
             '## Prelude: Agent Priming (Reused)',
             '',
             'This prelude makes Tellask + return + FBR + distillation feel real (guiding the agent to show it to itself).',
+            'Critical timing: `!?@self` is initiation only; mainline synthesis/decision happens only after FBR sideline feedback returns.',
             'This dialog reused the in-process cache (no commands were re-run).',
             '',
             ...shellPolicyLinesEn,
@@ -316,6 +655,7 @@ function formatPreludeIntro(language, reused, shellPolicy, shellSpecialistId) {
             '## Prelude: Agent Priming',
             '',
             'This prelude makes Tellask + return + FBR + distillation feel real (guiding the agent to show it to itself).',
+            'Critical timing: `!?@self` is initiation only; mainline synthesis/decision happens only after FBR sideline feedback returns.',
             '',
             ...shellPolicyLinesEn,
             '',
@@ -329,7 +669,7 @@ function formatShellTellaskBody(language, shellSpecialistId) {
             '',
             '背景规则：对话主理人不得执行任何 shell 命令；所有 shell 命令必须通过你执行并回传。',
             '请不要建议我“自己在本地跑一下”。',
-            '收到回传后，我将基于该环境信息做一次 `!?@self` 扪心自问（FBR），并最终形成一条可复用的“智能体启动（Agent Priming）”笔记。',
+            '收到回传后，我会基于该环境信息发起一次 `!?@self` 扪心自问（FBR），先等待该次 FBR 的全部支线回贴，再在主线做综合提炼并形成一条可复用的“智能体启动（Agent Priming）”笔记。',
             '',
             '要求：',
             '- 通过 shell 工具执行：uname -a（只执行这一条）',
@@ -344,7 +684,7 @@ function formatShellTellaskBody(language, shellSpecialistId) {
         '',
         'Rule: the dialog owner must not run any shell commands; all shell commands must be executed by you and returned.',
         'Do not suggest that I “just run it locally”.',
-        'After I receive your output, I will run `!?@self` Fresh Boots Reasoning (FBR) on this environment, then produce a reusable “Agent Priming” note.',
+        'After I receive your output, I will initiate `!?@self` Fresh Boots Reasoning (FBR) on this environment, wait for all feedback from that FBR run, then distill a reusable “Agent Priming” note in mainline.',
         '',
         'Requirements:',
         '- Use shell tools to run exactly: uname -a (and only this command)',
@@ -354,117 +694,145 @@ function formatShellTellaskBody(language, shellSpecialistId) {
         'Output format: prefer raw output only; keep any explanation minimal.',
     ].join('\n');
 }
-function formatFbrSelfTeaser(language) {
+function formatVcsSessionRound1TellaskBody(language) {
     if (language === 'zh') {
-        return '（我会在收到全部 FBR 支线反馈后进行综合提炼，并在主线对话中输出一条可复用的“智能体启动（Agent Priming）”笔记。）';
+        return [
+            `这是同一长线诉请（session: ${PRIMING_VCS_SESSION_SLUG}）的 Round-1，请你只做仓库拓扑盘点。`,
+            '',
+            '在当前 rtws 中确认：',
+            '- 根路径是否是 git repo',
+            '- 是否存在 submodule（给出路径列表）',
+            '- 是否存在子目录独立 repo（给出路径列表）',
+            '',
+            '要求：',
+            '- 只使用 git / find 命令采集事实；不要用 python/node/perl 等脚本探测',
+            '- 建议命令：`git rev-parse --is-inside-work-tree`、`git submodule status --recursive`、`find . -name .git`',
+            '- 仅做事实盘点，不做下一步建议',
+            '- 输出必须短且结构化，便于我在 Round-2 继续诉请',
+        ].join('\n');
     }
-    return '(After I receive all FBR sideline feedback, I will distill it into a reusable “Agent Priming” note.)';
+    return [
+        `This is Round-1 of the same Tellask Session (${PRIMING_VCS_SESSION_SLUG}); do topology inventory only.`,
+        '',
+        'In the current rtws, confirm:',
+        '- whether the root path is a git repo',
+        '- whether submodules exist (with path list)',
+        '- whether nested independent repos exist (with path list)',
+        '',
+        'Requirements:',
+        '- use git/find commands only; do not use python/node/perl scripts for discovery',
+        '- suggested commands: `git rev-parse --is-inside-work-tree`, `git submodule status --recursive`, `find . -name .git`',
+        '- facts only, no next-step suggestions',
+        '- keep output short and structured so I can continue in Round-2',
+    ].join('\n');
 }
-function formatFbrTellaskBody(language, snapshotCmd, snapshotText, shellPolicy, shellSpecialistId, options) {
-    const shellSpecialistMention = shellSpecialistId && shellSpecialistId.trim()
-        ? `@${shellSpecialistId.trim()}`
-        : '@<shell specialist>';
-    const shellPolicyTailZh = shellPolicy === 'specialist_only'
-        ? [
+function formatVcsSessionRound2TellaskBody(language, round1Response) {
+    const round1Anchor = takeFirstNonEmptyLine(round1Response) ?? '(empty)';
+    if (language === 'zh') {
+        return [
+            `这是同一长线诉请（session: ${PRIMING_VCS_SESSION_SLUG}）的 Round-2。Round-1 已结束，本轮是新的续推诉请。`,
+            `Round-1 摘要锚点：${round1Anchor}`,
             '',
-            `约束提醒：后续如需任何 shell 命令，必须诉请 shell 专员（${shellSpecialistMention}）执行并回传；此智能体不应自行执行。`,
-        ].join('\n')
-        : shellPolicy === 'no_specialist'
-            ? [
-                '',
-                '约束提醒：本团队无 shell 专员，因此后续**不能执行任意 shell 命令**；只能通过文件读写等非 shell 工具推进。',
-            ].join('\n')
-            : '';
-    const shellPolicyTailEn = shellPolicy === 'specialist_only'
-        ? [
+            '请继续确认 Round-1 涉及到的每一个 repo：',
+            '- remote（fetch/push）现状',
+            '- 当前 branch / upstream 现状',
+            '- 工作区是否脏（可给简要计数）',
             '',
-            `Constraint: if we need any shell command later, we must Tellask the shell specialist (${shellSpecialistMention}) to run it and return; this agent must not run it directly.`,
-        ].join('\n')
-        : shellPolicy === 'no_specialist'
-            ? [
-                '',
-                'Constraint: this team has no shell specialist, so we must **not run arbitrary shell commands**; proceed only with non-shell tools like file read/write.',
-            ].join('\n')
-            : '';
+            '要求：',
+            '- 只使用 git 命令逐 repo 采集，不要用 python/node/perl',
+            '- 建议命令：`git -C <repo> remote -v`、`git -C <repo> branch --show-current`、`git -C <repo> rev-parse --abbrev-ref --symbolic-full-name @{upstream}`、`git -C <repo> status --porcelain`',
+            '- 覆盖全部 repo；缺失时明确写 unavailable',
+            '- 输出保持结构化与简短，不扩展到修复建议',
+        ].join('\n');
+    }
+    return [
+        `This is Round-2 of the same Tellask Session (${PRIMING_VCS_SESSION_SLUG}). Round-1 is closed; this is a new continuation Tellask.`,
+        `Round-1 anchor: ${round1Anchor}`,
+        '',
+        'For every repo covered by Round-1, continue with:',
+        '- remote status (fetch/push)',
+        '- current branch / upstream status',
+        '- whether working tree is dirty (brief count is enough)',
+        '',
+        'Requirements:',
+        '- use git commands repo-by-repo; do not use python/node/perl scripts',
+        '- suggested commands: `git -C <repo> remote -v`, `git -C <repo> branch --show-current`, `git -C <repo> rev-parse --abbrev-ref --symbolic-full-name @{upstream}`, `git -C <repo> status --porcelain`',
+        '- cover all repos; mark unavailable when missing',
+        '- keep output structured and short; do not expand into fix proposals',
+    ].join('\n');
+}
+function formatRuntimeVcsRoundNote(language, round, content) {
+    if (language === 'zh') {
+        return [
+            `由 Dominds 运行时执行 VCS 盘点 Round-${round}（标准模式，非降级）：`,
+            '',
+            content,
+            '',
+        ].join('\n');
+    }
+    return [
+        `Dominds runtime VCS inventory Round-${round} (standard mode, not degraded):`,
+        '',
+        content,
+        '',
+    ].join('\n');
+}
+function formatFbrSelfTeaser(language) {
+    if (language === 'zh') {
+        return '（我会先等待该次 FBR 的全部支线反馈返回；在收齐前不做最终行动决策。收齐后再综合提炼，并在主线对话中输出一条可复用的“智能体启动（Agent Priming）”笔记。）';
+    }
+    return '(I will first wait for all feedback from this FBR run and will not finalize next-action decisions before that. After all feedback returns, I will distill it into a reusable “Agent Priming” note in mainline.)';
+}
+function formatFbrTellaskBody(language, snapshotText, options) {
     const effortLineZh = options.fbrEffort >= 1
-        ? '运行时提示：运行时会生成多份“初心自我”独立推理草稿，供上游对话综合提炼（这些草稿之间没有稳定映射关系，不要把它们当作固定身份）。请给出你这一份独立分析。'
+        ? '运行时提示：运行时会生成多份“初心自我”独立推理草稿，供上游对话综合提炼（这些草稿之间没有稳定映射关系，不要把它们当作固定身份）。上游对话会在收齐全部回贴后才综合决策；请只给出你这一份独立分析，不要替上游下最终行动决策。'
         : '运行时提示：本成员已禁用 FBR。';
     const effortLineEn = options.fbrEffort >= 1
-        ? 'Runtime note: the runtime will generate multiple independent “fresh boots” drafts for the upstream dialog to distill (no stable mapping—do not treat them as fixed identities). Please produce your own independent analysis.'
+        ? 'Runtime note: the runtime will generate multiple independent “fresh boots” drafts for the upstream dialog to distill (no stable mapping—do not treat them as fixed identities). The upstream dialog will decide only after all feedback returns; provide your own draft only and do not finalize upstream next-action decisions.'
         : 'Runtime note: FBR is disabled for this member.';
     const tellaskBackHintZh = (() => {
-        if (shellPolicy === 'specialist_only') {
-            return [
-                '提示：如果你还想知道更多系统细节（`uname -a` 之外），可在本 FBR 支线对话中用 `!?@tellasker` 回问诉请者（上游对话）——例如“请补充哪些日志/配置/报错、以及你希望我重点评估哪些风险”。',
-                `诉请者可据此选择不违反安全协议的命令，并交由 shell 专员（${shellSpecialistMention}）执行回传。`,
-                '（当前这次 FBR 请不要真的发起任何诉请；只需说明你会回问什么。）',
-            ].join('\n');
-        }
-        if (shellPolicy === 'no_specialist') {
-            return [
-                '提示：如果你还想知道更多系统细节（`uname -a` 之外），可在本 FBR 支线对话中用 `!?@tellasker` 回问诉请者（上游对话）补充信息。',
-                '注意：本团队无 shell 专员，因此仍然**不得执行任意 shell 命令**；只能请求补充文本材料（文件片段/日志/配置/运行报错等）。',
-                '（当前这次 FBR 请不要真的发起任何诉请；只需说明你会回问什么。）',
-            ].join('\n');
-        }
         return [
-            '提示：如果你还想知道更多系统细节（`uname -a` 之外），可在本 FBR 支线对话中用 `!?@tellasker` 回问诉请者（上游对话）。',
+            '提示：如果你还想知道更多系统细节，可在本 FBR 支线对话中用 `!?@tellasker` 回问诉请者（上游对话）。',
             '（当前这次 FBR 请不要真的发起任何诉请；只需说明你会回问什么。）',
         ].join('\n');
     })();
     const tellaskBackHintEn = (() => {
-        if (shellPolicy === 'specialist_only') {
-            return [
-                'Hint: if you want more system details beyond `uname -a`, ask back in this FBR sideline dialog via `!?@tellasker` (to the upstream tellasker dialog).',
-                `Then the tellasker can choose safety-compliant follow-up commands and have the shell specialist (${shellSpecialistMention}) run and return them.`,
-                '(In this FBR run, do not actually emit any tellasks; just state what you would ask back.)',
-            ].join('\n');
-        }
-        if (shellPolicy === 'no_specialist') {
-            return [
-                'Hint: if you want more system details beyond `uname -a`, ask back in this FBR sideline dialog via `!?@tellasker` (to the upstream tellasker dialog).',
-                'Note: there is no shell specialist in this team, so do **not** run arbitrary shell commands; request additional text materials only (file snippets/logs/configs/errors).',
-                '(In this FBR run, do not actually emit any tellasks; just state what you would ask back.)',
-            ].join('\n');
-        }
         return [
-            'Hint: if you want more system details beyond `uname -a`, ask back in this FBR sideline dialog via `!?@tellasker` (to the upstream tellasker dialog).',
+            'Hint: if you want more system details, ask back in this FBR sideline dialog via `!?@tellasker` (to the upstream tellasker dialog).',
             '(In this FBR run, do not actually emit any tellasks; just state what you would ask back.)',
         ].join('\n');
     })();
     if (language === 'zh') {
         return [
-            '你正在进行一次“扪心自问”（FBR）。你**没有任何工具**：不能调用工具，只能使用本文本推理。',
             effortLineZh,
             '',
             tellaskBackHintZh,
             '',
             '请基于下面环境信息回答：',
             '- 在这个环境里要注意些什么？',
-            '- 优先利用哪些命令行工具，为什么？',
+            '- 哪些关键上下文仍然缺失？',
+            '- 请明确区分：事实依据 / 不确定项 / 建议下一步（供上游收齐草稿后综合）。',
             '',
-            `环境信息（当前 Dominds 运行时真实环境快照；来自命令：\`${snapshotCmd}\`）：`,
+            '环境信息（当前 Dominds 运行时环境快照）：',
             snapshotText,
-            shellPolicyTailZh,
         ].join('\n');
     }
     return [
-        'You are doing Fresh Boots Reasoning (FBR). You have **no tools**: do not call tools; reason with text only.',
         effortLineEn,
         '',
         tellaskBackHintEn,
         '',
         'Based on the environment info below, answer:',
         '- What should we watch out for in this environment?',
-        '- Which CLI tools should we prioritize, and why?',
+        '- What critical context is still missing?',
+        '- Clearly separate: factual evidence / uncertainties / suggested next step (for upstream synthesis after all drafts return).',
         '',
-        `Environment info (a real snapshot of the current Dominds runtime; from \`${snapshotCmd}\`):`,
+        'Environment info (a snapshot of the current Dominds runtime):',
         snapshotText,
-        shellPolicyTailEn,
     ].join('\n');
 }
 async function generatePrimingNoteViaMainlineAgent(options) {
-    const { dlg, shellSnapshotText, shellResponseText, fbrResponses, fbrTellaskHead, fbrCallId } = options;
+    const { dlg, shellSnapshotText, shellResponseText, vcsRound1Text, vcsRound2Text, fbrResponses, fbrTellaskHead, fbrCallId, } = 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.
@@ -490,6 +858,18 @@ async function generatePrimingNoteViaMainlineAgent(options) {
                 ? ['Shell 反馈（完整回传）：', shellReturnTrimmed].join('\n')
                 : ['Shell feedback (full return):', shellReturnTrimmed].join('\n'));
         }
+        const vcsRound1Trimmed = typeof vcsRound1Text === 'string' ? vcsRound1Text.trim() : '';
+        if (vcsRound1Trimmed) {
+            evidenceParts.push(language === 'zh'
+                ? ['VCS Session Round-1 结果：', vcsRound1Trimmed].join('\n')
+                : ['VCS session Round-1 result:', vcsRound1Trimmed].join('\n'));
+        }
+        const vcsRound2Trimmed = typeof vcsRound2Text === 'string' ? vcsRound2Text.trim() : '';
+        if (vcsRound2Trimmed) {
+            evidenceParts.push(language === 'zh'
+                ? ['VCS Session Round-2 结果：', vcsRound2Trimmed].join('\n')
+                : ['VCS session Round-2 result:', vcsRound2Trimmed].join('\n'));
+        }
         const maxDrafts = Math.min(6, fbrResponses.length);
         for (let i = 0; i < maxDrafts; i++) {
             const r = fbrResponses[i];
@@ -531,6 +911,7 @@ async function generatePrimingNoteViaMainlineAgent(options) {
         const internalPrompt = language === 'zh'
             ? [
                 '你正在进行智能体启动（Agent Priming）的“综合提炼”步骤。',
+                '你收到本提示时，意味着该次 `!?@self` FBR 的并发回贴已经收齐；本步骤只做综合提炼，不重新发起 FBR。',
                 '请基于下方提供的环境快照（以及可选的 `!?@self` FBR 草稿），综合提炼出一条可复用的“智能体启动（Agent Priming）笔记”。',
                 '',
                 '证据材料（仅供综合提炼；不要逐条复述）：',
@@ -544,9 +925,11 @@ async function generatePrimingNoteViaMainlineAgent(options) {
                 '- 去重并消解冲突，只保留最关键的结论',
                 '- 用 6~12 条 bullet points 输出（每条尽量短）',
                 '- 只写结论要点；不要输出推理过程，也不要出现“我在考虑/我将要/让我们检查”等元话语',
+                '- 必须明确写出：收到回贴代表该轮诉请结束；继续推进必须显式发起下一轮诉请',
             ].join('\n')
             : [
                 'You are in the Agent Priming distillation step.',
+                'Receiving this prompt means feedback from this `!?@self` FBR run has already been collected; this step is synthesis/distillation only, not another FBR initiation.',
                 'Based on the environment snapshot (and optional `!?@self` FBR drafts) below, distill a reusable “Agent Priming note”.',
                 '',
                 'Evidence (for distillation only; do not repeat draft-by-draft):',
@@ -560,6 +943,7 @@ async function generatePrimingNoteViaMainlineAgent(options) {
                 '- Dedupe and reconcile conflicts; keep only the key conclusions',
                 '- Output 6–12 concise bullet points',
                 '- Conclusion bullets only; no reasoning narration or meta talk (e.g. “I think / I will / let’s inspect”)',
+                '- Explicitly include this rule: a delivered response closes the current Tellask round; continuation requires a new explicit Tellask',
             ].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.
@@ -589,20 +973,20 @@ function buildCoursePrefixMsgs(entry) {
     const header = (() => {
         if (language === 'zh') {
             if (entry.shellPolicy === 'specialist_only') {
-                return '智能体启动（Agent Priming）上下文：本进程在对话创建时已真实跑通一次“诉请（shell 专员）+ 回传 + `!?@self` FBR + 综合提炼”。以下为压缩转录，作为每一程对话的开头上下文注入。';
+                return '智能体启动（Agent Priming）上下文：本进程在对话创建时已真实跑通一次“诉请（shell 专员）+ 回传 + `!?@self` FBR + 综合提炼”，并遵循“发起 FBR → 等待回贴 → 综合决策”的时序。以下为压缩转录，作为每一程对话的开头上下文注入。';
             }
             if (entry.shellPolicy === 'no_specialist') {
-                return '智能体启动（Agent Priming）上下文：本进程在对话创建时已获取环境快照并完成一次 `!?@self` FBR + 综合提炼（无 shell 专员；不得执行任意 shell 命令）。以下为压缩转录，作为每一程对话的开头上下文注入。';
+                return '智能体启动（Agent Priming）上下文：本进程在对话创建时已获取环境快照并完成一次 `!?@self` FBR + 综合提炼（无 shell 专员；不得执行任意 shell 命令），并遵循“发起 FBR → 等待回贴 → 综合决策”的时序。以下为压缩转录，作为每一程对话的开头上下文注入。';
             }
-            return '智能体启动（Agent Priming）上下文：本进程在对话创建时已获取环境快照并完成一次 `!?@self` FBR + 综合提炼。以下为压缩转录，作为每一程对话的开头上下文注入。';
+            return '智能体启动（Agent Priming）上下文：本进程在对话创建时已获取环境快照并完成一次 `!?@self` FBR + 综合提炼，并遵循“发起 FBR → 等待回贴 → 综合决策”的时序。以下为压缩转录，作为每一程对话的开头上下文注入。';
         }
         if (entry.shellPolicy === 'specialist_only') {
-            return 'Agent Priming context: this process already ran a real Tellask (shell specialist) + return + `!?@self` FBR + distillation at dialog creation. The condensed transcript below is injected at the start of each course.';
+            return 'Agent Priming context: this process already ran a real Tellask (shell specialist) + return + `!?@self` FBR + distillation at dialog creation, following the timing contract “initiate FBR -> wait for feedback -> synthesize/decide”. The condensed transcript below is injected at the start of each course.';
         }
         if (entry.shellPolicy === 'no_specialist') {
-            return 'Agent Priming context: this process captured an environment snapshot and ran `!?@self` FBR + distillation at dialog creation (no shell specialist; do not run arbitrary shell commands). The condensed transcript below is injected at the start of each course.';
+            return 'Agent Priming context: this process captured an environment snapshot and ran `!?@self` FBR + distillation at dialog creation (no shell specialist; do not run arbitrary shell commands), following the timing contract “initiate FBR -> wait for feedback -> synthesize/decide”. The condensed transcript below is injected at the start of each course.';
         }
-        return 'Agent Priming context: this process captured an environment snapshot and ran `!?@self` FBR + distillation at dialog creation. The condensed transcript below is injected at the start of each course.';
+        return 'Agent Priming context: this process captured an environment snapshot and ran `!?@self` FBR + distillation at dialog creation, following the timing contract “initiate FBR -> wait for feedback -> synthesize/decide”. The condensed transcript below is injected at the start of each course.';
     })();
     const shellSnapshotLabel = language === 'zh'
         ? 'Shell 环境快照（当前 Dominds 运行时；来自 `uname -a`）'
@@ -612,8 +996,16 @@ function buildCoursePrefixMsgs(entry) {
         : language === 'zh'
             ? '（无）'
             : '(empty)';
+    const vcsInventoryLabel = language === 'zh' ? 'VCS 现状盘点（rtws）' : 'VCS inventory (rtws)';
+    const vcsInventory = entry.vcs.inventoryText.trim()
+        ? entry.vcs.inventoryText.trim()
+        : language === 'zh'
+            ? '（无）'
+            : '(empty)';
     const effort = Math.max(0, Math.floor(entry.fbr.effort));
-    const fbrLabel = language === 'zh' ? 'FBR 输出（摘要）' : 'FBR outputs (summary)';
+    const fbrLabel = language === 'zh'
+        ? 'FBR 输出（摘要；主线在收齐回贴后综合）'
+        : 'FBR outputs (summary; synthesized after all feedback is collected)';
     const previewCap = Math.min(entry.fbr.responses.length, Math.max(0, Math.min(6, effort)));
     const previewResponses = previewCap > 0 ? entry.fbr.responses.slice(0, previewCap) : [];
     const blocks = [];
@@ -647,6 +1039,11 @@ function buildCoursePrefixMsgs(entry) {
             role: 'user',
             content: `${shellSnapshotLabel}:\n\n${shellSnapshot}`,
         },
+        {
+            type: 'environment_msg',
+            role: 'user',
+            content: `${vcsInventoryLabel}:\n\n${vcsInventory}`,
+        },
         {
             type: 'environment_msg',
             role: 'user',
@@ -723,6 +1120,99 @@ async function replayAgentPriming(dlg, entry) {
                 originMemberId: dlg.agentId,
             });
         }
+        // Phase 2.5: VCS long-session drill (two rounds)
+        if (entry.vcs.kind === 'specialist_session') {
+            let round1CallId = null;
+            let round1TellaskHead = null;
+            let round2CallId = null;
+            let round2TellaskHead = null;
+            try {
+                await dlg.notifyGeneratingStart();
+                const round1Content = [
+                    `!?@${entry.vcs.specialistId} !tellaskSession ${entry.vcs.sessionSlug}`,
+                    ...prefixTellaskBodyLines(entry.vcs.round1.tellaskBody).split('\n'),
+                    '',
+                ].join('\n');
+                const round1Calls = await emitSayingEventsAndPersist(dlg, round1Content);
+                const round1 = round1Calls.find((c) => c.validation.kind === 'valid');
+                if (round1) {
+                    round1CallId = round1.callId;
+                    round1TellaskHead = round1.tellaskHead;
+                }
+            }
+            finally {
+                try {
+                    await dlg.notifyGeneratingFinish();
+                }
+                catch (_finishErr) {
+                    // best-effort
+                }
+            }
+            if (round1CallId && round1TellaskHead) {
+                await dlg.receiveTeammateResponse(entry.vcs.specialistId, round1TellaskHead, 'completed', dlg.id, {
+                    response: entry.vcs.round1.responseText,
+                    agentId: entry.vcs.specialistId,
+                    callId: round1CallId,
+                    originMemberId: dlg.agentId,
+                });
+            }
+            try {
+                await dlg.notifyGeneratingStart();
+                const round2Content = [
+                    `!?@${entry.vcs.specialistId} !tellaskSession ${entry.vcs.sessionSlug}`,
+                    ...prefixTellaskBodyLines(entry.vcs.round2.tellaskBody).split('\n'),
+                    '',
+                ].join('\n');
+                const round2Calls = await emitSayingEventsAndPersist(dlg, round2Content);
+                const round2 = round2Calls.find((c) => c.validation.kind === 'valid');
+                if (round2) {
+                    round2CallId = round2.callId;
+                    round2TellaskHead = round2.tellaskHead;
+                }
+            }
+            finally {
+                try {
+                    await dlg.notifyGeneratingFinish();
+                }
+                catch (_finishErr) {
+                    // best-effort
+                }
+            }
+            if (round2CallId && round2TellaskHead) {
+                await dlg.receiveTeammateResponse(entry.vcs.specialistId, round2TellaskHead, 'completed', dlg.id, {
+                    response: entry.vcs.round2.responseText,
+                    agentId: entry.vcs.specialistId,
+                    callId: round2CallId,
+                    originMemberId: dlg.agentId,
+                });
+            }
+        }
+        else {
+            try {
+                await dlg.notifyGeneratingStart();
+                await emitSayingEventsAndPersist(dlg, entry.vcs.round1NoteMarkdown);
+            }
+            finally {
+                try {
+                    await dlg.notifyGeneratingFinish();
+                }
+                catch (_finishErr) {
+                    // best-effort
+                }
+            }
+            try {
+                await dlg.notifyGeneratingStart();
+                await emitSayingEventsAndPersist(dlg, entry.vcs.round2NoteMarkdown);
+            }
+            finally {
+                try {
+                    await dlg.notifyGeneratingFinish();
+                }
+                catch (_finishErr) {
+                    // best-effort
+                }
+            }
+        }
         // Phase 3: FBR ask (call bubble)
         let fbrCallId = null;
         let fbrTellaskHead = null;
@@ -800,6 +1290,10 @@ async function replayAgentPriming(dlg, entry) {
 async function runAgentPrimingLive(dlg) {
     const createdAt = (0, time_1.formatUnifiedTimestamp)(new Date());
     const language = (0, runtime_language_1.getWorkLanguage)();
+    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).
+    dlg.disableDiligencePush = true;
     let fatalRunState = null;
     let shellPolicy = 'no_specialist';
     let specialistId = null;
@@ -807,6 +1301,15 @@ async function runAgentPrimingLive(dlg) {
     let shellResponseText = '';
     let snapshotText = '';
     let directNoteMarkdown = '';
+    let vcsRound1Body = '';
+    let vcsRound2Body = '';
+    let vcsRound1ResponseText = '';
+    let vcsRound2ResponseText = '';
+    let vcsEvidenceRound1Text = '';
+    let vcsEvidenceRound2Text = '';
+    let vcsRound1NoteMarkdown = '';
+    let vcsRound2NoteMarkdown = '';
+    let vcsInventoryText = '';
     let fbrCallBody = '';
     let selfTeaser = '';
     let fbrEffort = 0;
@@ -946,7 +1449,7 @@ async function runAgentPrimingLive(dlg) {
                 language,
                 collectiveTargets: [ensuredSpecialistId],
             });
-            await (0, driver_1.driveDialogStream)(sub, { content: initPrompt, msgId: (0, id_1.generateShortId)(), grammar: 'markdown' }, true);
+            await (0, driver_1.driveDialogStream)(sub, { content: initPrompt, msgId: (0, id_1.generateShortId)(), grammar: 'markdown', skipTaskdoc: true }, true);
             shellResponseText = extractLastAssistantSaying(sub.msgs);
             const toolResult = extractLastShellCmdResultText(sub.msgs);
             snapshotText = toolResult ? toolResult : shellResponseText;
@@ -964,6 +1467,202 @@ async function runAgentPrimingLive(dlg) {
                 });
             });
         }
+        // Phase 2.5: VCS tellask-session drill (two rounds) or runtime inventory.
+        if (shellPolicy === 'specialist_only' && specialistId !== null) {
+            const ensuredSpecialistId = specialistId;
+            try {
+                vcsRound1Body = formatVcsSessionRound1TellaskBody(language);
+                let round1CallId = '';
+                let round1TellaskHead = '';
+                let round1TellaskBodyForSubdialog = '';
+                await dlg.withLock(async () => {
+                    try {
+                        await dlg.notifyGeneratingStart();
+                        const round1CallSaying = [
+                            `!?@${ensuredSpecialistId} !tellaskSession ${PRIMING_VCS_SESSION_SLUG}`,
+                            ...prefixTellaskBodyLines(vcsRound1Body).split('\n'),
+                            '',
+                        ].join('\n');
+                        const calls = await emitSayingEventsAndPersist(dlg, round1CallSaying);
+                        const call = calls.find((c) => c.validation.kind === 'valid');
+                        if (!call) {
+                            throw new Error('Failed to emit VCS session round-1 tellask call');
+                        }
+                        round1CallId = call.callId;
+                        round1TellaskHead = call.tellaskHead;
+                        round1TellaskBodyForSubdialog = call.body;
+                    }
+                    finally {
+                        try {
+                            await dlg.notifyGeneratingFinish();
+                        }
+                        catch (_finishErr) {
+                            // best-effort
+                        }
+                    }
+                });
+                const round1Sub = await dlg.withLock(async () => {
+                    return await dlg.createSubDialog(ensuredSpecialistId, round1TellaskHead, round1TellaskBodyForSubdialog || vcsRound1Body, {
+                        originMemberId: dlg.agentId,
+                        callerDialogId: dlg.id.selfId,
+                        callId: round1CallId,
+                        tellaskSession: PRIMING_VCS_SESSION_SLUG,
+                        collectiveTargets: [ensuredSpecialistId],
+                    });
+                });
+                const rootDialog = dlg instanceof dialog_1.RootDialog ? dlg : dlg instanceof dialog_1.SubDialog ? dlg.rootDialog : undefined;
+                if (rootDialog) {
+                    rootDialog.registerSubdialog(round1Sub);
+                    await rootDialog.saveSubdialogRegistry();
+                }
+                const round1Prompt = (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                    fromAgentId: dlg.agentId,
+                    toAgentId: round1Sub.agentId,
+                    tellaskHead: round1TellaskHead,
+                    tellaskBody: round1TellaskBodyForSubdialog || vcsRound1Body,
+                    language,
+                    collectiveTargets: [ensuredSpecialistId],
+                });
+                await (0, driver_1.driveDialogStream)(round1Sub, {
+                    content: round1Prompt,
+                    msgId: (0, id_1.generateShortId)(),
+                    grammar: 'markdown',
+                    skipTaskdoc: true,
+                }, true);
+                vcsRound1ResponseText = extractLastAssistantSaying(round1Sub.msgs).trim();
+                if (!vcsRound1ResponseText) {
+                    throw new Error('Specialist VCS session round-1 returned empty output');
+                }
+                await dlg.withLock(async () => {
+                    await dlg.receiveTeammateResponse(ensuredSpecialistId, round1TellaskHead, 'completed', round1Sub.id, {
+                        response: vcsRound1ResponseText,
+                        agentId: ensuredSpecialistId,
+                        callId: round1CallId,
+                        originMemberId: dlg.agentId,
+                    });
+                });
+                vcsRound2Body = formatVcsSessionRound2TellaskBody(language, vcsRound1ResponseText);
+                let round2CallId = '';
+                let round2TellaskHead = '';
+                let round2TellaskBodyForSubdialog = '';
+                await dlg.withLock(async () => {
+                    try {
+                        await dlg.notifyGeneratingStart();
+                        const round2CallSaying = [
+                            `!?@${ensuredSpecialistId} !tellaskSession ${PRIMING_VCS_SESSION_SLUG}`,
+                            ...prefixTellaskBodyLines(vcsRound2Body).split('\n'),
+                            '',
+                        ].join('\n');
+                        const calls = await emitSayingEventsAndPersist(dlg, round2CallSaying);
+                        const call = calls.find((c) => c.validation.kind === 'valid');
+                        if (!call) {
+                            throw new Error('Failed to emit VCS session round-2 tellask call');
+                        }
+                        round2CallId = call.callId;
+                        round2TellaskHead = call.tellaskHead;
+                        round2TellaskBodyForSubdialog = call.body;
+                    }
+                    finally {
+                        try {
+                            await dlg.notifyGeneratingFinish();
+                        }
+                        catch (_finishErr) {
+                            // best-effort
+                        }
+                    }
+                });
+                const round2Prompt = (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                    fromAgentId: dlg.agentId,
+                    toAgentId: round1Sub.agentId,
+                    tellaskHead: round2TellaskHead,
+                    tellaskBody: round2TellaskBodyForSubdialog || vcsRound2Body,
+                    language,
+                    collectiveTargets: [ensuredSpecialistId],
+                });
+                await (0, driver_1.driveDialogStream)(round1Sub, {
+                    content: round2Prompt,
+                    msgId: (0, id_1.generateShortId)(),
+                    grammar: 'markdown',
+                    skipTaskdoc: true,
+                }, true);
+                vcsRound2ResponseText = extractLastAssistantSaying(round1Sub.msgs).trim();
+                if (!vcsRound2ResponseText) {
+                    throw new Error('Specialist VCS session round-2 returned empty output');
+                }
+                await dlg.withLock(async () => {
+                    await dlg.receiveTeammateResponse(ensuredSpecialistId, round2TellaskHead, 'completed', round1Sub.id, {
+                        response: vcsRound2ResponseText,
+                        agentId: ensuredSpecialistId,
+                        callId: round2CallId,
+                        originMemberId: dlg.agentId,
+                    });
+                });
+                vcsInventoryText = [vcsRound1ResponseText, '', vcsRound2ResponseText].join('\n');
+            }
+            catch (err) {
+                log_1.log.warn('VCS tellask-session drill via shell specialist failed; fallback to runtime inventory', err, {
+                    dialogId: dlg.id.valueOf(),
+                    specialistId: ensuredSpecialistId,
+                });
+            }
+        }
+        const runtimeInventory = await collectRtwsGitInventory();
+        const runtimeRound1Text = formatRtwsGitInventoryRound1(language, runtimeInventory);
+        const runtimeRound2Text = formatRtwsGitInventoryRound2(language, runtimeInventory);
+        const runtimeInventoryText = [runtimeRound1Text, '', runtimeRound2Text].join('\n');
+        if (shellPolicy === 'specialist_only' &&
+            specialistId !== null &&
+            vcsRound1ResponseText.trim() &&
+            vcsRound2ResponseText.trim()) {
+            // Keep teammate replies as collaboration transcript, but use runtime-verified
+            // inventory as canonical facts for downstream FBR/distillation evidence.
+            vcsEvidenceRound1Text = runtimeRound1Text;
+            vcsEvidenceRound2Text = runtimeRound2Text;
+            vcsInventoryText = runtimeInventoryText;
+        }
+        else {
+            vcsRound1ResponseText = runtimeRound1Text;
+            vcsRound2ResponseText = runtimeRound2Text;
+            vcsEvidenceRound1Text = runtimeRound1Text;
+            vcsEvidenceRound2Text = runtimeRound2Text;
+            vcsRound1NoteMarkdown = formatRuntimeVcsRoundNote(language, 1, vcsRound1ResponseText);
+            vcsRound2NoteMarkdown = formatRuntimeVcsRoundNote(language, 2, vcsRound2ResponseText);
+            vcsInventoryText = runtimeInventoryText;
+            await dlg.withLock(async () => {
+                try {
+                    await dlg.notifyGeneratingStart();
+                    await emitSayingEventsAndPersist(dlg, vcsRound1NoteMarkdown);
+                }
+                finally {
+                    try {
+                        await dlg.notifyGeneratingFinish();
+                    }
+                    catch (_finishErr) {
+                        // best-effort
+                    }
+                }
+            });
+            await dlg.withLock(async () => {
+                try {
+                    await dlg.notifyGeneratingStart();
+                    await emitSayingEventsAndPersist(dlg, vcsRound2NoteMarkdown);
+                }
+                finally {
+                    try {
+                        await dlg.notifyGeneratingFinish();
+                    }
+                    catch (_finishErr) {
+                        // best-effort
+                    }
+                }
+            });
+        }
+        const fbrSnapshotText = [
+            snapshotText.trim() ? snapshotText.trim() : '',
+            vcsInventoryText.trim() ? vcsInventoryText.trim() : '',
+        ]
+            .filter((part) => part !== '')
+            .join('\n\n---\n\n');
         const rawFbrEffort = member ? member.fbr_effort : undefined;
         fbrEffort = (() => {
             if (typeof rawFbrEffort !== 'number' || !Number.isFinite(rawFbrEffort))
@@ -976,7 +1675,7 @@ async function runAgentPrimingLive(dlg) {
             }
             return n;
         })();
-        fbrCallBody = formatFbrTellaskBody(language, BASELINE_ENV_SNAPSHOT_CMD, snapshotText, shellPolicy, specialistId, { fbrEffort });
+        fbrCallBody = formatFbrTellaskBody(language, fbrSnapshotText.trim() ? fbrSnapshotText : snapshotText, { fbrEffort });
         selfTeaser = formatFbrSelfTeaser(language);
         let fbrCallId = null;
         let fbrTellaskHead = null;
@@ -1022,8 +1721,8 @@ async function runAgentPrimingLive(dlg) {
                         fbrCallBody,
                         '',
                         language === 'zh'
-                            ? '提示：请尽量提供与其它 FBR 草稿不同的视角（例如安全/限制/可验证性/工具优先级/风险点）。'
-                            : 'Hint: try to provide a distinct angle vs other FBR drafts (e.g. security/constraints/verifiability/tool priority/risk).',
+                            ? '提示：请尽量提供与其它 FBR 草稿不同的视角（例如安全/限制/可验证性/风险点）。'
+                            : 'Hint: try to provide a distinct angle vs other FBR drafts (e.g. security/constraints/verifiability/risk).',
                     ].join('\n')
                     : fbrCallBody;
                 const sub = await dlg.withLock(async () => {
@@ -1042,7 +1741,12 @@ async function runAgentPrimingLive(dlg) {
                     language,
                     collectiveTargets: [dlg.agentId],
                 });
-                await (0, driver_1.driveDialogStream)(sub, { content: initPrompt, msgId: (0, id_1.generateShortId)(), grammar: 'markdown' }, true);
+                await (0, driver_1.driveDialogStream)(sub, {
+                    content: initPrompt,
+                    msgId: (0, id_1.generateShortId)(),
+                    grammar: 'markdown',
+                    skipTaskdoc: true,
+                }, true);
                 const responseText = extractLastAssistantSaying(sub.msgs);
                 return { sub, responseText };
             }));
@@ -1072,6 +1776,8 @@ async function runAgentPrimingLive(dlg) {
             dlg,
             shellSnapshotText: snapshotText,
             shellResponseText: shellResponseText,
+            vcsRound1Text: vcsEvidenceRound1Text,
+            vcsRound2Text: vcsEvidenceRound2Text,
             fbrResponses: fbrResponsesForInjection,
             fbrTellaskHead: fbrTellaskHead,
             fbrCallId: fbrCallId,
@@ -1093,6 +1799,33 @@ async function runAgentPrimingLive(dlg) {
                     directNoteMarkdown,
                     snapshotText,
                 },
+            vcs: shellPolicy === 'specialist_only' &&
+                specialistId !== null &&
+                vcsRound1ResponseText.trim() &&
+                vcsRound2ResponseText.trim()
+                ? {
+                    kind: 'specialist_session',
+                    specialistId,
+                    sessionSlug: PRIMING_VCS_SESSION_SLUG,
+                    round1: {
+                        tellaskBody: vcsRound1Body || formatVcsSessionRound1TellaskBody(language),
+                        responseText: vcsRound1ResponseText,
+                    },
+                    round2: {
+                        tellaskBody: vcsRound2Body ||
+                            formatVcsSessionRound2TellaskBody(language, vcsRound1ResponseText),
+                        responseText: vcsRound2ResponseText,
+                    },
+                    inventoryText: vcsInventoryText,
+                }
+                : {
+                    kind: 'runtime_inventory',
+                    round1NoteMarkdown: vcsRound1NoteMarkdown ||
+                        formatRuntimeVcsRoundNote(language, 1, vcsRound1ResponseText),
+                    round2NoteMarkdown: vcsRound2NoteMarkdown ||
+                        formatRuntimeVcsRoundNote(language, 2, vcsRound2ResponseText),
+                    inventoryText: vcsInventoryText,
+                },
             fbr: {
                 tellaskHead: '@self',
                 tellaskBody: fbrCallBody,
@@ -1146,6 +1879,7 @@ async function runAgentPrimingLive(dlg) {
         throw err;
     }
     finally {
+        dlg.disableDiligencePush = prevDisableDiligencePush;
         if (fatalRunState) {
             await (0, dialog_run_state_1.setDialogRunState)(dlg.id, fatalRunState);
         }