@wrongstack/core 0.308.0 → 0.308.2

package/dist/coordination/agents/index.js

@@ -1378,7 +1378,7 @@ var RUNTIME_CAPABILITY_MANIFEST = [
     id: "execution.shell",
     pack: "development",
     exposure: "direct",
-    tools: ["bash", "exec", "language", "language_info", "language_package"]
+    tools: ["bash", "exec", "pwsh", "language", "language_info", "language_package"]
   },
   {
     id: "verification.run",
@@ -3337,7 +3337,7 @@ ${identity}`);
         splitLearnedEntries(rawLearned)
       );
       const rawBytes = Buffer.byteLength(rawLearned, "utf8");
-      const freshEntries = meta === void 0 ? [] : rawEntries.filter((entry) => entry.capturedAt > meta.consolidatedAt);
+      const freshEntries = meta === void 0 ? [] : rawEntries.filter((entry) => entry.capturedAt >= meta.consolidatedAt);
       const stale = meta === void 0 || freshEntries.length > 0 || rawEntries.length > meta.sourceEntryCount || rawBytes > meta.sourceBytes;
       if (!stale) {
         learnedContent = consolidated;
@@ -4934,7 +4934,7 @@ var VERIFY_AGENTS = [
       id: "bug-hunter",
       name: "Bug Hunter",
       role: "bug-hunter",
-      tools: [...TOOLS.inspect],
+      tools: [...TOOLS.inspect, "dead-code-scan"],
       prompt: agentPrompt("bug-hunter")
     },
     budget: HEAVY_BUDGET,
@@ -5024,7 +5024,7 @@ var REVIEW_AGENTS = [
       id: "code-reviewer",
       name: "Code Reviewer",
       role: "code-reviewer",
-      tools: [...TOOLS.inspect, "git"],
+      tools: [...TOOLS.inspect, "git", "codebase-impact-analysis", "codebase-invariant-check"],
       prompt: agentPrompt("code-reviewer")
     },
     budget: MEDIUM_BUDGET,

package/dist/coordination/index.d.ts

@@ -69,6 +69,7 @@ TIMEOUT_PREEMPT_FRACTION, } from './subagent-budget.js';
 export { assignNickname } from './subagent-nicknames.js';
 export { formatSubagentStructuredReport, MAX_SUBAGENT_STRUCTURED_REPORT_CHARS, makeSubagentResultTool, normalizeSubagentStructuredReport, readSubagentStructuredReport, SUBAGENT_STRUCTURED_REPORT_META_KEY, } from './subagent-result-tool.js';
 export { startTechStackConsumer, type TechStackConsumerOptions, } from './techstack-mailbox-consumer.js';
+export { composeBoundedTaskDescription, type TaskBoundary, parseTaskBoundary, renderTaskBoundaryBlock, taskBoundarySchemaProperties, } from './task-boundary.js';
 export { type FleetWorktreePolicy, resolveSubagentWorktreeDecision, subagentNeedsWorktree, WorktreeIntegrationError, type WorktreeIsolationDecision, type WorktreeTaskRunnerOptions, type WorktreeTaskStateUpdate, wrapSubagentRunnerWithWorktrees, } from './worktree-task-runner.js';
 export { collabInjectMiddleware, collabPauseMiddleware, } from '../middleware/collab-pause.js';
 export { AdaptiveConcurrencyController, type AdaptiveConcurrencyState, } from './adaptive-concurrency.js';

package/dist/coordination/index.js

@@ -2643,7 +2643,7 @@ var RUNTIME_CAPABILITY_MANIFEST = [
     id: "execution.shell",
     pack: "development",
     exposure: "direct",
-    tools: ["bash", "exec", "language", "language_info", "language_package"]
+    tools: ["bash", "exec", "pwsh", "language", "language_info", "language_package"]
   },
   {
     id: "verification.run",
@@ -4435,7 +4435,7 @@ ${identity}`);
         splitLearnedEntries(rawLearned)
       );
       const rawBytes = Buffer.byteLength(rawLearned, "utf8");
-      const freshEntries = meta === void 0 ? [] : rawEntries.filter((entry) => entry.capturedAt > meta.consolidatedAt);
+      const freshEntries = meta === void 0 ? [] : rawEntries.filter((entry) => entry.capturedAt >= meta.consolidatedAt);
       const stale = meta === void 0 || freshEntries.length > 0 || rawEntries.length > meta.sourceEntryCount || rawBytes > meta.sourceBytes;
       if (!stale) {
         learnedContent = consolidated;
@@ -6032,7 +6032,7 @@ var VERIFY_AGENTS = [
       id: "bug-hunter",
       name: "Bug Hunter",
       role: "bug-hunter",
-      tools: [...TOOLS.inspect],
+      tools: [...TOOLS.inspect, "dead-code-scan"],
       prompt: agentPrompt("bug-hunter")
     },
     budget: HEAVY_BUDGET,
@@ -6122,7 +6122,7 @@ var REVIEW_AGENTS = [
       id: "code-reviewer",
       name: "Code Reviewer",
       role: "code-reviewer",
-      tools: [...TOOLS.inspect, "git"],
+      tools: [...TOOLS.inspect, "git", "codebase-impact-analysis", "codebase-invariant-check"],
       prompt: agentPrompt("code-reviewer")
     },
     budget: MEDIUM_BUDGET,
@@ -10481,6 +10481,80 @@ var FLEET_ROSTER_WITHACP = {
   ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
 };
 
+// src/coordination/task-boundary.ts
+var PLACEHOLDER_VALUES = /* @__PURE__ */ new Set([
+  "n/a",
+  "na",
+  "none",
+  "nothing",
+  "tbd",
+  "todo",
+  "unknown",
+  "unspecified",
+  "-",
+  "\u2014",
+  ".",
+  "as above",
+  "same as above",
+  "see above",
+  "see task",
+  "same as task"
+]);
+var isPlaceholder = (value) => PLACEHOLDER_VALUES.has(value.trim().toLowerCase());
+var MIN_SCOPE_CHARS = 8;
+var MIN_NON_GOAL_CHARS = 3;
+function parseTaskBoundary(raw) {
+  const scope = typeof raw.scope === "string" ? raw.scope.trim() : "";
+  if (scope.length < MIN_SCOPE_CHARS) {
+    return {
+      ok: false,
+      error: `\`scope\` is missing or too vague \u2014 state in one concrete sentence what work this task covers (files, components, or commands in-bounds).`,
+      hint: 'Example \u2014 scope: "Audit packages/core/src/parser/*.ts for unhandled token errors and report findings."'
+    };
+  }
+  if (!Array.isArray(raw.outOfScope) || raw.outOfScope.length === 0) {
+    return {
+      ok: false,
+      error: "`outOfScope` must be an array with at least one explicit non-goal \u2014 things the worker must NOT do.",
+      hint: 'Example \u2014 outOfScope: ["Do not modify files outside packages/core", "Do not fix the bugs you find, only report them"].'
+    };
+  }
+  const concrete = raw.outOfScope.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length >= MIN_NON_GOAL_CHARS && !isPlaceholder(item));
+  if (concrete.length === 0) {
+    return {
+      ok: false,
+      error: 'Every `outOfScope` entry was a placeholder ("none", "n/a", \u2026). Name at least one concrete non-goal: files or areas not to touch, changes not to make, features not to add.',
+      hint: 'There is always an edge worth stating \u2014 "read-only, no edits", "no dependency changes", "do not touch other packages". If truly nothing comes to mind, the task is not decomposed enough yet.'
+    };
+  }
+  return { ok: true, boundary: { scope, outOfScope: concrete } };
+}
+function renderTaskBoundaryBlock(boundary) {
+  return [
+    "\u2500\u2500 TASK BOUNDARY (hard contract \u2014 these lines define your edges) \u2500\u2500",
+    `Scope (what this task covers):
+${boundary.scope}`,
+    `Out of scope (explicit non-goals \u2014 do NOT do any of these):
+${boundary.outOfScope.map((item) => `- ${item}`).join("\n")}`
+  ].join("\n");
+}
+function composeBoundedTaskDescription(objective, boundary) {
+  return `${objective.trim()}
+
+${renderTaskBoundaryBlock(boundary)}`;
+}
+var taskBoundarySchemaProperties = {
+  scope: {
+    type: "string",
+    description: "REQUIRED. One concrete sentence stating what work this task covers \u2014 the in-bounds. The call is rejected without it."
+  },
+  outOfScope: {
+    type: "array",
+    items: { type: "string", minLength: 1 },
+    description: 'REQUIRED. At least one explicit non-goal the worker must NOT do (files/areas not to touch, changes not to make, features not to add). Placeholders like "none" are rejected.'
+  }
+};
+
 // src/coordination/delegate-tool.ts
 function createDelegateTool(opts) {
   const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
@@ -10490,8 +10564,9 @@ function createDelegateTool(opts) {
     properties: {
       task: {
         type: "string",
-        description: "What the subagent should do \u2014 natural language, complete sentence(s)."
+        description: "The objective \u2014 what the subagent should do, natural language, complete sentence(s). Pair it with the required `scope` and `outOfScope` boundary fields."
       },
+      ...taskBoundarySchemaProperties,
       role: {
         type: "string",
         description: rosterIds.length > 0 ? "Roster role id. Common: bug-hunter, security-scanner, refactor-planner, critic, audit-log, executor, shadow-agent, architect." : "No roster configured \u2014 pass `name` instead."
@@ -10549,12 +10624,12 @@ function createDelegateTool(opts) {
         description: "Max fresh-worker continuations after budget exhaustion. Default 1. Each gets the prior partial report."
       }
     },
-    required: ["task"]
+    required: ["task", "scope", "outOfScope"]
   };
   return {
     name: "delegate",
     description: "Hand a piece of work to a subagent and block until it returns. This call is synchronous: the leader's iteration pauses for the full duration of the subagent's run. (Multiple `delegate` calls fired in the same assistant turn still parallelize through the provider's parallel-tool-call surface, but each one eats wall-clock time \u2014 so for fan-out you actually control, reach for the async path below.) Use `delegate` when your next step genuinely needs the subagent's verdict \u2014 a review, a fact-check, a sign-off. Has own context, own LLM call, auto-extending budget, and a partial-completion handoff path (maxHandoffs, default 1). Workers cannot recursively spawn.\n\n**Do NOT use `delegate` for long-running work.** While `delegate` is in flight, the leader is fully blocked \u2014 it cannot act on other tools, read mail, or react to the user. If the work might run for tens of minutes or hours (multi-file refactor, monorepo audit, long-running build/test, sweeping migration), the blocking call wastes the leader's time. Use the async tool family instead: `spawn_subagent` to create each worker (returns a `subagentId` immediately), `assign_task` to queue work on it (returns a `taskId` immediately), then `await_tasks` to retrieve results later. The leader keeps doing other work while the worker churns, and a worker that realizes its task will run long can mail the leader (type `steer` or `ask` via `mail_send`) saying *\"my task is going to run long, please spawn a subagent instead\"* so the leader re-dispatches asynchronously instead of waiting.\n\n**Do NOT use `delegate` for fan-out you control.** Multiple sequential `delegate` calls each block the leader, wasting wall-clock time. For independent investigations you want to run in parallel \u2014 security scan + bug hunt + perf review on the same PR \u2014 use the async tool family: `spawn_subagent` to create each worker (returns a `subagentId` immediately), `assign_task` to queue work on it (returns a `taskId` immediately), then the `await_tasks` tool with `{mode: 'any'}` to fold the first useful result into the next decision while the rest keep churning. Reach for `delegate` only when the result gates your next move AND the work is short enough that blocking the leader is acceptable.",
-    usageHint: "Set `task` to a complete instruction. Pick `role` from roster or pass `name` for free-form. Reach for `delegate` only when the result gates your next move AND the work is short enough that blocking the leader is acceptable (minutes, not hours). For long-running work or fan-out you control, use `spawn_subagent` + `assign_task` + `await_tasks` instead. Raise `maxHandoffs` (default 1, cap 8) for multi-day or multi-refactor tasks; pass larger `timeoutMs`/`maxIterations`/`maxToolCalls` only when needed.",
+    usageHint: "Set `task` to the objective, then make the edges explicit: `scope` (what the work covers) and `outOfScope` (at least one concrete non-goal) are REQUIRED \u2014 the call is rejected without them, and the worker treats the rendered boundary block as a hard contract. Pick `role` from roster or pass `name` for free-form. Reach for `delegate` only when the result gates your next move AND the work is short enough that blocking the leader is acceptable (minutes, not hours). For long-running work or fan-out you control, use `spawn_subagent` + `assign_task` + `await_tasks` instead. Raise `maxHandoffs` (default 1, cap 8) for multi-day or multi-refactor tasks; pass larger `timeoutMs`/`maxIterations`/`maxToolCalls` only when needed.",
     permission: "auto",
     mutating: false,
     managesOwnTimeout: true,
@@ -10574,6 +10649,14 @@ function createDelegateTool(opts) {
           error: "Delegation cancelled before spawn \u2014 the run was interrupted."
         };
       }
+      const boundary = parseTaskBoundary(i);
+      if (!boundary.ok) {
+        return {
+          ok: false,
+          error: `delegate rejected \u2014 task boundary incomplete: ${boundary.error}`,
+          hint: boundary.hint
+        };
+      }
       const target = i.role ?? i.name ?? "subagent";
       const launchModePreface = [
         "Launch-mode guidance (delegate): you were launched via the synchronous `delegate` tool, so the leader is blocked on this call for the full duration of your run.",
@@ -10644,7 +10727,8 @@ function createDelegateTool(opts) {
         const dir = director;
         const maxHandoffs = Math.min(8, Math.max(0, Math.floor(i.maxHandoffs ?? 1)));
         const handoffs = [];
-        let delegatedTask = i.task;
+        const baseBrief = composeBoundedTaskDescription(i.task, boundary.boundary);
+        let delegatedTask = baseBrief;
         let handoffCount = 0;
         for (; ; ) {
           const attemptConfig = (() => {
@@ -10784,7 +10868,7 @@ function createDelegateTool(opts) {
               remainingWork: continuation.remainingWork
             });
             handoffCount += 1;
-            delegatedTask = buildHandoffTask(i.task, continuation, handoffCount, maxHandoffs);
+            delegatedTask = buildHandoffTask(baseBrief, continuation, handoffCount, maxHandoffs);
             continue;
           }
           const incomplete = result.report?.completion === "partial";
@@ -12688,8 +12772,9 @@ function makeAssignTool(director) {
       description: {
         type: "string",
         minLength: 1,
-        description: "The task in natural language \u2014 what you want this subagent to do."
+        description: "The objective in natural language \u2014 what you want this subagent to do. Pair it with the required `scope` and `outOfScope` boundary fields."
       },
+      ...taskBoundarySchemaProperties,
       maxToolCalls: {
         type: "number",
         minimum: 1,
@@ -12697,20 +12782,28 @@ function makeAssignTool(director) {
       },
       timeoutMs: { type: "number", minimum: 1, description: "Optional per-task timeout in ms." }
     },
-    required: ["subagentId", "description"]
+    required: ["subagentId", "description", "scope", "outOfScope"]
   };
   return {
     name: "assign_task",
-    description: "Queue a task on a previously spawned subagent. NON-BLOCKING: returns a `taskId` IMMEDIATELY \u2014 the subagent processes the task on its next iteration with its own LLM budget. The `taskId` is the durable handle for retrieving the result later via `await_tasks`, `roll_up`, or `ask_result`. Many `assign_task` calls can be in flight in parallel against the same or different subagents. This is the primary tool for fan-out work; do NOT use `delegate` to spawn multiple investigations sequentially.",
+    description: "Queue a task on a previously spawned subagent. NON-BLOCKING: returns a `taskId` IMMEDIATELY \u2014 the subagent processes the task on its next iteration with its own LLM budget. The `taskId` is the durable handle for retrieving the result later via `await_tasks`, `roll_up`, or `ask_result`. Every assignment MUST carry an explicit boundary: `scope` (what the work covers) and `outOfScope` (at least one concrete non-goal) \u2014 the call is rejected without them, and the worker treats the rendered boundary block as a hard contract. Many `assign_task` calls can be in flight in parallel against the same or different subagents. This is the primary tool for fan-out work; do NOT use `delegate` to spawn multiple investigations sequentially.",
     permission: "auto",
     mutating: false,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema,
     async execute(input) {
       const i = input;
+      const boundary = parseTaskBoundary(i);
+      if (!boundary.ok) {
+        return {
+          ok: false,
+          error: `assign_task rejected \u2014 task boundary incomplete: ${boundary.error}`,
+          hint: boundary.hint
+        };
+      }
       const task = {
         id: randomUUID8(),
-        description: i.description,
+        description: composeBoundedTaskDescription(i.description, boundary.boundary),
         subagentId: i.subagentId,
         maxToolCalls: i.maxToolCalls,
         timeoutMs: i.timeoutMs
@@ -18543,6 +18636,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       sessionPath: (sid, ext) => this.sessionPath(sid, ext)
     });
     this.clearLoadCache(canonical);
+    if (id !== canonical) this.clearLoadCache(id);
   }
   async summarize(id, mtime) {
     return summarizeSessionFile({
@@ -20502,8 +20596,8 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   withNickname(subagent, subagentId) {
     const role = subagent.role ?? "subagent";
     const name = subagent.name?.trim() ?? "";
-    const isPlaceholder = name === "" || name.toLowerCase() === role.toLowerCase() || name === "subagent" || name === "adhoc" || name === "generic" || /^slot-/.test(name);
-    if (!isPlaceholder) return subagent;
+    const isPlaceholder2 = name === "" || name.toLowerCase() === role.toLowerCase() || name === "subagent" || name === "adhoc" || name === "generic" || /^slot-/.test(name);
+    if (!isPlaceholder2) return subagent;
     const { key, display } = assignNickname(role, this.usedNicknames);
     this.usedNicknames.add(key);
     this.subagentNicknames.set(subagentId, key);
@@ -31366,6 +31460,7 @@ export {
   clearProjectSkillAugmentation,
   collabInjectMiddleware,
   collabPauseMiddleware,
+  composeBoundedTaskDescription,
   composeDirectorPrompt,
   composeSubagentPrompt,
   consolidatedDocumentPath,
@@ -31450,6 +31545,7 @@ export {
   parseMailboxAckInput,
   parseMailboxQueryInput,
   parseMailboxSendInput,
+  parseTaskBoundary,
   phaseForRole,
   quarantinePath,
   rankRoleSkills,
@@ -31466,6 +31562,7 @@ export {
   refreshProjectAgentIdentity,
   release,
   renderSkillAugmentation,
+  renderTaskBoundaryBlock,
   resetCaptureWindow,
   resetCaptureWindows,
   resetProjectAgentIdentity,
@@ -31496,6 +31593,7 @@ export {
   startPackageOutdatedWatcher,
   startTechStackConsumer,
   subagentNeedsWorktree,
+  taskBoundarySchemaProperties,
   terminalPolicyDecision,
   unwrapWholeDocumentFence,
   updatePackageOutdatedStatus,

package/dist/coordination/task-boundary.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Hard task-boundary contract for leader → subagent assignment tools.
+ *
+ * `delegate` and `assign_task` reject any assignment that does not carry an
+ * explicit in-bounds `scope` and at least one concrete out-of-scope non-goal.
+ * Prompt-only guidance ("state the scope and non-goals") degrades under
+ * pressure: a rushed leader writes "fix it", the worker guesses the edges, and
+ * the drift only surfaces at review time — the most expensive place to find
+ * it. Forcing the boundary into structured fields makes the edges
+ * machine-checkable at assignment time and lets the tool return a teaching
+ * error that names exactly what is missing, so the leader self-corrects on
+ * the next call instead of shipping a vague brief.
+ *
+ * The parsed boundary is composed into `TaskSpec.description` as a clearly
+ * delimited block. That is deliberate: the description is the canonical brief
+ * every runner, transcript, handoff continuation, and roll-up already
+ * consumes, so the boundary travels with the task everywhere without new
+ * plumbing (and `buildHandoffTask`'s "Original task:" carry-over preserves it
+ * into fresh workers for free).
+ */
+import type { JSONSchema } from '../types/tool.js';
+export interface TaskBoundary {
+    /** What the work covers — the in-bounds statement. */
+    scope: string;
+    /** Explicit non-goals: things the worker must NOT do. */
+    outOfScope: string[];
+}
+export type TaskBoundaryParseResult = {
+    ok: true;
+    boundary: TaskBoundary;
+} | {
+    ok: false;
+    error: string;
+    hint: string;
+};
+/**
+ * Validate and normalize the `scope` / `outOfScope` pair from a tool input.
+ * Returns the cleaned boundary, or an error + hint pair worded so the calling
+ * leader can fix the call in one retry.
+ */
+export declare function parseTaskBoundary(raw: {
+    scope?: unknown;
+    outOfScope?: unknown;
+}): TaskBoundaryParseResult;
+/**
+ * Render the boundary as the block appended to `TaskSpec.description`. The
+ * heading is loud on purpose: the worker treats these lines as hard edges,
+ * and review-time drift checks quote them verbatim.
+ */
+export declare function renderTaskBoundaryBlock(boundary: TaskBoundary): string;
+/**
+ * Compose the leader's objective with its boundary into the canonical brief
+ * delivered to the runner. The objective stays verbatim and first; the
+ * boundary block follows so handoffs, transcripts, and roll-ups that quote
+ * the description carry the edges with them.
+ */
+export declare function composeBoundedTaskDescription(objective: string, boundary: TaskBoundary): string;
+/**
+ * Shared schema property definitions so `delegate` and `assign_task` state
+ * the identical contract. Declaring the fields here (rather than inline per
+ * tool) keeps the required-field teaching text single-sourced.
+ */
+export declare const taskBoundarySchemaProperties: Record<string, JSONSchema>;
+//# sourceMappingURL=task-boundary.d.ts.map

package/dist/core/index.js

@@ -7920,7 +7920,7 @@ var RUNTIME_CAPABILITY_MANIFEST = [
     id: "execution.shell",
     pack: "development",
     exposure: "direct",
-    tools: ["bash", "exec", "language", "language_info", "language_package"]
+    tools: ["bash", "exec", "pwsh", "language", "language_info", "language_package"]
   },
   {
     id: "verification.run",