@nanmicoder/dsh-agent-teams 0.1.17 → 0.1.19

package/lib/quality-gates.js

@@ -3,7 +3,7 @@
  * coverage, and resume. Tools and persistence call these; they do not I/O.
  * @module dsh-agent-teams/quality-gates
  */
-import { FINDING_SEVERITIES, REVIEW_VERDICTS, TASK_KINDS, } from "./types.js";
+import { FINDING_SEVERITIES, REVIEW_VERDICTS, TASK_KINDS, TERMINAL_TASK_STATUSES, } from "./types.js";
 const QUALITY_KINDS = [
     'requirements',
     'implementation',
@@ -269,13 +269,14 @@ export function validateCreateTask(team, input) {
     if (kind === 'implementation') {
         const requirements = team.tasks.filter((item) => taskKindOf(item) === 'requirements');
         const passed = requirements.some((item) => item.status === 'completed' && item.verdict === 'pass');
-        const stagedBehindRequirements = team.phase === 'staged' && requirements.some((item) => (dependencyClosureContains(team.tasks, dependencies, item.id)));
-        if (requirements.length > 0 && !passed && !stagedBehindRequirements) {
+        const behindRequirements = requirements.some((item) => (dependencyClosureContains(team.tasks, dependencies, item.id)));
+        // Planning an implementation is safe in either approval mode when its
+        // dependency chain fences execution behind requirements. Scheduling and
+        // claiming still wait for successful dependency completion.
+        if (requirements.length > 0 && !passed && !behindRequirements) {
             return {
                 ok: false,
-                error: team.phase === 'staged'
-                    ? 'implementation must depend on the staged requirements task; it will run only after requirements passes'
-                    : 'implementation is blocked until a requirements task completes with verdict=pass',
+                error: 'implementation must depend on a requirements task until requirements completes with verdict=pass',
             };
         }
     }
@@ -404,6 +405,140 @@ function unresolvedFindings(task) {
 function findingKey(ids) {
     return [...ids].sort().join(',');
 }
+/**
+ * Path-like tokens worth considering as repair-scope candidates. Two shapes:
+ * slash paths (`src/parser.ts`, `docs/guide.md`) and bare filenames with a
+ * known code/doc extension (`README.md`, `wc.js`). An optional `:line`
+ * suffix is tolerated and stripped. The extension allowlist keeps version
+ * tokens (`v0.1.17`), hex hashes, and prose out of the derived scope.
+ */
+const REPAIR_SCOPE_PATH_PATTERN = /(?:[A-Za-z0-9_.\-]+(?:\/[A-Za-z0-9_.\-]+)+|[\w.\-]+\.(?:tsx?|jsx?|mjs|cjs|json|md|txt|ya?ml|py|rs|go|java|html?|css|scss|sh|ps1|toml|xml|sql))(?::\d+)?/gu;
+const REPAIR_SCOPE_LINE_SUFFIX = /:\d+$/;
+/**
+ * Derive the repair round's inScope from the findings that caused it.
+ *
+ * `finding.file` records where the problem was OBSERVED, but the fix often
+ * targets a different file named in `requiredFix` (docs vs sample data,
+ * config vs code). Deriving the scope from both keeps the auto-generated
+ * repair contract satisfiable; deriving from `file` alone can produce a
+ * contract where the acceptance ("edit README.md") names a path the scope
+ * forbids, so no honest completion exists and the repair dead-locks.
+ *
+ * Absolute and otherwise illegal paths are dropped (they can never match
+ * workspace-relative scope patterns anyway); when nothing legal remains,
+ * the source task's own inScope is kept as the fallback. Over-inclusion is
+ * accepted: inScope is an audit upper bound, and the requiredFix text still
+ * tells the implementer what to touch.
+ *
+ * Keep all derived paths until the generator resolves inherited exclusions;
+ * filtering first would silently discard a required fix target.
+ */
+export function repairScopeFromFindings(findings, fallback) {
+    const derived = [];
+    const push = (raw) => {
+        const normalized = normalizeWorkspacePath(raw.replace(REPAIR_SCOPE_LINE_SUFFIX, ''));
+        if (normalized === undefined || derived.includes(normalized))
+            return;
+        derived.push(normalized);
+    };
+    for (const finding of findings) {
+        if (nonemptyString(finding.file))
+            push(finding.file);
+        for (const match of finding.requiredFix.matchAll(REPAIR_SCOPE_PATH_PATTERN))
+            push(match[0]);
+    }
+    return derived.length > 0 ? derived : fallback === undefined ? undefined : [...new Set(fallback)];
+}
+const AMENDABLE_CONTRACT_FIELDS = ['objective', 'acceptance', 'verify', 'inScope', 'outOfScope'];
+/**
+ * Controlled contract amendment (the pure rule; tooling keeps it
+ * captain-only). When a quality contract is wrong — a verify command that
+ * cannot pass, an inScope that forbids the file the objective names — the
+ * worker has no honest completion and either dead-locks or games the gate.
+ * Instead the captain may fix the contract mid-flight: every amendment is
+ * recorded on the task as a {@link TaskRevision} (previous values + reason),
+ * and once a review/requirements task has passed judgment on this task the
+ * contract is frozen. Amendments replace whole fields (lists are full
+ * replacements, not deltas); the implementer re-reads the amended contract
+ * before its next quality gate. Completion gates need no special casing:
+ * they read the task's current fields, so they naturally evaluate the
+ * amended contract.
+ */
+export function amendTaskContract(team, task, input, by, reason) {
+    if (!nonemptyString(by))
+        return { ok: false, error: 'contract amendment requires a non-empty author identity' };
+    if (!nonemptyString(reason))
+        return { ok: false, error: 'contract amendment requires a non-empty reason' };
+    if (TERMINAL_TASK_STATUSES.includes(task.status)) {
+        return { ok: false, error: `task ${task.id} is ${task.status}; terminal contracts are immutable` };
+    }
+    if (taskKindOf(task) === 'work') {
+        return { ok: false, error: `task ${task.id} has kind=work and no contract to amend` };
+    }
+    if (!AMENDABLE_CONTRACT_FIELDS.some((field) => input[field] !== undefined)) {
+        return { ok: false, error: `amendment requires at least one of: ${AMENDABLE_CONTRACT_FIELDS.join(', ')}` };
+    }
+    const next = {};
+    const previous = {};
+    if (input.objective !== undefined) {
+        if (!nonemptyString(input.objective)) {
+            return { ok: false, error: 'amended objective must be a non-empty string' };
+        }
+        next['objective'] = input.objective;
+        previous['objective'] = task.objective;
+    }
+    for (const field of ['acceptance', 'verify']) {
+        const value = input[field];
+        if (value === undefined)
+            continue;
+        if (!nonemptyStringList(value)) {
+            return { ok: false, error: `amended ${field} must be a non-empty list of non-empty strings` };
+        }
+        next[field] = value;
+        previous[field] = task[field];
+    }
+    for (const field of ['inScope', 'outOfScope']) {
+        const value = input[field];
+        if (value === undefined)
+            continue;
+        if (!nonemptyStringList(value)) {
+            return { ok: false, error: `amended ${field} must be a non-empty list of non-empty strings` };
+        }
+        for (const entry of value) {
+            if (normalizeWorkspacePath(entry) === undefined) {
+                return {
+                    ok: false,
+                    error: `amended ${field} entry "${entry}" is not a workspace-relative path (absolute paths and ".." can never match scope patterns)`,
+                };
+            }
+        }
+        next[field] = value;
+        previous[field] = task[field];
+    }
+    const reviewPassed = team.tasks.some((item) => ((taskKindOf(item) === 'review' || taskKindOf(item) === 'requirements')
+        && item.reviewedTaskId === task.id
+        && item.verdict === 'pass'));
+    if (reviewPassed) {
+        return { ok: false, error: `task ${task.id} already passed review; its contract is frozen` };
+    }
+    const revision = {
+        at: Date.now(),
+        by,
+        reason,
+        fields: Object.keys(next),
+        previous,
+    };
+    return {
+        ok: true,
+        revision,
+        task: {
+            ...task,
+            ...next,
+            revisions: [...(task.revisions ?? []), revision],
+            updatedAt: Date.now(),
+        },
+    };
+}
 const CAPTAIN_ASSIGNEE = 'captain';
 const OPEN_FOLLOW_UP_STATUSES = ['pending', 'claimed', 'in_progress'];
 function schedulableAssignee(preferred, team, forbidden) {
@@ -429,6 +564,13 @@ function hasOpenFollowUp(team, sourceTaskId, findingIds) {
         && findingKey(item.sourceFindingIds ?? []) === key
         && OPEN_FOLLOW_UP_STATUSES.includes(item.status)));
 }
+/** Drop previous-round exclusions that intersect this generated repair's scope. */
+function withoutScopeConflicts(outOfScope, inScope) {
+    if (outOfScope === undefined)
+        return undefined;
+    const conflicting = new Set(inScopeOverlap(outOfScope, inScope ?? []));
+    return outOfScope.filter((pattern) => !conflicting.has(pattern));
+}
 export function planQualityFollowUp(team, closed) {
     const empty = { created: [], tasks: [] };
     const kind = taskKindOf(closed);
@@ -467,7 +609,9 @@ export function planQualityFollowUp(team, closed) {
     if (countRepairAttempts(team, sourceId, findingIds) >= policy.maxRepairAttempts) {
         return { ...empty, escalated: true, status: 'escalated' };
     }
-    const files = findings.map((finding) => finding.file).filter((file) => nonemptyString(file));
+    // inScope is derived from the findings below: the observed file plus any
+    // workspace-relative paths referenced by the requiredFix instructions.
+    const repairScope = repairScopeFromFindings(findings, source?.inScope);
     const implementer = schedulableAssignee(source?.assignee, team);
     const repair = {
         id: `repair-round-${nextRound}`,
@@ -477,8 +621,8 @@ export function planQualityFollowUp(team, closed) {
         dependencies: [sourceId],
         round: nextRound,
         objective: source?.objective ?? closed.objective ?? `Fix findings from ${sourceId}`,
-        inScope: files.length > 0 ? files : source?.inScope,
-        outOfScope: source?.outOfScope,
+        inScope: repairScope,
+        outOfScope: withoutScopeConflicts(source?.outOfScope, repairScope),
         verify: source?.verify,
         acceptance: findings.map((finding) => finding.requiredFix),
         sourceTaskId: sourceId,
@@ -515,6 +659,20 @@ export function buildCoverageMatrix(goalItems, tasks) {
 }
 export function canDeclareDelivery(team) {
     const blockers = [];
+    if (team.phase === 'staged')
+        blockers.push('team plan is awaiting approval');
+    if (team.halted === true)
+        blockers.push('team is halted');
+    if (team.escalated === true)
+        blockers.push('team requires escalation resolution');
+    if (team.tasks.length === 0)
+        blockers.push('team has no completed work');
+    for (const item of team.tasks.filter(item => !isQualityKind(taskKindOf(item)))) {
+        if (item.status !== 'completed' && item.status !== 'cancelled')
+            blockers.push(`${item.id} (${taskKindOf(item)}) is not completed`);
+    }
+    if (team.tasks.length > 0 && team.tasks.every(item => item.status === 'cancelled'))
+        blockers.push('all work was cancelled');
     const quality = team.tasks.filter((item) => isQualityKind(taskKindOf(item)));
     const implementations = quality.filter((item) => taskKindOf(item) === 'implementation' || taskKindOf(item) === 'repair');
     const reviews = quality.filter((item) => taskKindOf(item) === 'review');
@@ -600,6 +758,15 @@ export function isCommandResult(value) {
         && (value['exitCode'] === undefined || (Number.isSafeInteger(value['exitCode'])))
         && (value['evidence'] === undefined || typeof value['evidence'] === 'string');
 }
+export function isTaskRevision(value) {
+    if (!isRecord(value))
+        return false;
+    return Number.isSafeInteger(value['at'])
+        && nonemptyString(value['by'])
+        && nonemptyString(value['reason'])
+        && nonemptyStringList(value['fields'])
+        && isRecord(value['previous']);
+}
 // Optional fields whose persisted values must be non-empty when present
 // (mirrors the checks in hasValidQualityTaskFields). Some models materialize
 // optional tool parameters as "" instead of omitting them (e.g. GPT-5.6
@@ -683,6 +850,10 @@ export function hasValidQualityTaskFields(value) {
         if (!Array.isArray(value['commandsRun']) || !value['commandsRun'].every(isCommandResult))
             return false;
     }
+    if (value['revisions'] !== undefined) {
+        if (!Array.isArray(value['revisions']) || !value['revisions'].every(isTaskRevision))
+            return false;
+    }
     return true;
 }
 function isRecord(value) {
@@ -796,7 +967,7 @@ export function describeQualityLoop(team) {
             halted: false,
             escalated: team.escalated === true,
             deliverable: true,
-            summary: 'All required quality gates passed. The captain may report delivery.',
+            summary: 'All required work and quality gates passed. The captain may report delivery.',
         };
     }
     if (team.escalated === true) {

package/lib/scheduler.js

@@ -13,7 +13,8 @@
  */
 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 { isCurrentMail, mailboxPrompt } from "./mailbox.js";
+import { markMailboxDelivered, discardMailboxMessages, beginTaskAttempt, CAPTAIN_KEY, claimMailboxDelivery, findTeamByParticipant, invalidateTaskAttempt, readTeam, readPendingMailbox, releaseMailboxDelivery, unsatisfiedDependencies, withTeamLock, writeTeam, } from "./state.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. */
@@ -103,6 +104,8 @@ function liveMember(ctx, member) {
     return ctx.agents.get(member.id);
 }
 function isMemberAvailable(ctx, member) {
+    if (member.stopping === true)
+        return false;
     const live = liveMember(ctx, member);
     return live === undefined || live.status === 'idle';
 }
@@ -168,13 +171,6 @@ When finishing: use status=completed only when the task's success criteria are s
 
 State policy: ${stateDir}/${teamId}/ is read-only diagnostics; mutate team state only through agent_teams_* tools.`;
 }
-function fallbackMailboxPrompt(messages) {
-    return [
-        'AgentTeams 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 agent_teams_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();
@@ -227,16 +223,28 @@ export function installTeamScheduler(ctx, config) {
                 if (captain === undefined)
                     return;
                 let member = team.members.find(candidate => candidate.name === memberName && candidate.status !== 'removed');
-                if (member === undefined || member.id === '' || !isMemberAvailable(ctx, member))
+                if (member === undefined || !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);
+                const unread = await withTeamLock(teamLockKey(stateRoot, team.id), async () => {
+                    const fresh = await readTeam(stateRoot, team.id);
+                    if (fresh === undefined)
+                        return [];
+                    const pending = await readPendingMailbox(stateRoot, fresh.id, member.name);
+                    await discardMailboxMessages(stateRoot, fresh.id, member.name, pending.filter(message => !isCurrentMail(fresh, message)).map(message => message.id));
+                    const current = pending.filter(message => isCurrentMail(fresh, message));
+                    await claimMailboxDelivery(stateRoot, fresh.id, member.name, current.map(message => message.id));
+                    return current;
+                });
                 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);
+                    const prompt = mailboxPrompt(team.id, member.name, unread);
+                    const signal = new AbortController().signal;
+                    const accepted = config.dispatch === undefined
+                        ? await deliverToMember(ctx, captain, member.id, prompt, signal, 'steer')
+                        : await config.dispatch(captain, team.id, member.name, prompt, signal, 'steer');
                     if (accepted) {
-                        await withTeamLock(teamLockKey(stateRoot, team.id), () => (acknowledgeMailbox(stateRoot, team.id, member.name, unread.map(message => message.id))));
+                        await withTeamLock(teamLockKey(stateRoot, team.id), () => (markMailboxDelivered(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))));
@@ -248,7 +256,7 @@ export function installTeamScheduler(ctx, config) {
                     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))
+                    if (currentMember === undefined || !isMemberAvailable(ctx, currentMember))
                         return undefined;
                     const owned = ownedOpenTask(fresh.tasks, currentMember.name);
                     // An idle edge observed by this scheduler parks the exact open
@@ -318,7 +326,11 @@ export function installTeamScheduler(ctx, config) {
                 });
                 if (ticket === undefined)
                     return;
-                const accepted = await deliverToMember(ctx, captain, ticket.memberId, assignmentPrompt(ticket, config.stateDir, team.id), new AbortController().signal);
+                const prompt = assignmentPrompt(ticket, config.stateDir, team.id);
+                const signal = new AbortController().signal;
+                const accepted = config.dispatch === undefined
+                    ? await deliverToMember(ctx, captain, ticket.memberId, prompt, signal)
+                    : await config.dispatch(captain, team.id, ticket.memberName, prompt, signal, 'queue', ticket.attemptId);
                 if (accepted)
                     return;
                 // Roll back only our exact failed dispatch. A concurrent captain

package/lib/snapshot.js

@@ -76,7 +76,7 @@ export async function assembleTeamSnapshot(ctx, stateRoot, workspace, state, opt
                         : activity.get(member.id) === 'idle' || activity.get(member.id) === 'ready'
                             ? 'idle'
                             : 'unknown')
-                    : state.phase === 'staged' ? 'idle' : 'unknown',
+                    : 'idle',
             progress: owned.length === 0 ? 0 : Math.round((done / owned.length) * 100),
             done,
             total: owned.length,

package/lib/state.js

@@ -18,7 +18,7 @@ import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promise
 import { join } from 'node:path';
 import { TERMINAL_TASK_STATUSES } from "./types.js";
 import { hasValidQualityTaskFields, isReviewPolicy, normalizeBlankOptionalTaskFields } from "./quality-gates.js";
-export { buildCoverageMatrix, canDeclareDelivery, classifyChangedPath, collectChangedPaths, defaultQualityDeliveryGraph, describeQualityLoop, evaluateQualityCompletion, hasValidQualityTaskFields, isQualityKind, normalizeBlankOptionalTaskFields, pathMatchesScope, planQualityFollowUp, qualityPlanningPrompt, resumeTeamState, sanitizeReviewAcceptance, sanitizeReviewObjective, taskKindOf, validateCreateTask, } from "./quality-gates.js";
+export { amendTaskContract, buildCoverageMatrix, canDeclareDelivery, classifyChangedPath, collectChangedPaths, defaultQualityDeliveryGraph, describeQualityLoop, evaluateQualityCompletion, hasValidQualityTaskFields, isQualityKind, isTaskRevision, normalizeBlankOptionalTaskFields, pathMatchesScope, planQualityFollowUp, qualityPlanningPrompt, resumeTeamState, sanitizeReviewAcceptance, sanitizeReviewObjective, taskKindOf, validateCreateTask, } from "./quality-gates.js";
 /** Mailbox key of the captain. */
 export const CAPTAIN_KEY = 'captain';
 /** A crashed live-delivery attempt becomes retryable after this interval. */
@@ -419,9 +419,14 @@ export async function readMailbox(stateRoot, teamId, agentKey, onMalformedLine)
 }
 /** Read only messages that have not been acknowledged by their recipient. */
 export async function readUnreadMailbox(stateRoot, teamId, agentKey, onMalformedLine) {
-    const now = Date.now();
     return (await readMailbox(stateRoot, teamId, agentKey, onMalformedLine))
-        .filter(message => message.readAt === undefined
+        .filter(message => message.readAt === undefined && message.discardedAt === undefined);
+}
+/** Pending delivery is distinct from delivered-but-not-yet-read input. */
+export async function readPendingMailbox(stateRoot, teamId, agentKey) {
+    const now = Date.now();
+    return (await readUnreadMailbox(stateRoot, teamId, agentKey))
+        .filter(message => message.deliveredAt === undefined
         && (message.deliveryClaimedAt === undefined
             || now - message.deliveryClaimedAt >= MAILBOX_DELIVERY_LEASE_MS));
 }
@@ -485,6 +490,16 @@ export async function acknowledgeMailbox(stateRoot, teamId, agentKey, messageIds
         };
     });
 }
+/** Acceptance by Harness is not evidence that a model step consumed input. */
+export async function markMailboxDelivered(stateRoot, teamId, agentKey, ids) {
+    await mutateMailbox(stateRoot, teamId, agentKey, ids, (message) => {
+        const { deliveryClaimedAt: _claimed, ...rest } = message;
+        return { ...rest, deliveredAt: message.deliveredAt ?? Date.now() };
+    });
+}
+export async function discardMailboxMessages(stateRoot, teamId, agentKey, ids) {
+    await mutateMailbox(stateRoot, teamId, agentKey, ids, message => ({ ...message, discardedAt: message.discardedAt ?? Date.now() }));
+}
 /** Remove the optional UTF-8 BOM some editors prepend to JSON text. */
 function stripLeadingBom(value) {
     return value.charCodeAt(0) === 0xFEFF ? value.slice(1) : value;
@@ -591,11 +606,13 @@ function isTeamMember(value) {
         && typeof value['name'] === 'string'
         && value['name'].trim() !== ''
         && isOptionalString(value['role'])
+        && (value['stopping'] === undefined || typeof value['stopping'] === 'boolean')
         && isOptionalString(value['provider'])
         && isOptionalString(value['model'])
         && isOptionalString(value['reasoningEffort'])
         && isOptionalString(value['activeProvider'])
         && isOptionalString(value['activeModel'])
+        && isOptionalString(value['spawnError'])
         && (value['executionPrompt'] === undefined || typeof value['executionPrompt'] === 'string')
         && (value['fallback'] === undefined || (isRecord(value['fallback']) && typeof value['fallback']['provider'] === 'string' && typeof value['fallback']['model'] === 'string'))
         && (value['fallbackActive'] === undefined || typeof value['fallbackActive'] === 'boolean')
@@ -691,6 +708,7 @@ export function isTeamTask(value) {
             || (Number.isSafeInteger(value['attempt']) && value['attempt'] >= 0))
         && isOptionalString(value['attemptId'])
         && isOptionalString(value['handoffId'])
+        && isOptionalString(value['handoffFromMemberId'])
         && (value['reassigning'] === undefined || typeof value['reassigning'] === 'boolean')
         && isFiniteNumber(value['createdAt'])
         && isFiniteNumber(value['updatedAt'])
@@ -729,10 +747,9 @@ function isTeamState(value, expectedId) {
     const tasks = value['tasks'];
     const memberIds = new Set();
     const memberKeys = new Set();
-    const staged = value['phase'] === 'staged';
     for (const member of members) {
         const key = sanitizeKey(member.name);
-        if ((!staged && member.id === '') || key === CAPTAIN_KEY || memberKeys.has(key))
+        if (key === CAPTAIN_KEY || memberKeys.has(key))
             return false;
         if (member.id !== '') {
             if (memberIds.has(member.id))
@@ -760,7 +777,10 @@ function isTeamMessage(value) {
         && isFiniteNumber(value['ts'])
         && (value['deliveryClaimedAt'] === undefined || isFiniteNumber(value['deliveryClaimedAt']))
         && (value['deliveredAt'] === undefined || isFiniteNumber(value['deliveredAt']))
-        && (value['readAt'] === undefined || isFiniteNumber(value['readAt']));
+        && (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');
 }
 /**
  * Remove a team's whole directory (members should be interrupted first).

package/lib/tool-names.js

@@ -3,6 +3,7 @@ export const TEAM_TOOL_NAMES = [
     'agent_teams_create', 'agent_teams_approve', 'agent_teams_edit_plan',
     'agent_teams_add_member', 'agent_teams_remove_member', 'agent_teams_create_task',
     'agent_teams_reassign_task', 'agent_teams_claim_task', 'agent_teams_update_task',
+    'agent_teams_amend_task',
     'agent_teams_send_message', 'agent_teams_status', 'agent_teams_resume', 'agent_teams_delete',
 ];
 export const MEMBER_TOOL_NAMES = [