dsh-plugin-t-expert 0.3.88 → 0.3.89

package/lib/teams/scheduler.js

@@ -1,642 +0,0 @@
-/**
- * Event-driven shared task scheduler.
- *
- * Claude Code teammates keep polling the shared task list after a turn. DSH
- * continuable agents instead expose explicit idle/running edges, so this
- * scheduler closes the same loop without keeping a polling turn alive: every
- * idle edge and every task-graph mutation attempts one atomic claim and wakes
- * the selected durable member. A resident member that becomes idle while it
- * still owns an open attempt is parked: only an explicit captain reassignment
- * may rotate that capability. Automatic retry is reserved for cold recovery,
- * when this process has not observed the durable owner settle its open attempt.
- * @module t-team/scheduler
- */
-import { join } from 'node:path';
-import { deliverToMember } from "./members.js";
-import { acknowledgeMailbox, beginTaskAttempt, CAPTAIN_KEY, claimMailboxDelivery, findTeamByParticipant, invalidateTaskAttempt, readTeam, readUnreadMailbox, releaseMailboxDelivery, unsatisfiedDependencies, withTeamLock, writeTeam, } from "./state.js";
-import { TERMINAL_TASK_STATUSES } from "./types.js";
-/** Per-dependency output cap in the assignment prompt. */
-export const DEPENDENCY_OUTPUT_MAX_CHARS = 2_000;
-/** Combined dependency-output budget in the assignment prompt. */
-export const DEPENDENCY_OUTPUTS_TOTAL_MAX_CHARS = 12_000;
-function taskProfileSeedId(task) {
-    const seed = task.profileSeedId?.trim();
-    return seed === undefined || seed === '' ? undefined : seed;
-}
-function teamProfileProtocol(team) {
-    return team.profile?.protocol;
-}
-/**
- * Recursively collect `status=completed` ancestors of `taskId` in topological
- * order (dependencies before dependents). Cycles stop that branch only.
- */
-export function collectCompletedDependencyOutputs(tasks, taskId, warn) {
-    const byId = new Map(tasks.map(task => [task.id, task]));
-    // 直接依赖 vs 传递性祖先：前者是这条任务的**直接输入**（给全文），后者只是背景
-    // （给摘要）。不区分的话，一条深链会用祖先的全文把预算吃光，把真正的直接输入挤掉。
-    const direct = new Set(byId.get(taskId)?.dependencies ?? []);
-    const visiting = new Set();
-    const visited = new Set();
-    const ordered = [];
-    const walk = (id) => {
-        if (visiting.has(id)) {
-            warn?.(`t-team: dependency cycle involving "${id}" while collecting outputs; stopping this branch`);
-            return;
-        }
-        if (visited.has(id))
-            return;
-        visiting.add(id);
-        const task = byId.get(id);
-        if (task !== undefined) {
-            for (const dependency of task.dependencies)
-                walk(dependency);
-            if (id !== taskId)
-                ordered.push(task);
-        }
-        visiting.delete(id);
-        visited.add(id);
-    };
-    walk(taskId);
-    return ordered
-        .filter(task => task.status === 'completed')
-        .map((task) => {
-        const profileSeedId = taskProfileSeedId(task);
-        return {
-            id: task.id,
-            subject: task.subject,
-            direct: direct.has(task.id),
-            ...profileSeedId === undefined ? {} : { profileSeedId },
-            ...task.output === undefined ? {} : { output: task.output },
-            ...task.summary === undefined ? {} : { summary: task.summary },
-            ...Array.isArray(task.tried) && task.tried.length > 0 ? { tried: task.tried } : {},
-        };
-    });
-}
-/**
- * 与本任务**并行在途**的其它任务（claimed / in_progress）。
- *
- * 为什么要给成员看见：两条并行任务即使写域（inScope）不重叠、闸门放行，也可能做出互相
- * 冲突的架构或风格决策 —— Cognition 记录过的经典形态是两个子代理并行做同一个游戏，一个
- * 画角色、一个画背景，风格完全对不上，因为彼此看不到对方的决策。事后由 integration 任务
- * 发现时返工成本已经产生。这里只用现成的任务表告诉成员「此刻还有谁在并行决定什么」，
- * 不新增任何状态，也不要求它们互相等待。
- */
-export function collectInFlightSiblings(tasks, taskId) {
-    return tasks
-        .filter(task => task.id !== taskId
-        && (task.status === 'claimed' || task.status === 'in_progress'))
-        .map(task => ({
-        id: task.id,
-        subject: task.subject,
-        assignee: task.assignee ?? '',
-        ...Array.isArray(task.inScope) && task.inScope.length > 0 ? { inScope: task.inScope } : {},
-    }));
-}
-/**
- * Format completed-dependency outputs with per-item and total truncation.
- *
- * 交接契约（2026-09-20）：**直接依赖给全文，传递性祖先优先给 `summary`**。
- * 过去一律传 `output` 全文再按字符数硬截断，于是长链上的祖先会把预算吃光，而下游真正
- * 需要的直接输入反倒被切掉；截断点还落在句子中间。有 `summary` 的祖先改传那一段压缩
- * 结论（它正是写给下游看的），信息密度高得多。
- *
- * `tried`（走过的死路）**无论直接与否都附上**：它的价值就是阻止下游重复同一条死路，
- * 而重复死路恰恰最常发生在隔了一层的任务之间。
- */
-export function formatDependencyOutputs(items) {
-    if (items.length === 0)
-        return '(none)';
-    const formatted = items.map((item) => {
-        const seed = item.profileSeedId === undefined ? '' : ` [${item.profileSeedId}]`;
-        // 祖先有摘要就用摘要；直接依赖始终用全文（缺全文时退回摘要）。
-        const preferSummary = item.direct !== true && typeof item.summary === 'string' && item.summary !== '';
-        const raw = preferSummary
-            ? item.summary
-            : item.output === undefined || item.output === ''
-                ? (item.summary ?? '(no output recorded)')
-                : item.output;
-        const truncated = raw.length > DEPENDENCY_OUTPUT_MAX_CHARS;
-        const body = truncated ? `${raw.slice(0, DEPENDENCY_OUTPUT_MAX_CHARS)} [truncated]` : raw;
-        const label = preferSummary ? ' (summary)' : '';
-        const tried = Array.isArray(item.tried) && item.tried.length > 0
-            ? `\n  Already tried and rejected: ${item.tried.join('; ')}`
-            : '';
-        return `- ${item.id}${seed} ${item.subject}${label}:\n  ${body}${tried}`;
-    });
-    let selected = formatted;
-    while (selected.length > 1 && selected.join('\n').length > DEPENDENCY_OUTPUTS_TOTAL_MAX_CHARS) {
-        selected = selected.slice(1);
-    }
-    const last = selected[0];
-    if (selected.length === 1 && last !== undefined && last.length > DEPENDENCY_OUTPUTS_TOTAL_MAX_CHARS) {
-        selected = [`${last.slice(0, DEPENDENCY_OUTPUTS_TOTAL_MAX_CHARS)} [truncated]`];
-    }
-    return selected.join('\n');
-}
-/**
- * 渲染「此刻并行在途的任务」。没有并行任务时返回空串（不占提示词预算）。
- * 措辞刻意约束成**只用于对齐决策**：不许等待、不许插手，否则会退化成互相阻塞。
- */
-export function formatInFlightSiblings(items) {
-    if (items === undefined || items.length === 0)
-        return '';
-    const lines = items.map((item) => {
-        const owner = item.assignee === '' ? 'unassigned' : item.assignee;
-        const scope = item.inScope === undefined || item.inScope.length === 0
-            ? ''
-            : ` — in scope: ${item.inScope.join(', ')}`;
-        return `- ${item.id} ${item.subject} (${owner})${scope}`;
-    });
-    return `
-Running in parallel right now (do NOT wait for these, do NOT work on them):
-${lines.join('\n')}
-Keep your choices compatible with theirs where your work meets. If your task forces a decision that would conflict with one of them, say so in your report instead of silently diverging.
-`;
-}
-function stateRootOf(workspace, config) {
-    return join(workspace, config.stateDir);
-}
-function teamLockKey(stateRoot, teamId) {
-    return `team:${stateRoot}:${teamId}`;
-}
-function liveCaptain(ctx, captainSessionId, supplied) {
-    if (supplied !== undefined && supplied.id === captainSessionId)
-        return supplied;
-    return ctx.agents.get(captainSessionId);
-}
-function liveMember(ctx, member) {
-    return ctx.agents.get(member.id);
-}
-function isMemberAvailable(ctx, member) {
-    const live = liveMember(ctx, member);
-    return live === undefined || live.status === 'idle';
-}
-function ownedOpenTask(tasks, memberName) {
-    return tasks.find(task => task.assignee === memberName
-        && (task.status === 'claimed' || task.status === 'in_progress'));
-}
-/**
- * 剩余关键路径长度（upward rank）：沿**尚未终结**的后继任务能延伸出的最长链长。
- *
- * 为什么需要它：就绪前沿常常同时有好几条任务，而过去是按**创建顺序**取第一条
- * （`ready.find`）—— 先挑走一条叶子任务会把真正卡住后续工作的那条往后推，直接拉长
- * makespan。rank 回答的正是「先做它能解开多少后续工作」，降序取就是经典 HEFT 的
- * upward-rank 优先。
- *
- * 只数**未终结**的后继：completed/failed/cancelled 不再产生剩余工作量，把它们算进去
- * 会让早已走完的分支虚高。无权重（每节点算 1）：引擎没有工期估计，节点数是唯一可得
- * 且稳定的代价度量。环（只可能出现在状态损坏时）按 0 截断该分支，绝不无限递归。
- * @returns Map<taskId, rank>；叶子为 1，越大越关键。
- */
-export function computeRemainingRanks(tasks) {
-    const byId = new Map(tasks.map(task => [task.id, task]));
-    const successors = new Map(tasks.map(task => [task.id, []]));
-    for (const task of tasks) {
-        for (const dependency of task.dependencies ?? [])
-            successors.get(dependency)?.push(task.id);
-    }
-    const ranks = new Map();
-    const visiting = new Set();
-    const rankOf = (id) => {
-        const cached = ranks.get(id);
-        if (cached !== undefined)
-            return cached;
-        if (visiting.has(id))
-            return 0; // 状态损坏出现环：这一支就此停住，不参与比较
-        visiting.add(id);
-        let deepest = 0;
-        for (const childId of successors.get(id) ?? []) {
-            const child = byId.get(childId);
-            if (child === undefined || TERMINAL_TASK_STATUSES.includes(child.status))
-                continue;
-            deepest = Math.max(deepest, rankOf(childId));
-        }
-        visiting.delete(id);
-        const rank = deepest + 1;
-        ranks.set(id, rank);
-        return rank;
-    };
-    for (const task of tasks)
-        rankOf(task.id);
-    return ranks;
-}
-/**
- * 亲和度词元：ASCII 词（≥3 字符）+ CJK 二元组。
- *
- * 中文没有分词，二元组是稳定又便宜的近似（「数据库性能工程师」→ 数据/据库/库性/性能/…）；
- * ASCII 那一半来自专家 slug（`engineering-frontend-developer` → engineering/frontend/
- * developer），是更精确的一半。两者都只用现成字段，不需要给 48 支小队补任何声明。
- */
-export function affinityTokens(text) {
-    const tokens = new Set();
-    const lower = String(text ?? '').toLowerCase();
-    for (const word of lower.match(/[a-z][a-z0-9]{2,}/gu) ?? [])
-        tokens.add(word);
-    for (const run of lower.replace(/[^\u4e00-\u9fff]+/gu, ' ').split(' ')) {
-        for (let index = 0; index + 2 <= run.length; index += 1)
-            tokens.add(run.slice(index, index + 2));
-    }
-    return tokens;
-}
-/** 成员画像词元：中文名 + 专家 slug（`member.role` 存的就是 slug）。 */
-export function memberAffinityTokens(member) {
-    return affinityTokens(`${member?.name ?? ''} ${member?.role ?? ''}`);
-}
-/** 任务文本与成员画像的重合词元数（0 = 看不出关系）。 */
-export function taskAffinity(task, memberTokens) {
-    if (memberTokens.size === 0)
-        return 0;
-    const text = [task?.subject, task?.objective, task?.description]
-        .filter(part => typeof part === 'string' && part !== '')
-        .join(' ');
-    let score = 0;
-    for (const token of affinityTokens(text)) {
-        if (memberTokens.has(token))
-            score += 1;
-    }
-    return score;
-}
-/**
- * 给一个空闲成员挑下一条任务。
- *
- * 排序键（依次）：
- *   1. **剩余关键路径降序** —— makespan 优先，永远不为了「派得更对口」牺牲关键路径；
- *   2. **成员亲和度降序** —— 只在同等关键度内起作用。小队成员是**异构领域专家**，
- *      而共享池过去完全不看这一点（`member.role` 全项目只用在成员自己的人格提示里），
- *      于是安全任务可能落到设计师头上。亲和度做**平级决胜**而不是硬过滤：既拿到专业
- *      匹配的收益，又不可能把任务饿死，也不可能比旧行为更差；
- *   3. **创建顺序** —— 前两项相同时保持稳定、可预测。
- *
- * 导出仅为让自检能直接钉住这三条排序键（与本文件 `assignmentPrompt` 等同样的做法）：
- * 这是**行为契约**，回退成旧的 `ready.find` 不会让任何文本断言变红。
- *
- * @param tasks 团队全部任务（rank 需要全图，不只是就绪集）
- * @param member 当前空闲成员记录（要用到 `name` 与 `role`）
- */
-export function nextReadyTask(tasks, member) {
-    const memberName = member.name;
-    const ready = tasks.filter(task => task.status === 'pending'
-        && task.reassigning !== true
-        && unsatisfiedDependencies([...tasks], task.dependencies).length === 0);
-    if (ready.length === 0)
-        return undefined;
-    const ranks = computeRemainingRanks(tasks);
-    const memberTokens = memberAffinityTokens(member);
-    const position = new Map(tasks.map((task, index) => [task.id, index]));
-    // 亲和度**每条任务只算一次**：它要把任务文本分词，而比较器会被调用 O(n log n) 次 ——
-    // 写在比较器里等于把同一段文本反复分词几百遍（本可忽略，但没有任何理由这么做）。
-    const affinity = new Map();
-    const affinityOf = (task) => {
-        let score = affinity.get(task.id);
-        if (score === undefined) {
-            score = taskAffinity(task, memberTokens);
-            affinity.set(task.id, score);
-        }
-        return score;
-    };
-    const best = (candidates) => candidates
-        .slice()
-        .sort((left, right) => (ranks.get(right.id) ?? 0) - (ranks.get(left.id) ?? 0)
-        || affinityOf(right) - affinityOf(left)
-        || (position.get(left.id) ?? 0) - (position.get(right.id) ?? 0))
-        .at(0);
-    const assigned = ready.filter(task => task.assignee === memberName);
-    if (assigned.length > 0)
-        return best(assigned);
-    // 审计修复（#5 调度侧）：共享池里的 review 任务不得分给被审任务的实现者本人
-    // （自审）。显式 assignee 已在创建/reassign 两道闸门挡住，这里挡住「调度器自动
-    // 把 review 派回实现者」这条剩余路径。
-    const pool = ready.filter(task => {
-        if (task.assignee !== undefined)
-            return false;
-        if ((task.kind ?? 'work') !== 'review')
-            return true;
-        const reviewed = tasks.find(candidate => candidate.id === task.reviewedTaskId);
-        return reviewed?.assignee !== memberName;
-    });
-    return pool.length === 0 ? undefined : best(pool);
-}
-export function assignmentPrompt(ticket, stateDir, teamId) {
-    const description = ticket.description === undefined ? '' : `\n\n${ticket.description}`;
-    const seed = ticket.profileSeedId === undefined ? '' : ` [${ticket.profileSeedId}]`;
-    const goal = ticket.teamDescription?.trim() || '(not provided)';
-    const protocol = ticket.profileProtocol?.trim() || '(none)';
-    const executionPrompt = ticket.executionPrompt?.trim();
-    const kind = ticket.kind?.trim() || 'work';
-    const contract = [
-        `Kind: ${kind}${ticket.round === undefined ? '' : ` (round ${ticket.round})`}`,
-        ticket.objective === undefined || ticket.objective === '' ? '' : `Objective: ${ticket.objective}`,
-        ticket.inScope === undefined || ticket.inScope.length === 0 ? '' : `In scope: ${ticket.inScope.join(', ')}`,
-        ticket.outOfScope === undefined || ticket.outOfScope.length === 0 ? '' : `Out of scope: ${ticket.outOfScope.join(', ')}`,
-        ticket.acceptance === undefined || ticket.acceptance.length === 0 ? '' : `Acceptance: ${ticket.acceptance.join('; ')}`,
-        ticket.verify === undefined || ticket.verify.length === 0 ? '' : `Verify: ${ticket.verify.join('; ')}`,
-        ticket.reviewedTaskId === undefined ? '' : `Reviewed task: ${ticket.reviewedTaskId}`,
-    ].filter((line) => line !== '').join('\n');
-    const structuredCompletion = ['implementation', 'repair', 'verification', 'integration'].includes(kind)
-        ? `
-Structured completion payload (keep these arrays in contract order):
-acceptanceResults: ${JSON.stringify((ticket.acceptance ?? []).map((criterion) => ({ criterion, status: 'passed', evidence: '<what proved it>' })))}
-commandsRun: ${JSON.stringify((ticket.verify ?? []).map((command) => ({ command, status: 'passed', exitCode: 0, evidence: '<observed result>' })))}
-${kind === 'implementation' || kind === 'repair' ? 'changedPaths: list the actual workspace-relative POSIX paths you changed.\n' : ''}`
-        : '';
-    return `T Team automatic task assignment from the shared task list.
-
-You are executing as configured member "${ticket.memberName}".
-Do not start a teammate's assigned task.
-
-Team goal:
-${goal}
-
-Profile protocol:
-${protocol}
-${executionPrompt === undefined || executionPrompt === '' ? '' : `
-Execution guidance:
-${executionPrompt}
-`}
-Completed dependency results:
-${formatDependencyOutputs(ticket.dependencyOutputs)}
-${formatInFlightSiblings(ticket.inFlightSiblings)}
-Task: ${ticket.taskId}${seed} — ${ticket.subject}${description}
-${contract === '' ? '' : `\nContract:\n${contract}\n`}
-${structuredCompletion}
-Attempt: ${ticket.attempt}
-Attempt id: ${ticket.attemptId}
-
-Call t_team_claim_task for ${ticket.taskId}; it will return this same attempt_id. Include attempt_id=${ticket.attemptId} in every t_team_update_task call. If it is rejected as stale, stop work because the task was reassigned. claimed cannot jump to completed. Mark in_progress first, then completed or failed. Include attempt_id on every update, then become idle.
-
-Write the report exactly once. t_team_update_task IS your report: the captain and every downstream task read output/summary/tried from it. After that update succeeds:
-- send_message to the captain with a ONE-LINE notice ("${ticket.taskId} completed — result in the task output"). That line is what wakes the captain; it must not restate the report.
-- Keep your closing turn message to ONE line too. It is delivered to the captain in full, so a write-up there is a third copy of the same text.
-Everything the captain needs is already in the task record. A completion written out three times costs three times the context and says nothing new.
-When finishing: use status=completed only when the task's success criteria are satisfied; use status=failed when blocking findings or validation failures mean downstream work must not proceed; include a concise output in either case. Always also send summary (the one-paragraph conclusion downstream tasks need, plus any assumption you had to make) and, whenever you hit dead ends, tried (each failed approach with why it failed) — tasks that depend on you transitively receive the summary instead of your full output, and tried is what stops them from repeating your dead ends. Quality kinds must submit structured fields: review/requirements need verdict=pass to complete (needs_revision/reject must fail with findings); implementation/repair/verification/integration need acceptanceResults and commandsRun, while implementation/repair also need in-scope changedPaths. Use status values "passed" or "failed" inside those arrays. After the work and verification finish, call t_team_update_task immediately; do not wait for captain confirmation and do not continue exploring. Do not approve your own implementation. Mail is not a formal next review. Treat the dependency results above as source material. Do not ignore them. Work only this task and only its in-scope paths in this turn.
-
-State policy: ${stateDir}/${teamId}/ is read-only diagnostics; mutate team state only through t_team_* tools.`;
-}
-function fallbackMailboxPrompt(messages) {
-    return [
-        'T Team delivered messages that were persisted while live delivery was unavailable:',
-        ...messages.map(message => `\nFrom ${message.from}:\n${message.content}`),
-        '\nHandle these messages in this turn. Task assignments still require t_team_claim_task and the current attempt_id.',
-    ].join('\n');
-}
-/** Install one scheduler and its member activity observer. */
-export function installTeamScheduler(ctx, config) {
-    const memberQueues = new Map();
-    // An idle edge in this process proves that the resident member ended its
-    // turn while the current attempt was still open. Remember that capability
-    // even after Harness disposes the continuable AgentHandle: later status or
-    // graph kicks must keep it parked. A cold process starts with an empty map,
-    // so durable open attempts are still recovered after restart.
-    const parkedAttempts = new Map();
-    const memberQueueKey = (stateRoot, teamId, memberName) => (`${stateRoot}\u0000${teamId}\u0000${memberName}`);
-    const serializeMember = async (key, operation) => {
-        const previous = memberQueues.get(key) ?? Promise.resolve();
-        let release;
-        const gate = new Promise((resolve) => { release = resolve; });
-        const tail = previous.then(() => gate);
-        memberQueues.set(key, tail);
-        await previous;
-        try {
-            return await operation();
-        }
-        finally {
-            release();
-            if (memberQueues.get(key) === tail)
-                memberQueues.delete(key);
-        }
-    };
-    const runtime = {
-        async kickTeam(workspace, teamId, suppliedCaptain) {
-            const stateRoot = stateRootOf(workspace, config);
-            const team = await readTeam(stateRoot, teamId);
-            if (team === undefined || team.halted === true || team.phase === 'staged')
-                return;
-            const captain = liveCaptain(ctx, team.captainSessionId, suppliedCaptain);
-            if (captain === undefined)
-                return;
-            for (const member of team.members) {
-                if (member.status === 'removed')
-                    continue;
-                await runtime.kickMember(workspace, teamId, member.name, captain);
-            }
-        },
-        async kickMember(workspace, teamId, memberName, suppliedCaptain) {
-            const stateRoot = stateRootOf(workspace, config);
-            const queueKey = memberQueueKey(stateRoot, teamId, memberName);
-            await serializeMember(queueKey, async () => {
-                let team = await readTeam(stateRoot, teamId);
-                if (team === undefined || team.halted === true || team.phase === 'staged')
-                    return;
-                const captain = liveCaptain(ctx, team.captainSessionId, suppliedCaptain);
-                if (captain === undefined)
-                    return;
-                let member = team.members.find(candidate => candidate.name === memberName && candidate.status !== 'removed');
-                if (member === undefined || member.id === '' || !isMemberAvailable(ctx, member))
-                    return;
-                // A mailbox-only fallback is real pending work. Deliver it before a
-                // fresh task and acknowledge only after Harness accepts the follow-up.
-                const unread = await readUnreadMailbox(stateRoot, team.id, member.name);
-                if (unread.length > 0) {
-                    await withTeamLock(teamLockKey(stateRoot, team.id), () => (claimMailboxDelivery(stateRoot, team.id, member.name, unread.map(message => message.id))));
-                    const accepted = await deliverToMember(ctx, captain, member.id, fallbackMailboxPrompt(unread), new AbortController().signal);
-                    if (accepted) {
-                        await withTeamLock(teamLockKey(stateRoot, team.id), () => (acknowledgeMailbox(stateRoot, team.id, member.name, unread.map(message => message.id))));
-                    }
-                    else {
-                        await withTeamLock(teamLockKey(stateRoot, team.id), () => (releaseMailboxDelivery(stateRoot, team.id, member.name, unread.map(message => message.id))));
-                    }
-                    return;
-                }
-                const ticket = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                    const fresh = await readTeam(stateRoot, team.id);
-                    if (fresh === undefined || fresh.halted === true || fresh.phase === 'staged')
-                        return undefined;
-                    const currentMember = fresh.members.find(candidate => candidate.name === memberName && candidate.status !== 'removed');
-                    if (currentMember === undefined || currentMember.id === '' || !isMemberAvailable(ctx, currentMember))
-                        return undefined;
-                    const owned = ownedOpenTask(fresh.tasks, currentMember.name);
-                    // An idle edge observed by this scheduler parks the exact open
-                    // capability. Harness may dispose its AgentHandle after settlement,
-                    // so registry absence is not evidence that the owner was lost. Keep
-                    // the marker sticky across later kicks; only a durable attempt that
-                    // this process has not observed is eligible for one cold recovery.
-                    const parkedAttemptId = parkedAttempts.get(currentMember.id);
-                    const recoverOwned = owned !== undefined
-                        && (owned.attemptId === undefined || owned.attemptId !== parkedAttemptId);
-                    const task = recoverOwned ? owned : owned === undefined
-                        ? nextReadyTask(fresh.tasks, currentMember)
-                        : undefined;
-                    if (task === undefined) {
-                        if (currentMember.status !== 'idle') {
-                            currentMember.status = 'idle';
-                            await writeTeam(stateRoot, fresh);
-                        }
-                        return undefined;
-                    }
-                    const previousAssignee = task.assignee;
-                    const previousStatus = recoverOwned ? task.status : undefined;
-                    const previousAttempt = recoverOwned ? task.attempt : undefined;
-                    const previousAttemptId = recoverOwned ? task.attemptId : undefined;
-                    const attemptId = beginTaskAttempt(task, currentMember.name);
-                    // A recovered generation is parked before delivery. This makes each
-                    // (member, attempt) recovery idempotent even if every status poll
-                    // sees a disposed handle. Fresh pending work remains unparked so a
-                    // genuinely lost first delivery can be recovered once.
-                    if (recoverOwned)
-                        parkedAttempts.set(currentMember.id, attemptId);
-                    else
-                        parkedAttempts.delete(currentMember.id);
-                    currentMember.status = 'working';
-                    await writeTeam(stateRoot, fresh);
-                    const profileSeedId = taskProfileSeedId(task);
-                    const protocol = teamProfileProtocol(fresh);
-                    return {
-                        taskId: task.id,
-                        memberName: currentMember.name,
-                        memberId: currentMember.id,
-                        attempt: task.attempt ?? 1,
-                        attemptId,
-                        previousAssignee,
-                        recoveredOwned: recoverOwned,
-                        ...previousStatus === undefined ? {} : { previousStatus },
-                        ...previousAttempt === undefined ? {} : { previousAttempt },
-                        ...previousAttemptId === undefined ? {} : { previousAttemptId },
-                        subject: task.subject,
-                        description: task.description,
-                        teamDescription: fresh.description,
-                        ...protocol === undefined ? {} : { profileProtocol: protocol },
-                        ...profileSeedId === undefined ? {} : { profileSeedId },
-                        ...fresh.profile?.executionPrompt === undefined && config.executionPrompt === undefined
-                            ? {}
-                            : { executionPrompt: fresh.profile?.executionPrompt ?? config.executionPrompt },
-                        kind: task.kind ?? 'work',
-                        ...task.round === undefined ? {} : { round: task.round },
-                        ...task.objective === undefined ? {} : { objective: task.objective },
-                        ...task.inScope === undefined ? {} : { inScope: task.inScope },
-                        ...task.outOfScope === undefined ? {} : { outOfScope: task.outOfScope },
-                        ...task.acceptance === undefined ? {} : { acceptance: task.acceptance },
-                        ...task.verify === undefined ? {} : { verify: task.verify },
-                        ...task.reviewedTaskId === undefined ? {} : { reviewedTaskId: task.reviewedTaskId },
-                        dependencyOutputs: collectCompletedDependencyOutputs(fresh.tasks, task.id, (message) => ctx.logger.warn(message)),
-                        inFlightSiblings: collectInFlightSiblings(fresh.tasks, task.id),
-                    };
-                });
-                if (ticket === undefined)
-                    return;
-                const accepted = await deliverToMember(ctx, captain, ticket.memberId, assignmentPrompt(ticket, config.stateDir, team.id), new AbortController().signal);
-                if (accepted)
-                    return { dispatched: true };
-                // Roll back only our exact failed dispatch. A concurrent captain
-                // handoff has already changed the capability and wins.
-                await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
-                    const fresh = await readTeam(stateRoot, team.id);
-                    if (fresh === undefined)
-                        return;
-                    const task = fresh.tasks.find(candidate => candidate.id === ticket.taskId);
-                    if (task?.attemptId !== ticket.attemptId)
-                        return;
-                    if (ticket.recoveredOwned && ticket.previousStatus !== undefined && ticket.previousAttemptId !== undefined) {
-                        // Recovery delivery failed. Restore the durable generation instead
-                        // of returning it to pending, then keep it parked so later status
-                        // kicks cannot spend an unbounded sequence of fresh attempts.
-                        task.status = ticket.previousStatus;
-                        task.assignee = ticket.previousAssignee;
-                        task.attempt = ticket.previousAttempt;
-                        task.attemptId = ticket.previousAttemptId;
-                        parkedAttempts.set(ticket.memberId, ticket.previousAttemptId);
-                    }
-                    else {
-                        task.status = 'pending';
-                        task.assignee = ticket.previousAssignee;
-                        task.attemptId = undefined;
-                        parkedAttempts.delete(ticket.memberId);
-                    }
-                    task.handoffId = undefined;
-                    task.reassigning = false;
-                    task.updatedAt = Date.now();
-                    const currentMember = fresh.members.find(candidate => candidate.name === ticket.memberName);
-                    if (currentMember !== undefined && currentMember.status !== 'removed')
-                        currentMember.status = 'idle';
-                    await writeTeam(stateRoot, fresh);
-                });
-                // 审计修复（#8）：把投递失败传回调用方（同步的 create/reassign 会把它带进工具
-                // 结果），而不是只让任务静默回滚成 pending。后台 idle-edge 调用方忽略该返回值。
-                return { dispatched: false, deliveryError: 'prompt delivery to member failed; see host logs' };
-            });
-        },
-    };
-    const syncMemberStatus = async (agent, status) => {
-        const workspace = agent.session.header.cwd ?? process.cwd();
-        const stateRoot = stateRootOf(workspace, config);
-        const located = await findTeamByParticipant(stateRoot, agent.id);
-        if (located === undefined) {
-            parkedAttempts.delete(agent.id);
-            return;
-        }
-        if (located.captainSessionId === agent.id) {
-            // Captain takeover is scoped to the captain's current turn. Unlike a
-            // durable member, the captain has no scheduler lane that can resume an
-            // abandoned attempt later. Returning unfinished captain-owned work to
-            // the shared pool on the idle edge prevents it from becoming a
-            // permanently parked `claimed` task after the captain answers, is
-            // interrupted, or the user switches conversations.
-            if (status === 'running')
-                return;
-            let requeued = false;
-            await withTeamLock(teamLockKey(stateRoot, located.id), async () => {
-                const fresh = await readTeam(stateRoot, located.id);
-                if (fresh === undefined || fresh.captainSessionId !== agent.id)
-                    return;
-                for (const task of fresh.tasks) {
-                    if (task.assignee !== CAPTAIN_KEY
-                        || task.status === 'completed'
-                        || task.status === 'failed'
-                        || task.status === 'cancelled')
-                        continue;
-                    invalidateTaskAttempt(task);
-                    task.reassigning = false;
-                    requeued = true;
-                }
-                if (requeued)
-                    await writeTeam(stateRoot, fresh);
-            });
-            if (requeued)
-                await runtime.kickTeam(workspace, located.id, agent);
-            return;
-        }
-        const member = located.members.find(candidate => candidate.id === agent.id && candidate.status !== 'removed');
-        if (member === undefined) {
-            parkedAttempts.delete(agent.id);
-            return;
-        }
-        await withTeamLock(teamLockKey(stateRoot, located.id), async () => {
-            const fresh = await readTeam(stateRoot, located.id);
-            const current = fresh?.members.find(candidate => candidate.id === agent.id && candidate.status !== 'removed');
-            if (fresh === undefined || current === undefined)
-                return;
-            const next = status === 'running' ? 'working' : 'idle';
-            if (next === 'idle') {
-                const owned = ownedOpenTask(fresh.tasks, current.name);
-                if (owned?.attemptId === undefined)
-                    parkedAttempts.delete(agent.id);
-                else
-                    parkedAttempts.set(agent.id, owned.attemptId);
-            }
-            else {
-                parkedAttempts.delete(agent.id);
-            }
-            if (current.status === next)
-                return;
-            current.status = next;
-            await writeTeam(stateRoot, fresh);
-        });
-        if (status === 'idle')
-            await runtime.kickMember(workspace, located.id, member.name);
-    };
-    ctx.on('agent/status', ({ agent, status }) => {
-        void syncMemberStatus(agent, status).catch((error) => {
-            ctx.logger.warn(`t-team: member status scheduling failed for ${agent.id}: ${String(error)}`);
-        });
-    });
-    return runtime;
-}