@wrongstack/core 0.148.0 → 0.236.0

package/dist/sdd/index.js

@@ -617,6 +617,81 @@ function topologicalSort(graph) {
   return result;
 }
 
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // SDD (Spec-Driven Development)
+  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
+  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
+  SDD_INVALID_STATE: "SDD_INVALID_STATE",
+  SDD_NOT_READY: "SDD_NOT_READY"};
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var AgentError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "agent",
+      severity: opts.code === ERROR_CODES.AGENT_ABORTED ? "warning" : "error",
+      recoverable: opts.recoverable ?? opts.code === ERROR_CODES.AGENT_ITERATION_LIMIT,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "AgentError";
+  }
+};
+var SddError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "sdd",
+      severity: opts.code === ERROR_CODES.SDD_PARSE_FAILED ? "warning" : "error",
+      recoverable: opts.code === ERROR_CODES.SDD_NOT_READY,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "SddError";
+  }
+};
+
 // src/sdd/task-tracker.ts
 var TaskTracker = class {
   constructor(opts) {
@@ -651,7 +726,10 @@ var TaskTracker = class {
     return this.graph;
   }
   addNode(node) {
-    if (!this.graph) throw new Error("No graph loaded");
+    if (!this.graph) throw new SddError({
+      message: "No graph loaded",
+      code: ERROR_CODES.SDD_INVALID_STATE
+    });
     const now = Date.now();
     const newNode = {
       ...node,
@@ -669,7 +747,10 @@ var TaskTracker = class {
     return newNode;
   }
   addEdge(from, to, type = "depends_on") {
-    if (!this.graph) throw new Error("No graph loaded");
+    if (!this.graph) throw new SddError({
+      message: "No graph loaded",
+      code: ERROR_CODES.SDD_INVALID_STATE
+    });
     this.graph.edges.push({
       id: crypto.randomUUID(),
       from,
@@ -680,9 +761,16 @@ var TaskTracker = class {
     this.persist();
   }
   updateNodeStatus(id, status, reason) {
-    if (!this.graph) throw new Error("No graph loaded");
+    if (!this.graph) throw new SddError({
+      message: "No graph loaded",
+      code: ERROR_CODES.SDD_INVALID_STATE
+    });
     const node = this.graph.nodes.get(id);
-    if (!node) throw new Error(`Node ${id} not found`);
+    if (!node) throw new SddError({
+      message: `Node ${id} not found`,
+      code: ERROR_CODES.SDD_NOT_READY,
+      context: { nodeId: id }
+    });
     const from = node.status;
     const now = Date.now();
     node.status = status;
@@ -705,9 +793,16 @@ var TaskTracker = class {
     this.persist();
   }
   updateNode(id, patch) {
-    if (!this.graph) throw new Error("No graph loaded");
+    if (!this.graph) throw new SddError({
+      message: "No graph loaded",
+      code: ERROR_CODES.SDD_INVALID_STATE
+    });
     const node = this.graph.nodes.get(id);
-    if (!node) throw new Error(`Node ${id} not found`);
+    if (!node) throw new SddError({
+      message: `Node ${id} not found`,
+      code: ERROR_CODES.SDD_NOT_READY,
+      context: { nodeId: id }
+    });
     if (patch.title !== void 0) node.title = patch.title;
     if (patch.description !== void 0) node.description = patch.description;
     if (patch.priority !== void 0) node.priority = patch.priority;
@@ -826,7 +921,12 @@ var TaskTracker = class {
   persist() {
     if (!this.graph) return;
     this.opts.store.saveGraph(this.graph).catch((err) => {
-      this.opts.onPersistError ? this.opts.onPersistError(err) : console.warn("[task-tracker] saveGraph failed:", err instanceof Error ? err.message : String(err));
+      this.opts.onPersistError ? this.opts.onPersistError(err) : console.warn(JSON.stringify({
+        level: "warn",
+        event: "task_tracker.save_graph_failed",
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
     });
   }
 };
@@ -879,12 +979,14 @@ var TaskFlow = class {
     const analysis = parser.analyze(this.spec);
     this.emit("spec.analyzed", { analysis });
     if (analysis.completeness < 50) {
-      this.emit("error", {
-        phase: "analyzing",
-        error: new Error(`Spec completeness too low: ${analysis.completeness}%`)
+      const err = new SddError({
+        message: `Spec completeness too low: ${analysis.completeness}%`,
+        code: ERROR_CODES.SDD_VALIDATION_FAILED,
+        context: { completeness: analysis.completeness }
       });
+      this.emit("error", { phase: "analyzing", error: err });
       this.setPhase("failed");
-      throw new Error("Spec too incomplete");
+      throw err;
     }
     this.setPhase("generating");
     const generator = new TaskGenerator({ taskTracker: this.opts.tracker });
@@ -892,7 +994,11 @@ var TaskFlow = class {
     return this.graph;
   }
   async execute(ctx) {
-    if (!this.graph) throw new Error("No graph loaded. Call fromSpec first.");
+    if (!this.graph) throw new SddError({
+      message: "No graph loaded. Call fromSpec first.",
+      code: ERROR_CODES.SDD_INVALID_STATE,
+      context: { phase: this.phase }
+    });
     this.setPhase("executing");
     this.stopped = false;
     const pendingTasks = this.getExecutableTasks();
@@ -932,7 +1038,11 @@ var TaskFlow = class {
   }
   async reviewTask(taskId, approved, comment) {
     const task = this.opts.tracker.getNode(taskId);
-    if (!task) throw new Error(`Task ${taskId} not found`);
+    if (!task) throw new SddError({
+      message: `Task ${taskId} not found`,
+      code: ERROR_CODES.SDD_NOT_READY,
+      context: { taskId }
+    });
     if (approved) {
       this.opts.tracker.updateNodeStatus(taskId, "completed", comment);
       this.emit("task.completed", { taskId });
@@ -1246,7 +1356,9 @@ var TaskGraphStore = class {
 // src/utils/expect-defined.ts
 function expectDefined(value, label) {
   if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
+    const err = new Error("Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
   }
   return value;
 }
@@ -1584,7 +1696,11 @@ var AISpecBuilder = class {
     switch (this.session.phase) {
       case "questioning":
         if (!this.session.spec) {
-          throw new Error("Cannot approve: no spec generated yet.");
+          throw new SddError({
+            message: "Cannot approve: no spec generated yet.",
+            code: ERROR_CODES.SDD_INVALID_STATE,
+            context: { phase: "questioning", sessionId: this.session.id }
+          });
         }
         this.session.phase = "spec_review";
         break;
@@ -1642,7 +1758,11 @@ var AISpecBuilder = class {
    */
   async saveSpec() {
     if (!this.session.spec) {
-      throw new Error("No spec to save.");
+      throw new SddError({
+        message: "No spec to save.",
+        code: ERROR_CODES.SDD_NOT_READY,
+        context: { sessionId: this.session.id }
+      });
     }
     await this.store.save(this.session.spec);
     return this.session.spec;
@@ -1657,17 +1777,30 @@ var AISpecBuilder = class {
     try {
       parsed = JSON.parse(jsonStr);
     } catch (e) {
-      throw new Error(`Invalid JSON for spec: ${e instanceof Error ? e.message : "parse error"}`);
+      throw new SddError({
+        message: "Invalid JSON for spec",
+        code: ERROR_CODES.SDD_PARSE_FAILED,
+        cause: e,
+        context: { detail: e instanceof Error ? e.message : "parse error" }
+      });
     }
     if (!parsed || typeof parsed !== "object") {
-      throw new Error("Spec JSON must be an object.");
+      throw new SddError({
+        message: "Spec JSON must be an object",
+        code: ERROR_CODES.SDD_VALIDATION_FAILED,
+        context: { actualType: typeof parsed }
+      });
     }
     const raw = parsed;
     const now = Date.now();
     const title = String(raw.title ?? this.session.title ?? "Untitled");
     const overview = String(raw.overview ?? "");
     if (!overview || overview === "undefined") {
-      throw new Error("Spec must have an overview.");
+      throw new SddError({
+        message: "Spec must have an overview",
+        code: ERROR_CODES.SDD_VALIDATION_FAILED,
+        context: { field: "overview", title }
+      });
     }
     const rawSections = Array.isArray(raw.sections) ? raw.sections : [];
     const sections = rawSections.filter((s) => s && typeof s === "object").map((s) => ({
@@ -2211,9 +2344,11 @@ function computeParallelGroups(graph, blockedByMap) {
 
 // src/utils/assert-never.ts
 function assertNever(x, message) {
-  throw new Error(
+  const err = new Error(
     `Unhandled case: ${JSON.stringify(x)}`
   );
+  err.name = "AssertNeverError";
+  throw err;
 }
 
 // src/sdd/spec-versioning.ts
@@ -2987,6 +3122,7 @@ var SubagentBudget = class _SubagentBudget {
 function makeAgentSubagentRunner(opts) {
   const format = opts.formatTaskInput ?? defaultFormatTaskInput;
   return async (task, ctx) => {
+    const taskStartedAt = Date.now();
     const factoryResult = await opts.factory(ctx.config);
     const { agent, events } = factoryResult;
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
@@ -3083,7 +3219,7 @@ function makeAgentSubagentRunner(opts) {
       }),
       events.on("provider.text_delta", (e) => {
         ctx.budget.markActivity();
-        streamingTextAcc = (streamingTextAcc + e.text).slice(-200);
+        streamingTextAcc = (streamingTextAcc + e.text).slice(-2e3);
       })
     );
     const onParentAbort = () => aborter.abort();
@@ -3091,6 +3227,15 @@ function makeAgentSubagentRunner(opts) {
     let result;
     try {
       result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
+      events.emit("subagent.task_completed", {
+        subagentId: ctx.subagentId,
+        taskId: task.id,
+        status: result.status === "done" ? "success" : "failed",
+        iterations: result.iterations,
+        toolCalls: ctx.budget.usage().toolCalls,
+        durationMs: Date.now() - taskStartedAt,
+        finalText: result.finalText?.trim() || void 0
+      });
     } finally {
       detachFleet?.();
       ctx.signal.removeEventListener("abort", onParentAbort);
@@ -3126,21 +3271,40 @@ function makeAgentSubagentRunner(opts) {
       if (budgetError) throw budgetError;
     }
     if (result.status === "failed") {
-      throw result.error instanceof Error ? result.error : new Error(String(result.error ?? "agent failed"));
+      throw result.error instanceof AgentError ? result.error : new AgentError({
+        message: result.error instanceof Error ? result.error.message : String(result.error ?? "agent failed"),
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        cause: result.error
+      });
     }
     if (result.status === "aborted") {
-      throw new Error("agent aborted");
+      throw new AgentError({
+        message: "agent aborted",
+        code: ERROR_CODES.AGENT_ABORTED
+      });
     }
     if (result.status === "max_iterations") {
-      throw new Error("agent exhausted iteration limit");
+      throw new AgentError({
+        message: "agent exhausted iteration limit",
+        code: ERROR_CODES.AGENT_ITERATION_LIMIT,
+        recoverable: true
+      });
     }
     const usage = ctx.budget.usage();
     const finalText = (result.finalText ?? "").trim();
     if (finalText.length === 0 && usage.toolCalls === 0) {
-      throw new Error("empty response");
+      throw new AgentError({
+        message: "empty response \u2014 agent produced no text and no tool calls",
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        context: { iterations: result.iterations }
+      });
     }
     if (finalText.length === 0 && lastToolFailed !== null) {
-      throw new Error(`tool failed: ${lastToolFailed}`);
+      throw new AgentError({
+        message: `unrecovered tool failure: ${lastToolFailed} \u2014 agent ended turn without acknowledging the error`,
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        context: { tool: lastToolFailed, iterations: result.iterations }
+      });
     }
     return {
       result: result.finalText,
@@ -3153,44 +3317,6 @@ function defaultFormatTaskInput(task) {
   return task.description ?? "";
 }
 
-// src/types/errors.ts
-var ERROR_CODES = {
-  // Provider
-  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
-  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
-  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
-  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
-  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
-  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR"};
-var WrongStackError = class extends Error {
-  code;
-  subsystem;
-  severity;
-  recoverable;
-  context;
-  constructor(opts) {
-    super(opts.message, { cause: opts.cause });
-    this.name = "WrongStackError";
-    this.code = opts.code;
-    this.subsystem = opts.subsystem;
-    this.severity = opts.severity ?? "error";
-    this.recoverable = opts.recoverable ?? false;
-    this.context = opts.context;
-  }
-  /**
-   * Render a one-line user-facing description.
-   * Subclasses should override for domain-specific formatting.
-   */
-  describe() {
-    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
-    return `${this.code}: ${this.message}${ctx}`;
-  }
-};
-function formatContext(ctx) {
-  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
-  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
-}
-
 // src/types/provider.ts
 var ProviderError = class extends WrongStackError {
   status;
@@ -3265,6 +3391,9 @@ function providerStatusToCode(status, type) {
 
 // src/coordination/coordinator/error-classifier.ts
 function classifySubagentError(err, hints = {}) {
+  if (err instanceof AgentError && err.cause) {
+    return classifySubagentError(err.cause, hints);
+  }
   const cause = err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : void 0;
   if (err instanceof ProviderError) {
     const baseMessage2 = err.describe();
@@ -3297,7 +3426,7 @@ function classifySubagentError(err, hints = {}) {
   if (/agent exhausted iteration limit$/i.test(baseMessage)) {
     return { kind: "budget_iterations", message: baseMessage, retryable: false, cause };
   }
-  if (/empty response$/i.test(baseMessage)) {
+  if (/empty response/i.test(baseMessage)) {
     return { kind: "empty_response", message: baseMessage, retryable: false, cause };
   }
   if (/^tool failed: /i.test(baseMessage)) {
@@ -3347,11 +3476,11 @@ var HEAVY_BUDGET = {
 };
 var TOOLS = {
   /** Pure read/inspect — safe for analysis and review agents. */
-  read: ["read", "grep", "glob", "search", "tree"],
+  read: ["read", "grep", "glob", "search", "tree", "mailbox"],
   /** Read + structured inspection (logs, diffs, json, dependency audit). */
-  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit"],
+  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit", "mailbox"],
   /** Read + edit (no shell). For agents that write code/docs but don't run it. */
-  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch"],
+  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch", "mailbox"],
   /** Full build loop: edit + run (lint/format/typecheck/test/bash). */
   build: [
     "read",
@@ -3368,16 +3497,17 @@ var TOOLS = {
     "lint",
     "format",
     "typecheck",
-    "test"
+    "test",
+    "mailbox"
   ],
   /** Version control. */
   vcs: ["read", "grep", "glob", "git", "diff"],
   /** Dependency management + CVE audit. */
-  deps: ["read", "grep", "glob", "install", "outdated", "audit", "json"],
+  deps: ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"],
   /** Documentation authoring. */
-  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document"],
+  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document", "mailbox"],
   /** Web research. */
-  research: ["read", "grep", "glob", "search", "fetch"]
+  research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
 };
 
 // src/coordination/agents/phase1-discovery.ts
@@ -4175,15 +4305,44 @@ Working rules:
       id: "e2e",
       name: "E2E",
       role: "e2e",
-      tools: [...TOOLS.build, "fetch"],
+      tools: [
+        ...TOOLS.build,
+        "fetch",
+        "playwright_navigate",
+        "playwright_screenshot",
+        "playwright_click",
+        "playwright_type",
+        "playwright_evaluate",
+        "playwright_select_option",
+        "playwright_hover",
+        "playwright_fill_form",
+        "playwright_wait_for",
+        "playwright_press_key",
+        "playwright_drag"
+      ],
       prompt: `You are the E2E agent. Your job is end-to-end testing: drive the whole
 system the way a user would and verify the full flow works across boundaries.
 
 Scope:
 - Author end-to-end scenarios that exercise real user journeys
 - Drive UI/CLI/API across process and network boundaries
+- Use Playwright browser tools (navigate, click, type, screenshot, evaluate)
+  to automate web UI flows \u2014 open pages, interact with forms, capture evidence
 - Set up and tear down realistic test state
-- Capture failures with enough detail to reproduce (screenshots, logs)
+- Capture failures with enough detail to reproduce (screenshots, logs, page HTML)
+
+Playwright tools available (require the "playwright" MCP server to be enabled):
+  playwright_navigate(url)     \u2014 open a page at the given URL
+  playwright_screenshot()      \u2014 capture a full-page or viewport screenshot
+  playwright_click(selector)   \u2014 click on an element matching a CSS selector
+  playwright_type(selector, text) \u2014 type text into a focused input element
+  playwright_evaluate(script)  \u2014 run arbitrary JavaScript in the page context
+  playwright_select_option(selector, value) \u2014 pick a <select> dropdown option
+  playwright_hover(selector)   \u2014 hover the mouse over an element
+  playwright_fill_form(fields) \u2014 fill multiple form fields in one call
+  playwright_wait_for(selector) \u2014 block until an element appears on the page
+  playwright_press_key(key)    \u2014 press a keyboard key (Enter, Tab, Escape, \u2026)
+  playwright_drag(from, to)    \u2014 drag an element from one selector to another
 
 Input format you accept:
 { "task": "scenario | smoke | journey", "flow": "<user journey>", "surface": "ui | cli | api" }
@@ -4197,8 +4356,10 @@ Output: Markdown e2e report:
 Working rules:
 - Test the real flow end to end; don't stub the thing under test
 - Make scenarios deterministic \u2014 control time, randomness, and external state
-- On failure, capture artifacts (logs/screenshots) for reproduction
-- Keep scenarios independent so one failure doesn't cascade`
+- On failure, capture artifacts (screenshots, page HTML, logs) for reproduction
+- Keep scenarios independent so one failure doesn't cascade
+- For browser tests: playwright_navigate first, then interact, then playwright_screenshot as evidence
+- If playwright tools are unavailable, report it and fall back to API/CLI testing`
     },
     budget: HEAVY_BUDGET,
     capability: {
@@ -4211,10 +4372,106 @@ Working rules:
         "user journey",
         "smoke test",
         "playwright",
+        "browser",
+        "screenshot",
+        "web ui",
+        "headless",
         "cypress",
         "full flow",
         "browser test",
-        "acceptance test"
+        "acceptance test",
+        "navigate",
+        "click",
+        "form fill",
+        "dom",
+        "page load"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "browser",
+      name: "Browser",
+      role: "browser",
+      tools: [
+        ...TOOLS.read,
+        "fetch",
+        "playwright_navigate",
+        "playwright_screenshot",
+        "playwright_click",
+        "playwright_type",
+        "playwright_evaluate",
+        "playwright_select_option",
+        "playwright_hover",
+        "playwright_fill_form",
+        "playwright_wait_for",
+        "playwright_press_key",
+        "playwright_drag"
+      ],
+      prompt: `You are the Browser agent. Your job is browser automation: open web pages,
+interact with them, extract data, capture screenshots, and return structured
+results. You are a read-focused agent \u2014 you drive the browser, not the filesystem.
+
+Scope:
+- Navigate to URLs and wait for pages to load
+- Take full-page or element screenshots as evidence
+- Click buttons, fill forms, select options, type text \u2014 full user simulation
+- Extract page content: text, HTML, element attributes, data tables
+- Evaluate JavaScript in the page context to extract structured data
+- Verify visual state (element visibility, text content, attribute values)
+
+Playwright tools available (require the "playwright" MCP server to be enabled):
+  playwright_navigate(url)          \u2014 open a page at the given URL
+  playwright_screenshot()           \u2014 capture a full-page or viewport screenshot
+  playwright_click(selector)        \u2014 click on an element matching a CSS selector
+  playwright_type(selector, text)   \u2014 type text into a focused input element
+  playwright_evaluate(script)       \u2014 run arbitrary JavaScript in the page context
+  playwright_select_option(selector, value) \u2014 pick a <select> dropdown option
+  playwright_hover(selector)        \u2014 hover the mouse over an element
+  playwright_fill_form(fields)      \u2014 fill multiple form fields in one call
+  playwright_wait_for(selector)     \u2014 block until an element appears on the page
+  playwright_press_key(key)         \u2014 press a keyboard key (Enter, Tab, Escape, \u2026)
+  playwright_drag(from, to)         \u2014 drag an element from one selector to another
+
+Input format you accept:
+{ "task": "navigate | screenshot | extract | interact | verify", "url": "<url>", "steps": ["step1", "step2"] }
+
+Output: Structured markdown report:
+- ## Page (URL, title, load status)
+- ## Actions Taken (step-by-step with timestamps)
+- ## Results (extracted data, element states, verification results)
+- ## Screenshots (list attached screenshot references)
+- ## Errors (any failures with stack traces)
+
+Working rules:
+- Always playwright_navigate first before any interaction
+- Always playwright_wait_for after navigation to ensure the page is ready
+- playwright_screenshot is your primary evidence \u2014 use it before and after interactions
+- Use playwright_evaluate for structured data extraction (JSON, text content)
+- If a selector fails, try alternative selectors before giving up
+- Report exact CSS selectors used \u2014 they're part of the evidence
+- If playwright tools are unavailable, report the error immediately \u2014 do not guess`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Browser automation: opens pages, clicks, types, screenshots, extracts data via Playwright headless Chromium.",
+      keywords: [
+        "browser",
+        "screenshot",
+        "navigate",
+        "web page",
+        "scrape",
+        "crawl",
+        "headless",
+        "chrome",
+        "open url",
+        "capture",
+        "page title",
+        "extract data",
+        "fill form",
+        "click button",
+        "take screenshot"
       ]
     }
   },
@@ -5663,7 +5920,7 @@ Working rules:
       id: "tech-stack",
       name: "Tech Stack Validator",
       role: "tech-stack",
-      tools: ["search", "fetch", "read", "grep", "glob", "outdated", "audit", "json"],
+      tools: ["search", "fetch", "read", "grep", "glob", "outdated", "audit", "json", "mailbox"],
       prompt: `You are the Tech Stack Validator \u2014 a single-shot validation agent that fires
 before any package, library, or framework choice is committed.
 
@@ -5671,6 +5928,16 @@ Your ONLY job: verify that a technology choice is current, real, and not obsolet
 You are the "this isn't code, this is 10-year-old technology" agent. Intervene
 hard when the LLM hallucinates a version number or suggests dead tech.
 
+## Before you begin
+
+Check the inter-agent mailbox for pending tasks. Other agents or the file-watcher
+may have left assign messages with dependency files to audit:
+- mailbox action=check
+
+If you find an assign message, use the specified file path and packages.
+When done, post results back:
+- mailbox action=send to=<sender> type=result subject="Tech stack audit results" body="..."
+
 ## Critical rules
 
 1. **Verify existence.** Search npm registry (fetch https://registry.npmjs.org/<pkg>/latest)
@@ -5729,11 +5996,11 @@ When APPROVED:
 **Install**: pnpm add <name>@^<major>.<minor>.0`
     },
     budget: {
-      timeoutMs: 6e4,
-      maxIterations: 5,
-      maxToolCalls: 20,
-      maxTokens: 4e4,
-      maxCostUsd: 0.1
+      timeoutMs: 12e4,
+      maxIterations: 10,
+      maxToolCalls: 40,
+      maxTokens: 6e4,
+      maxCostUsd: 0.25
     },
     capability: {
       phase: "meta",
@@ -6774,7 +7041,10 @@ var SddParallelRun = class {
       "\u2022 Do not ask before routine in-project tool use; if a permission gate appears, wait for that flow.",
       "\u2022 Keep output concise \u2014 summarize changes, do not transcribe files."
     ].join("\n");
-    if (!this.coordinator) throw new Error("SDD parallel runner requires a coordinator");
+    if (!this.coordinator) throw new SddError({
+      message: "SDD parallel runner requires a coordinator",
+      code: ERROR_CODES.SDD_INVALID_STATE
+    });
     const coordinator = this.coordinator;
     const spawns = subagentIds.map(
       (subagentId) => coordinator.spawn({
@@ -6786,7 +7056,10 @@ var SddParallelRun = class {
     );
     const spawnResults = await Promise.all(spawns);
     if (!spawnResults.every((r) => Boolean(r.subagentId))) {
-      throw new Error("One or more subagent spawns failed");
+      throw new SddError({
+        message: "One or more subagent spawns failed",
+        code: ERROR_CODES.SDD_INVALID_STATE
+      });
     }
     const assignPromises = tasks.map((task, i) => {
       const spec = {