@nanmicoder/dsh-agent-teams 0.1.20 → 0.1.22-rc.1

package/lib/git-artifact-stamp.json

@@ -0,0 +1,5 @@
+{
+  "schema": 1,
+  "source": "5f2a18e5208435f0838152058ab8929f024699a61fb85338a5dffcaf0c829447",
+  "output": "1373527d718f862f5fae89f40dc6bd3347cef086159d596ff2519c5f5182bd4b"
+}

package/lib/harness-compat.js

@@ -18,6 +18,21 @@ function boundary(runtime) {
 function unsupported(detail) {
     throw new Error(`agent-teams: unsupported Harness subagent contract (${detail}); use an explicitly tested Harness version and a coherent dependency installation`);
 }
+/**
+ * 0.1.6 moved startup admission to serial agent/created. Older created events
+ * have no source and precede session-start; ignore those until the old hook.
+ * Keep the removed event's type confined to this audited compatibility seam.
+ */
+export function onAgentReady(ctx, listener) {
+    const stopCreated = ctx.on('agent/created', payload => {
+        if ('source' in payload)
+            listener(payload.agent, true);
+        return undefined;
+    });
+    const legacy = ctx;
+    const stopLegacy = legacy.on('agent/session-start', ({ agent }) => listener(agent, false));
+    return () => { stopCreated(); stopLegacy(); };
+}
 /** Read child-owned history, excluding any descriptor inherited from a parent. */
 export function sessionOwnEvents(session) {
     const current = session;
@@ -48,7 +63,7 @@ export function installContinuableMemberSetup(ctx, setup) {
     const installed = new WeakSet();
     const active = new Set();
     ctx.effect(() => {
-        const stop = ctx.on('agent/session-start', ({ agent }) => {
+        const stop = onAgentReady(ctx, (agent, vetoable) => {
             if (installed.has(agent))
                 return;
             // Deliberately synchronous: awaiting here loses the first-request race.
@@ -57,6 +72,8 @@ export function installContinuableMemberSetup(ctx, setup) {
                 teardown = setup(agent.ctx, agent);
             }
             catch (error) {
+                if (vetoable)
+                    throw error;
                 // session-start is a notification: Harness logs a thrown listener and
                 // still admits the first prompt. Reject request assembly explicitly so
                 // a malformed saved route cannot silently execute on a default model.
@@ -95,7 +112,7 @@ export function installContinuableMemberSetup(ctx, setup) {
 /** Queue a distinct host-authored turn; never substitute model-message steer. */
 export async function queueMemberPrompt(runtime, parent, childId, content, signal) {
     const host = boundary(runtime);
-    const source = { kind: 'plugin', plugin: 'dsh-agent-teams' };
+    const source = { kind: 'agent-teams' };
     if (typeof host.followup === 'function') {
         return host.followup.call(runtime, parent, childId, content, { source, signal });
     }
@@ -110,7 +127,7 @@ export async function queueMemberPrompt(runtime, parent, childId, content, signa
 /** Coordination joins the nearest step, including waking an idle/cold child. */
 export async function steerMemberPrompt(runtime, parent, childId, content, signal, live) {
     const host = boundary(runtime);
-    const source = { kind: 'plugin', plugin: 'dsh-agent-teams' };
+    const source = { kind: 'agent-teams' };
     const deliver = host[hostPromptDeliver];
     if (typeof deliver === 'function')
         return deliver.call(runtime, parent, childId, content, source, signal, 'steer');

package/lib/index.js

@@ -285,7 +285,7 @@ export function apply(ctx, config) {
                         try {
                             captain.steer(createUserMessage({
                                 content: [{ type: 'text', text: stagedPlanApprovedContext(team.name) }],
-                                source: { kind: 'plugin', plugin: 'dsh-agent-teams' },
+                                source: { kind: 'agent-teams' },
                             }));
                         }
                         catch (error) {

package/lib/mailbox.js

@@ -1,19 +1,39 @@
 import { join } from 'node:path';
-import { acknowledgeMailbox, CAPTAIN_KEY, discardMailboxMessages, findTeamByCaptain, readMailbox, readTeam, sanitizeKey, withTeamLock } from "./state.js";
+import { acknowledgeMailbox, CAPTAIN_KEY, discardMailboxMessages, findTeamByCaptain, readMailbox, readUnreadMailbox, readTeam, sanitizeKey, withTeamLock } from "./state.js";
 import { sessionOwnEvents } from "./harness-compat.js";
 const PREFIX = 'AgentTeams inbox receipt: ';
 export function isCurrentMail(team, message) {
     if (message.discardedAt !== undefined)
         return false;
+    if (message.sourceAttemptId !== undefined && !team.tasks.some(task => task.id === message.sourceTaskId
+        && task.attemptId === message.sourceAttemptId && task.assignee === message.from
+        && (message.sourceTaskStatus === undefined || !['completed', 'failed', 'cancelled'].includes(task.status) || message.sourceTaskStatus === task.status)))
+        return false;
     if (message.attemptId === undefined)
         return true;
     return team.tasks.some(task => task.id === message.taskId && task.attemptId === message.attemptId
         && task.assignee === message.to && (task.status === 'claimed' || task.status === 'in_progress'));
 }
+/** Include structured provenance even in the status-tool fallback presentation. */
+export function mailboxContent(message) {
+    return (message.sourceTaskId === undefined ? ''
+        : `[Source task ${message.sourceTaskId}, attempt_id ${message.sourceAttemptId}${message.sourceTaskStatus === undefined ? '' : `, status=${message.sourceTaskStatus}`}]\n`) + message.content;
+}
 function mailboxBody(recipient, messages) {
     return messages.map(message => recipient === CAPTAIN_KEY
-        ? `AgentTeams message from member ${message.from}:\n\n${message.content}`
-        : `AgentTeams message from ${message.from}${message.attemptId === undefined ? '' : ` for task ${message.taskId}, attempt_id ${message.attemptId}`}:\n\n${message.content}`).join('\n\n');
+        ? `AgentTeams message from member ${message.from}:\n\n${mailboxContent(message)}`
+        : `AgentTeams message from ${message.from}${message.attemptId === undefined ? '' : ` for task ${message.taskId}, attempt_id ${message.attemptId}`}:\n\n${mailboxContent(message)}`).join('\n\n');
+}
+/** Fallback reads must enforce the same current-generation rule as live admission. */
+export async function readCurrentMailbox(root, teamId, recipient, onMalformed) {
+    return withTeamLock(`team:${root}:${teamId}`, async () => {
+        const team = await readTeam(root, teamId);
+        if (team === undefined)
+            return [];
+        const messages = await readUnreadMailbox(root, teamId, recipient, onMalformed);
+        await discardMailboxMessages(root, teamId, recipient, messages.filter(message => !isCurrentMail(team, message)).map(message => message.id));
+        return messages.filter(message => isCurrentMail(team, message));
+    });
 }
 export function mailboxPrompt(teamId, recipient, messages) {
     return PREFIX + JSON.stringify({ teamId, recipient, ids: messages.map(message => message.id) }) + '\n\n' + mailboxBody(recipient, messages);

package/lib/members.js

@@ -72,7 +72,7 @@ export function steerCaptainReport(captain, from, content, receipt) {
     try {
         captain.steer(createUserMessage({
             content: [{ type: 'text', text: receipt ?? `AgentTeams message from member ${from}:\n\n${content}` }],
-            source: { kind: 'plugin', plugin: 'dsh-agent-teams' },
+            source: { kind: 'agent-teams' },
         }));
         return true;
     }
@@ -459,13 +459,13 @@ Working rules:
    - a stale-attempt rejection means the captain reassigned or took over the task; stop touching that task and wait for new work.
    claimed cannot jump to completed. Mark in_progress first, then completed or failed.
    Include attempt_id on every update. Then report once as described below and become idle.
-4. Send one short report with agent_teams_send_message (to=captain) when you complete a task or hit a blocker. The captain is also your parent: this single message satisfies both reporting duties. Do not repeat it through the native send_message tool or send acknowledgments that add no new information.
+4. Send one short report with agent_teams_send_message (to=captain) when you complete a task or hit a blocker. Include source_task_id and source_attempt_id in task reports; a stale source rejection means stop, never relabel an old result with a new attempt. The captain is also your parent: this single message satisfies both reporting duties. Do not repeat it through the native send_message tool or send acknowledgments that add no new information.
 5. To ask a teammate something, use agent_teams_send_message with to=<teammate name>; the message lands in their mailbox and wakes them directly — teammates talk to each other without the captain in the loop. The same applies to the captain (to=captain).
 6. After your turn becomes idle, the shared task scheduler may assign your next ready task automatically. Never claim a second task while you still own unfinished work.
 7. If you already own an open attempt (claimed or in_progress) and receive mail, treat it as guidance for that same attempt_id unless the mail explicitly tells you to stop or fail. Do not claim a new task in that turn.
 8. Do not start a teammate's assigned task. Do not privately tell the next-stage member to start; the scheduler assigns unlocked work after you become idle.
 9. You are a worker: do not create or delete teams, reassign tasks, or add/remove members — that is the captain's job.
-10. Quality-gate kinds carry a contract (kind, objective, inScope, acceptance, verify). Stay inside inScope. Do not mark your own implementation as review pass. Review/requirements complete only with verdict=pass; needs_revision/reject must fail with findings. Mail is not a formal next review.`;
+10. Quality-gate kinds carry a contract (kind, objective, inScope, acceptance, verify). Stay inside inScope. Do not mark your own implementation as review pass. Review/requirements complete only with verdict=pass; needs_revision/reject must fail with findings. Mail is not a formal next review. Completed work must not be repeated to attach late evidence: call update_task on the original task with its attempt_id and acceptanceResults/commandsRun/evidence_note; supplements are append-only and cannot change its verdict.`;
 }
 /**
  * The initial user message delivered when the member is created.

package/lib/quality-gates.js

@@ -236,6 +236,11 @@ export function validateCreateTask(team, input) {
         if (!team.tasks.some((item) => item.id === input.sourceTaskId)) {
             return { ok: false, error: `source task "${input.sourceTaskId}" does not exist` };
         }
+        const duplicate = team.tasks.find(item => taskKindOf(item) === 'repair'
+            && OPEN_STATUSES.includes(item.status) && item.sourceTaskId === input.sourceTaskId
+            && findingKey(item.sourceFindingIds ?? []) === findingKey(input.sourceFindingIds ?? []));
+        if (duplicate !== undefined)
+            return { ok: false, error: `repair task ${duplicate.id} already covers these findings; use that task instead of creating duplicate work` };
     }
     const dependencies = input.dependencies ?? [];
     for (const dependency of dependencies) {
@@ -850,6 +855,8 @@ export function hasValidQualityTaskFields(value) {
         if (!Array.isArray(value['commandsRun']) || !value['commandsRun'].every(isCommandResult))
             return false;
     }
+    if (value['supplementalEvidence'] !== undefined && (!Array.isArray(value['supplementalEvidence']) || !value['supplementalEvidence'].every(isTaskEvidence)))
+        return false;
     if (value['revisions'] !== undefined) {
         if (!Array.isArray(value['revisions']) || !value['revisions'].every(isTaskRevision))
             return false;
@@ -991,3 +998,50 @@ export function describeQualityLoop(team) {
     };
 }
 export { QUALITY_KINDS, WRITE_KINDS };
+/** Persisted evidence must remain loadable after process restart. */
+export function isTaskEvidence(value) {
+    if (!isRecord(value))
+        return false;
+    return typeof value['at'] === 'number' && Number.isFinite(value['at'])
+        && nonemptyString(value['by']) && Number.isSafeInteger(value['attempt']) && value['attempt'] >= 0
+        && (value['attemptId'] === undefined || nonemptyString(value['attemptId']))
+        && (value['note'] === undefined || nonemptyString(value['note']))
+        && (value['acceptanceResults'] === undefined || (Array.isArray(value['acceptanceResults']) && value['acceptanceResults'].every(isAcceptanceResult)))
+        && (value['commandsRun'] === undefined || (Array.isArray(value['commandsRun']) && value['commandsRun'].every(isCommandResult)))
+        && (value['note'] !== undefined || (Array.isArray(value['acceptanceResults']) && value['acceptanceResults'].length > 0) || (Array.isArray(value['commandsRun']) && value['commandsRun'].length > 0));
+}
+/** Append observations without mutating the original result or its completion time. */
+export function appendTaskEvidence(task, input, by) {
+    if (!TERMINAL_TASK_STATUSES.includes(task.status))
+        throw new Error('supplemental evidence requires a terminal task');
+    // Key order must not turn a retried JSON object into a different observation.
+    const stable = (value) => JSON.stringify(value, (_key, item) => typeof item === 'object' && item !== null && !Array.isArray(item)
+        ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b))) : item);
+    for (const key of ['status', 'output', 'verdict', 'findings', 'changedPaths']) {
+        if (input[key] !== undefined && stable(input[key]) !== stable(task[key])) {
+            throw new Error(`terminal task ${task.id} is immutable: cannot change ${key}; append evidence with evidence_note, acceptanceResults or commandsRun instead. Do not reclaim or redo completed work.`);
+        }
+    }
+    const prior = (task.supplementalEvidence ?? []).filter(row => row.by === by && row.attempt === (task.attempt ?? 0) && row.attemptId === task.attemptId);
+    const freshItems = (items, existing) => {
+        const seen = new Set(existing.map(stable));
+        return (items ?? []).filter(item => { const key = stable(item); if (seen.has(key))
+            return false; seen.add(key); return true; });
+    };
+    const acceptanceResults = freshItems(input.acceptanceResults, [...task.acceptanceResults ?? [], ...prior.flatMap(row => row.acceptanceResults ?? [])]);
+    const commandsRun = freshItems(input.commandsRun, [...task.commandsRun ?? [], ...prior.flatMap(row => row.commandsRun ?? [])]);
+    const trimmed = input.evidence_note?.trim();
+    const note = trimmed && !prior.some(row => row.note === trimmed) ? trimmed : undefined;
+    if (!note && acceptanceResults.length === 0 && commandsRun.length === 0)
+        return false;
+    const entry = { at: Date.now(), by, attempt: task.attempt ?? 0,
+        ...task.attemptId === undefined ? {} : { attemptId: task.attemptId },
+        ...note === undefined ? {} : { note },
+        ...acceptanceResults.length === 0 ? {} : { acceptanceResults },
+        ...commandsRun.length === 0 ? {} : { commandsRun },
+    };
+    if (!isTaskEvidence(entry))
+        throw new Error('invalid supplemental evidence');
+    task.supplementalEvidence = [...task.supplementalEvidence ?? [], entry];
+    return true;
+}

package/lib/scheduler.js

@@ -166,8 +166,8 @@ ${structuredCompletion}
 Attempt: ${ticket.attempt}
 Attempt id: ${ticket.attemptId}
 
-Call agent_teams_claim_task for ${ticket.taskId}; it will return this same attempt_id. Include attempt_id=${ticket.attemptId} in every agent_teams_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 send_message to captain and become idle.
-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. 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 agent_teams_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.
+Call agent_teams_claim_task for ${ticket.taskId}; it will return this same attempt_id. Include attempt_id=${ticket.attemptId} in every agent_teams_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 send_message to captain with source_task_id and source_attempt_id and become idle.
+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. 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 agent_teams_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. Completed work must not be repeated to attach late evidence: call update_task on the original task with its attempt_id and acceptanceResults/commandsRun/evidence_note; supplements are append-only and cannot change its verdict. 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 agent_teams_* tools.`;
 }
@@ -281,6 +281,10 @@ export function installTeamScheduler(ctx, config) {
                     const previousStatus = recoverOwned ? task.status : undefined;
                     const previousAttempt = recoverOwned ? task.attempt : undefined;
                     const previousAttemptId = recoverOwned ? task.attemptId : undefined;
+                    const previousResult = recoverOwned ? {
+                        output: task.output, verdict: task.verdict, findings: task.findings,
+                        changedPaths: task.changedPaths, acceptanceResults: task.acceptanceResults, commandsRun: task.commandsRun,
+                    } : 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
@@ -302,6 +306,7 @@ export function installTeamScheduler(ctx, config) {
                         attemptId,
                         previousAssignee,
                         recoveredOwned: recoverOwned,
+                        ...previousResult === undefined ? {} : { previousResult },
                         ...previousStatus === undefined ? {} : { previousStatus },
                         ...previousAttempt === undefined ? {} : { previousAttempt },
                         ...previousAttemptId === undefined ? {} : { previousAttemptId },
@@ -350,6 +355,7 @@ export function installTeamScheduler(ctx, config) {
                         task.assignee = ticket.previousAssignee;
                         task.attempt = ticket.previousAttempt;
                         task.attemptId = ticket.previousAttemptId;
+                        Object.assign(task, ticket.previousResult);
                         parkedAttempts.set(ticket.memberId, ticket.previousAttemptId);
                     }
                     else {

package/lib/snapshot.js

@@ -110,6 +110,7 @@ export async function assembleTeamSnapshot(ctx, stateRoot, workspace, state, opt
             ...task.kind === undefined ? {} : { kind: task.kind },
             ...task.round === undefined ? {} : { round: task.round },
             ...task.verdict === undefined ? {} : { verdict: task.verdict },
+            updatedAt: task.updatedAt,
         })),
         messageCount: captainInbox.length
             + members.reduce((count, member) => count + member.unread, 0),

package/lib/state.js

@@ -133,6 +133,15 @@ export function transitionError(current, next) {
     }
     return undefined;
 }
+/** Execution results belong to one attempt; a retry must produce its own evidence. */
+function clearAttemptResult(task) {
+    task.output = undefined;
+    task.verdict = undefined;
+    task.findings = undefined;
+    task.changedPaths = undefined;
+    task.acceptanceResults = undefined;
+    task.commandsRun = undefined;
+}
 /** Activate the task's current generation for one owner and return its capability id. */
 export function activateTaskAttempt(task, assignee) {
     const attemptId = randomUUID();
@@ -141,7 +150,7 @@ export function activateTaskAttempt(task, assignee) {
     task.attemptId = attemptId;
     task.handoffId = undefined;
     task.reassigning = false;
-    task.output = undefined;
+    clearAttemptResult(task);
     task.updatedAt = Date.now();
     return attemptId;
 }
@@ -172,7 +181,7 @@ export function invalidateTaskAttempt(task, nextAssignee, reassigning = false) {
     task.status = 'pending';
     task.assignee = nextAssignee;
     task.reassigning = reassigning;
-    task.output = undefined;
+    clearAttemptResult(task);
     task.updatedAt = Date.now();
 }
 /**
@@ -780,7 +789,10 @@ function isTeamMessage(value) {
         && (value['readAt'] === undefined || isFiniteNumber(value['readAt']))
         && (value['discardedAt'] === undefined || isFiniteNumber(value['discardedAt']))
         && (value['taskId'] === undefined || typeof value['taskId'] === 'string')
-        && (value['attemptId'] === undefined || typeof value['attemptId'] === 'string');
+        && (value['attemptId'] === undefined || typeof value['attemptId'] === 'string')
+        && (value['sourceTaskId'] === undefined || typeof value['sourceTaskId'] === 'string')
+        && (value['sourceAttemptId'] === undefined || typeof value['sourceAttemptId'] === 'string')
+        && (value['sourceTaskStatus'] === undefined || ['pending', 'claimed', 'in_progress', 'completed', 'failed', 'cancelled'].includes(value['sourceTaskStatus']));
 }
 /**
  * Remove a team's whole directory (members should be interrupted first).

package/lib/tools.js

@@ -12,11 +12,12 @@ import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { join } from 'node:path';
 import { appendTeamEvent, captainSessionOf } from "./events.js";
-import { amendTaskContract, acknowledgeMailbox, markMailboxDelivered, discardMailboxMessages, appendMailbox, archiveTeamDir, beginTaskAttempt, CAPTAIN_KEY, createMessage, createTeamDir, findTeamByCaptain, findTeamByParticipant, cancelUnfinishedTask, invalidateTaskAttempt, readUnreadMailbox, recordRetiredMemberIds, releaseMailboxDelivery, readTeam, sanitizeKey, transitionError, unsatisfiedDependencies, withTeamLock, writeTeam, validateCreateTask, evaluateQualityCompletion, planQualityFollowUp, resumeTeamState, buildCoverageMatrix, canDeclareDelivery, describeQualityLoop, sanitizeReviewAcceptance, sanitizeReviewObjective, normalizeBlankOptionalTaskFields, taskKindOf, } from "./state.js";
+import { amendTaskContract, acknowledgeMailbox, markMailboxDelivered, discardMailboxMessages, appendMailbox, archiveTeamDir, beginTaskAttempt, CAPTAIN_KEY, createMessage, createTeamDir, findTeamByCaptain, findTeamByParticipant, cancelUnfinishedTask, invalidateTaskAttempt, readUnreadMailbox, readMailbox, recordRetiredMemberIds, releaseMailboxDelivery, readTeam, sanitizeKey, transitionError, unsatisfiedDependencies, withTeamLock, writeTeam, validateCreateTask, evaluateQualityCompletion, planQualityFollowUp, resumeTeamState, buildCoverageMatrix, canDeclareDelivery, describeQualityLoop, sanitizeReviewAcceptance, sanitizeReviewObjective, normalizeBlankOptionalTaskFields, taskKindOf, } from "./state.js";
+import { appendTaskEvidence } from "./quality-gates.js";
 import { deliverToMember, installRetiredMemberGuard, installMemberSelectionRuntime, installMemberDelegationGuard, memberActivity, resolveMemberLlmSelection, spawnMember, steerCaptainReport, validateMemberLlmSelections, } from "./members.js";
 import { TERMINAL_TASK_STATUSES } from "./types.js";
 import { collectCompletedDependencyOutputs, formatDependencyOutputs, installTeamScheduler } from "./scheduler.js";
-import { installMailboxAdmission, mailboxPrompt } from "./mailbox.js";
+import { installMailboxAdmission, isCurrentMail, mailboxContent, mailboxPrompt, readCurrentMailbox } from "./mailbox.js";
 import { resolveTeamProfile } from "./profiles.js";
 export { steerCaptainReport } from "./members.js";
 /** The caller agent, or a loud failure for non-agent callers. */
@@ -510,7 +511,7 @@ export function registerAgentTeamsTools(ctx, config) {
         try {
             captain.followup(createUserMessage({
                 content: [{ type: 'text', text: stagedPlanFeedbackContext(prepared.teamName) }],
-                source: { kind: 'plugin', plugin: 'dsh-agent-teams' },
+                source: { kind: 'agent-teams' },
             }));
         }
         catch (error) {
@@ -548,7 +549,7 @@ export function registerAgentTeamsTools(ctx, config) {
         try {
             captain.inject(createUserMessage({
                 content: [{ type: 'text', text: stagedPlanDiscardContext(discarded.teamName) }],
-                source: { kind: 'plugin', plugin: 'dsh-agent-teams' },
+                source: { kind: 'agent-teams' },
             }));
         }
         catch (error) {
@@ -1468,7 +1469,7 @@ export function registerAgentTeamsTools(ctx, config) {
     }));
     ctx.tools.register(defineTool({
         name: 'agent_teams_update_task',
-        description: 'Update a task status/output. Members must supply the current attempt_id returned by claim_task; stale attempts are rejected after takeover/reassignment. Terminal results are immutable. A captain must use reassign_task(assignee="captain") before updating member-owned work.',
+        description: 'Update a task status/output. Members must supply the current attempt_id returned by claim_task; stale attempts are rejected after takeover/reassignment. Terminal results are immutable, but owners and the captain can append acceptanceResults/commandsRun/evidence_note as attributed supplemental evidence, without reclaiming or changing the verdict. A captain must use reassign_task(assignee="captain") before updating active member-owned work.',
         parameters: {
             task_id: { type: 'string', required: true, description: 'The task id to update.' },
             attempt_id: { type: 'string', description: 'Members must explicitly include the current attempt_id from their assignment/claim in EVERY update, including failed reviews with findings. If omitted, retry with the same current id; omission does not revoke the attempt.' },
@@ -1477,7 +1478,8 @@ export function registerAgentTeamsTools(ctx, config) {
                 enum: ['in_progress', 'completed', 'failed', 'cancelled'],
                 description: 'New status (in_progress, completed, failed, cancelled).',
             },
-            output: { type: 'string', description: 'Result summary; set when completing or failing.' },
+            output: { type: 'string', description: 'Original result summary; immutable after completion/failure.' },
+            evidence_note: { type: 'string', description: 'Append-only supplementary observation on a terminal task. Does not reopen work or change the original result.' },
             verdict: {
                 type: 'string',
                 enum: ['pass', 'needs_revision', 'reject'],
@@ -1543,11 +1545,13 @@ export function registerAgentTeamsTools(ctx, config) {
                     output: { type: 'string' },
                     attempt: { type: 'number', required: true },
                     attempt_id: { type: 'string' },
+                    evidence_count: { type: 'number' },
+                    follow_up: { type: 'string' },
                 },
             },
             render: (args, value) => [{
                     type: 'text',
-                    text: `Task ${value.task_id} attempt ${value.attempt} → ${value.status}${value.output !== undefined ? `\nOutput: ${value.output}` : ''}`,
+                    text: `Task ${value.task_id} attempt ${value.attempt} → ${value.status}${value.output !== undefined ? `\nOutput: ${value.output}` : ''}${value.evidence_count === undefined ? '' : `\nSupplemental evidence records: ${value.evidence_count}. Original result unchanged.`}${value.follow_up ? `\n${value.follow_up}` : ''}`,
                 }],
         },
         async execute(args, exec) {
@@ -1555,12 +1559,14 @@ export function registerAgentTeamsTools(ctx, config) {
             const workspace = workspaceOf(caller);
             const stateRoot = stateRootOf(workspace, config);
             const team = await requireParticipantTeam(workspace, config, caller);
+            let followUpMessage;
             const updated = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
                 const { team: fresh, identity } = await requireFreshParticipant(stateRoot, team.id, caller.id);
                 const task = requireTask(fresh, args.task_id);
                 if (identity.kind === 'captain'
                     && task.assignee !== undefined
                     && task.assignee !== CAPTAIN_KEY
+                    && !TERMINAL_TASK_STATUSES.includes(task.status)
                     && !(args.status === 'cancelled' && task.status === 'pending' && (task.attempt ?? 0) === 0 && task.reassigning !== true)) {
                     throw new Error(`task ${task.id} is owned by member "${task.assignee}"; call agent_teams_reassign_task with assignee="captain" before takeover`);
                 }
@@ -1576,12 +1582,14 @@ export function registerAgentTeamsTools(ctx, config) {
                     }
                 }
                 if (TERMINAL_TASK_STATUSES.includes(task.status)) {
-                    const sameStatus = args.status === undefined || args.status === task.status;
-                    const sameOutput = args.output === undefined || args.output === task.output;
-                    if (!sameStatus || !sameOutput) {
-                        throw new Error(`terminal task ${task.id} is immutable; use agent_teams_reassign_task to retry failed/cancelled work`);
-                    }
+                    const appended = appendTaskEvidence(task, {
+                        ...args, findings: parseFindings(args.findings), changedPaths: normalizeBlankOptionalTaskFields(args).changedPaths,
+                        acceptanceResults: parseAcceptanceResults(args.acceptanceResults), commandsRun: parseCommandResults(args.commandsRun),
+                    }, identity.name);
+                    if (appended)
+                        await writeTeam(stateRoot, fresh);
                     return {
+                        evidence_count: task.supplementalEvidence?.length ?? 0,
                         task_id: task.id,
                         status: task.status,
                         attempt: task.attempt ?? 0,
@@ -1589,6 +1597,8 @@ export function registerAgentTeamsTools(ctx, config) {
                         ...task.output !== undefined ? { output: task.output } : {},
                     };
                 }
+                if (args.evidence_note?.trim())
+                    throw new Error('evidence_note is for terminal tasks; record active work with output and structured evidence');
                 // Blank optional list entries (e.g. changedPaths:[""]) must not be
                 // persisted: hasValidQualityTaskFields rejects them on reload and
                 // would brick the whole team state (issue #105 class).
@@ -1626,13 +1636,22 @@ export function registerAgentTeamsTools(ctx, config) {
                 if (commandsRun !== undefined)
                     task.commandsRun = commandsRun;
                 task.updatedAt = Date.now();
+                const priorDependencies = new Map(fresh.tasks.map(item => [item.id, [...item.dependencies]]));
                 const followUp = (task.status === 'failed' && (task.verdict === 'needs_revision' || task.verdict === 'reject'))
                     ? applyQualityFollowUp(fresh, task)
                     : undefined;
+                let followUpSummary;
+                if ((followUp?.created.length ?? 0) > 0) {
+                    const rewired = fresh.tasks.filter(item => priorDependencies.has(item.id) && JSON.stringify(priorDependencies.get(item.id)) !== JSON.stringify(item.dependencies));
+                    followUpSummary = `Automatic quality follow-up for ${task.id}: ${followUp.created.map(item => `${item.id} (${item.kind}, owner=${item.assignee ?? 'unassigned'}, deps=${item.dependencies.join(',') || 'none'})`).join('; ')}.${rewired.length ? ` Updated dependencies: ${rewired.map(item => `${item.id} -> ${item.dependencies.join(',')}`).join('; ')}.` : ''} Use these tasks; do not create duplicate repair/review work.`;
+                    followUpMessage = createMessage(CAPTAIN_KEY, CAPTAIN_KEY, followUpSummary);
+                }
                 if (followUp?.escalated === true) {
                     await appendMailbox(stateRoot, fresh.id, CAPTAIN_KEY, createMessage(CAPTAIN_KEY, CAPTAIN_KEY, `Quality-gate loop escalated after ${task.id} (${task.kind ?? 'review'} verdict=${task.verdict}). Automatic repair/review stopped.`));
                 }
                 await writeTeam(stateRoot, fresh);
+                if (followUpMessage !== undefined)
+                    await appendMailbox(stateRoot, fresh.id, CAPTAIN_KEY, followUpMessage);
                 appendTeamEvent(ctx, captainSessionOf(ctx, fresh.captainSessionId, caller.session), 'agent-teams/task-updated', {
                     teamId: fresh.id,
                     taskId: task.id,
@@ -1654,6 +1673,7 @@ export function registerAgentTeamsTools(ctx, config) {
                     });
                 }
                 return {
+                    ...followUpSummary === undefined ? {} : { follow_up: followUpSummary },
                     task_id: task.id,
                     status: task.status,
                     attempt: task.attempt ?? 0,
@@ -1661,6 +1681,12 @@ export function registerAgentTeamsTools(ctx, config) {
                     ...task.output !== undefined ? { output: task.output } : {},
                 };
             });
+            if (followUpMessage !== undefined) {
+                const captain = ctx.agents.get(team.captainSessionId);
+                if (captain !== undefined && steerCaptainReport(captain, CAPTAIN_KEY, followUpMessage.content, mailboxPrompt(team.id, CAPTAIN_KEY, [followUpMessage]))) {
+                    await withTeamLock(teamLockKey(stateRoot, team.id), () => markMailboxDelivered(stateRoot, team.id, CAPTAIN_KEY, [followUpMessage.id]));
+                }
+            }
             await scheduler.kickTeam(workspace, team.id, team.captainSessionId === caller.id ? caller : undefined);
             return updated;
         },
@@ -1749,6 +1775,8 @@ export function registerAgentTeamsTools(ctx, config) {
         name: 'agent_teams_send_message',
         description: 'Send coordination or current-task guidance directly to the captain or a teammate. A running recipient receives it at the next model step; an idle recipient wakes. Messages are durably retained until read. Use task creation/reassignment for a new unit of work, not repeated status nudges.',
         parameters: {
+            source_task_id: { type: 'string', description: 'Sender task, NOT the recipient task. Members include it with source_attempt_id. Captains sending guidance normally omit both source fields.' },
+            source_attempt_id: { type: 'string', description: 'Sender execution capability paired with source_task_id. Stale reports are rejected. Omit for ordinary captain guidance.' },
             to: { type: 'string', required: true, description: 'Recipient: "captain" or a member name.' },
             content: { type: 'string', required: true, description: 'The message text.' },
             from: { type: 'string', description: 'Sender (defaults to the caller: the captain, or the calling member).' },
@@ -1761,7 +1789,7 @@ export function registerAgentTeamsTools(ctx, config) {
                     message_id: { type: 'string', required: true },
                     from: { type: 'string', required: true },
                     to: { type: 'string', required: true },
-                    delivered: { type: 'string', required: true, description: 'live (accepted by the live captain), wake (member recipient woken), or mailbox (durable inbox only).' },
+                    delivered: { type: 'string', required: true, description: 'live (accepted by the live captain), wake (member recipient woken), mailbox (durable inbox only), or duplicate (same message already retained).' },
                 },
             },
             render: (args, value) => [{
@@ -1783,8 +1811,26 @@ export function registerAgentTeamsTools(ctx, config) {
                 if (args.from !== undefined && args.from !== from) {
                     throw new Error(`agent_teams_send_message: "from" must be your own identity ("${from}"), not "${args.from}"`);
                 }
+                const sourceTaskId = args.source_task_id?.trim() || undefined;
+                const sourceAttemptId = args.source_attempt_id?.trim() || undefined;
+                if ((sourceTaskId === undefined) !== (sourceAttemptId === undefined))
+                    throw new Error('send_message requires source_task_id and source_attempt_id together');
+                const source = sourceTaskId === undefined
+                    ? identity.kind === 'member' ? memberOpenTask(fresh, identity.name) ?? fresh.tasks.filter(item => item.assignee === identity.name && item.attemptId !== undefined).sort((a, b) => b.updatedAt - a.updatedAt)[0] : undefined
+                    : requireTask(fresh, sourceTaskId);
+                if (sourceTaskId !== undefined && (source?.assignee !== identity.name || source.attemptId !== sourceAttemptId)) {
+                    throw new Error('stale or foreign source attempt; stop sending results from the revoked task');
+                }
+                const sourceFields = source?.attemptId === undefined ? {} : { sourceTaskId: source.id, sourceAttemptId: source.attemptId, sourceTaskStatus: source.status };
+                const owned = to === CAPTAIN_KEY ? undefined : memberOpenTask(fresh, requireMember(fresh, to).name);
+                const duplicate = (await readMailbox(stateRoot, fresh.id, to)).find(message => message.from === from
+                    && message.content === args.content && message.taskId === owned?.id && message.attemptId === owned?.attemptId
+                    && message.sourceTaskId === sourceFields.sourceTaskId && message.sourceAttemptId === sourceFields.sourceAttemptId && message.sourceTaskStatus === sourceFields.sourceTaskStatus
+                    && isCurrentMail(fresh, message) && (message.attemptId !== undefined || message.sourceAttemptId !== undefined || message.readAt === undefined));
+                if (duplicate !== undefined)
+                    return { kind: 'duplicate', message: duplicate, from };
                 if (to === CAPTAIN_KEY) {
-                    const message = { ...createMessage(from, CAPTAIN_KEY, args.content), deliveryClaimedAt: Date.now() };
+                    const message = { ...createMessage(from, CAPTAIN_KEY, args.content), ...sourceFields, deliveryClaimedAt: Date.now() };
                     await appendMailbox(stateRoot, fresh.id, CAPTAIN_KEY, message);
                     appendTeamEvent(ctx, captainSessionOf(ctx, fresh.captainSessionId, caller.session), 'agent-teams/message-sent', {
                         teamId: fresh.id,
@@ -1800,8 +1846,7 @@ export function registerAgentTeamsTools(ctx, config) {
                     throw new Error(`team "${fresh.name}" is halted; call agent_teams_resume before waking a member`);
                 }
                 const recipient = requireMember(fresh, to);
-                const owned = memberOpenTask(fresh, recipient.name);
-                const message = { ...createMessage(from, recipient.name, args.content), deliveryClaimedAt: Date.now(),
+                const message = { ...createMessage(from, recipient.name, args.content), ...sourceFields, deliveryClaimedAt: Date.now(),
                     ...owned?.attemptId === undefined ? {} : { taskId: owned.id, attemptId: owned.attemptId },
                 };
                 await appendMailbox(stateRoot, fresh.id, recipient.name, message);
@@ -1815,6 +1860,8 @@ export function registerAgentTeamsTools(ctx, config) {
                 });
                 return { kind: 'member', fresh, identity, message, from, recipient };
             });
+            if (prepared.kind === 'duplicate')
+                return { message_id: prepared.message.id, from: prepared.from, to: prepared.message.to, delivered: 'duplicate' };
             // Resolve the exact live captain only after releasing the state lock.
             // The plugin mailbox is already durable if live delivery cannot proceed.
             const captain = ctx.agents.get(prepared.fresh.captainSessionId);
@@ -1893,6 +1940,7 @@ export function registerAgentTeamsTools(ctx, config) {
                 kind: taskKindOf(task),
                 ...task.round === undefined ? {} : { round: task.round },
                 ...task.verdict === undefined ? {} : { verdict: task.verdict },
+                ...task.supplementalEvidence === undefined ? {} : { supplemental_evidence: JSON.stringify(task.supplementalEvidence) },
                 findings_open: (task.findings ?? []).filter((finding) => finding.resolved !== true).length,
                 ...task.profileSeedId === undefined ? {} : { seed_id: task.profileSeedId },
                 ...task.output !== undefined ? { output: task.output } : {},
@@ -1906,15 +1954,15 @@ export function registerAgentTeamsTools(ctx, config) {
                 }
             };
             const captainInbox = identity.kind === 'captain'
-                ? await readUnreadMailbox(stateRoot, team.id, CAPTAIN_KEY, reportMalformed(CAPTAIN_KEY))
+                ? await readCurrentMailbox(stateRoot, team.id, CAPTAIN_KEY, reportMalformed(CAPTAIN_KEY))
                 : [];
-            const ownInbox = identity.kind === 'member' ? (await readUnreadMailbox(stateRoot, team.id, identity.name)).slice(0, 10) : [];
+            const ownInbox = identity.kind === 'member' ? (await readCurrentMailbox(stateRoot, team.id, identity.name)).slice(0, 10) : [];
             const memberInboxes = {};
             const visibleMembers = identity.kind === 'captain'
                 ? members
                 : members.filter((member) => member.name === identity.name);
             for (const member of visibleMembers) {
-                const messages = await readUnreadMailbox(stateRoot, team.id, member.name, reportMalformed(member.name));
+                const messages = await readCurrentMailbox(stateRoot, team.id, member.name, reportMalformed(member.name));
                 if (messages.length > 0) {
                     memberInboxes[member.name] = {
                         count: messages.length,
@@ -1957,10 +2005,10 @@ export function registerAgentTeamsTools(ctx, config) {
                 tasks,
                 captain_inbox: captainInbox.slice(0, 10).map((message) => ({
                     from: message.from,
-                    content: message.content,
+                    content: mailboxContent(message),
                     ts: message.ts,
                 })),
-                member_inbox: ownInbox.map(message => ({ from: message.from, content: message.content, ts: message.ts })),
+                member_inbox: ownInbox.map(message => ({ from: message.from, content: mailboxContent(message), ts: message.ts })),
                 member_inboxes: memberInboxes,
                 mailbox_warnings: mailboxWarnings,
                 mailbox_warning_count: mailboxWarningCount,
@@ -2326,12 +2374,13 @@ function renderStatus(value) {
         ...team.tasks.map((task) => {
             const deps = task.dependencies.length > 0 ? ` (deps: ${task.dependencies.join(',')})` : '';
             const output = task.output !== undefined ? `\n      output: ${task.output.slice(0, 300)}` : '';
+            const evidence = task.supplemental_evidence ? `\n      Supplemental observations (original verdict unchanged): ${task.supplemental_evidence}` : '';
             const handoff = task.reassigning ? ' (reassigning)' : '';
             const seed = task.seed_id === undefined || task.seed_id === '' ? '' : ` seed ${task.seed_id}`;
             const kind = task.kind ? ` ${task.kind}` : '';
             const round = task.round === undefined ? '' : ` r${task.round}`;
             const verdict = task.verdict === undefined ? '' : ` verdict ${task.verdict}`;
-            return `  - ${task.id} [${task.status}]${kind}${round}${verdict} attempt ${task.attempt}${handoff}${seed} ${task.subject} → ${task.assignee || 'unassigned'}${deps}${output}`;
+            return `  - ${task.id} [${task.status}]${kind}${round}${verdict} attempt ${task.attempt}${handoff}${seed} ${task.subject} → ${task.assignee || 'unassigned'}${deps}${output}${evidence}`;
         }),
         ...team.coverage === undefined || team.coverage.length === 0 ? [] : [
             'Coverage:',

package/lib/types/capabilities.d.ts

@@ -1,4 +1,3 @@
-/** Stable, agent-scoped presentation. Business authority stays in the tools. */
 import type { Context } from '@deepseek-ai/cordis';
 import type { Agent } from '@deepseek-ai/dsh-agent';
 export declare const TEAM_ACTIVATION_PROMPT = "AgentTeams (Agent Teams) provides multi-agent team collaboration. Apply these rules when the user requests it (including /agent-teams) or when continuing an existing team. Mentioning, quoting, discussing, or declining AgentTeams alone is not a request to start work.";