@wrongstack/core 0.299.0 → 0.301.0

package/dist/types/skill.d.ts

@@ -19,6 +19,11 @@ export interface SkillManifest {
      * grants nor restricts any tool.
      */
     allowedTools?: string[] | undefined;
+    /** Stable WrongStack runtime capabilities required to activate this skill. */
+    requiredCapabilities?: string[] | undefined;
+    requiredTools?: string[] | undefined;
+    /** Optional capabilities; the skill must remain useful when these are absent. */
+    optionalCapabilities?: string[] | undefined;
     path: string;
     /**
      * Discovery layer the skill came from. `claude-*`, `foreign`, and `extra` are

package/dist/types/system-prompt.d.ts

@@ -1,6 +1,6 @@
+import type { MailboxAgentStatus } from '../coordination/mailbox-types.js';
 import type { TextBlock } from './blocks.js';
 import type { Tool } from './tool.js';
-import type { MailboxAgentStatus } from '../coordination/mailbox-types.js';
 /** Model capabilities relevant to prompt composition. */
 export interface ModelCapabilities {
     maxContextTokens: number;
@@ -12,6 +12,8 @@ export interface BuildContext {
     cwd: string;
     projectRoot: string;
     tools: Tool[];
+    /** Complete enabled catalog, including tools reachable only through lazy gateways. */
+    catalogTools?: Tool[] | undefined;
     /** Provider id (e.g. "anthropic", "minimax-coding-plan"). */
     provider?: string | undefined;
     /** Model id (e.g. "configured-model", "MiniMax-M2.7"). */

package/dist/types/tool-executor.d.ts

@@ -102,6 +102,10 @@ export interface ToolConfirmPendingResult {
     toolUseId: string;
     toolName: string;
     input: unknown;
+    preToolContext?: {
+        text: string;
+        contextAs: 'inline' | 'separate';
+    } | undefined;
     suggestedPattern: string;
     decisionSource?: import('./permission.js').PermissionDecision['source'] | undefined;
     riskTier?: import('./tool.js').RiskTier | undefined;
@@ -139,7 +143,10 @@ export interface ToolExecutorLike {
      * `bytes` from the running budget — no second `Buffer.byteLength`
      * walk, and no `JSON.stringify` fallback for structured results.
      */
-    executeTool(tool: Tool, use: ToolUseBlock, ctx: import('../core/context.js').Context, budget: number): Promise<{
+    executeTool(tool: Tool, use: ToolUseBlock, ctx: import('../core/context.js').Context, budget: number, preToolContext?: {
+        text: string;
+        contextAs: 'inline' | 'separate';
+    }): Promise<{
         block: ToolResultBlock;
         bytes: number;
     }>;

package/dist/utils/context-breakdown.d.ts

@@ -1,5 +1,5 @@
-import { type SystemBlockSource } from '../core/system-prompt-builder.js';
 import type { Context } from '../core/context.js';
+import { type SystemBlockSource } from '../core/system-prompt-builder.js';
 /**
  * Real, per-category token accounting for the live context window — the data
  * behind an honest `/context` display. Every number is measured from the actual
@@ -25,10 +25,16 @@ export interface ContextBreakdown {
     };
     history: {
         total: number;
-        /** User/assistant text + tool_use inputs + thinking. */
+        /** User/assistant/system text only. */
         text: number;
+        /** Serialized tool_use arguments. Optional for backward-compatible UI snapshots. */
+        toolInputs?: number | undefined;
         /** tool_result output content. */
         toolResults: number;
+        /** Preserved provider reasoning/thinking blocks. */
+        thinking?: number | undefined;
+        /** Images and future/unknown content block kinds. */
+        other?: number | undefined;
         messageCount: number;
     };
     volatile: {

package/dist/utils/index.d.ts

@@ -32,7 +32,7 @@ export { getPerfProfile, indexParallelBatchSize, isFrugalPerf, type PerfProfile,
 export { isPidAlive } from './pid.js';
 export * from './project-identity.js';
 export { type ProjectWatchEvent, type ProjectWatchSubscription, watchProjectTree, } from './project-watch.js';
-export { type CompileFail, type CompileResult, compileUserRegex } from './regex-guard.js';
+export { capSubject, type CompileFail, type CompileResult, compileUserRegex, MAX_SUBJECT_LEN, } from './regex-guard.js';
 export * from './safe-json.js';
 export { sessionScopedPath } from './session-scoped-path.js';
 export * from './sleep.js';

package/dist/utils/index.js

@@ -1655,6 +1655,25 @@ function resetCalibration(calibrationKey) {
   _cals.delete(calibrationKey);
 }
 
+// src/utils/todos-format.ts
+function formatTodosList(todos) {
+  if (todos.length === 0) return "No todos.";
+  const lines = [];
+  const done = todos.filter((t) => t.status === "completed").length;
+  lines.push(color.dim(`Todos (${done}/${todos.length} done):`));
+  todos.forEach((t, i) => {
+    const mark = t.status === "completed" ? color.green("[x]") : t.status === "in_progress" ? color.yellow("[~]") : color.dim("[ ]");
+    const text = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
+    const label = t.status === "completed" ? color.dim(text) : text;
+    lines.push(`  ${color.dim(String(i + 1).padStart(2))}. ${mark} ${label}`);
+  });
+  return lines.join("\n");
+}
+function hasOpenTodos(todos) {
+  if (!Array.isArray(todos) || todos.length === 0) return false;
+  return todos.some((t) => t.status === "pending" || t.status === "in_progress");
+}
+
 // src/core/agent-response.ts
 var MAX_TODO_SNAPSHOT_ITEMS = 10;
 var MAX_TODO_SNAPSHOT_CONTENT = 180;
@@ -1664,6 +1683,9 @@ function buildLiveNextStepsGateBlock(ctx) {
     (todo) => todo.status === "pending" || todo.status === "in_progress"
   );
   if (openTodos.length === 0) {
+    const toolRoute = ctx.tools?.some((t) => t.name === "nextsteps") ? [
+      "Calling the `nextsteps` tool with the same items satisfies branch 1 as well; if you both call it and write the block, the block wins."
+    ] : [];
     return {
       type: "text",
       text: [
@@ -1672,6 +1694,7 @@ function buildLiveNextStepsGateBlock(ctx) {
         "On the final response, you MUST take exactly one branch:",
         "1. If at least one genuinely useful follow-on action exists, include a balanced <nextsteps> block containing 1-4 exact prompt messages that can be submitted back to you through the current TUI or WebUI input.",
         "Every item must ask the agent to perform work. Never put a human-only chore or an instruction addressed to the user inside <nextsteps>; natural-language agent-directed imperatives are valid and need not be shell commands.",
+        ...toolRoute,
         "2. If no useful follow-on action truly exists, omit <nextsteps> and explicitly tell the user in normal prose that no further steps are needed for this task.",
         "Silently omitting both is invalid. Do not decide by chance, tone, or response length, and do not invent filler suggestions.",
         "[/nextsteps_gate]"
@@ -1765,7 +1788,10 @@ function getContextBreakdown(ctx) {
     }
   }
   let histText = 0;
+  let histToolInputs = 0;
   let histToolResults = 0;
+  let histThinking = 0;
+  let histOther = 0;
   for (const msg of ctx.messages) {
     if (typeof msg.content === "string") {
       histText += estimateTextTokens(msg.content);
@@ -1777,16 +1803,16 @@ function getContextBreakdown(ctx) {
           histText += estimateTextTokens(b.text);
           break;
         case "tool_use":
-          histText += estimateToolInputTokens(b.input);
+          histToolInputs += estimateToolInputTokens(b.input);
           break;
         case "tool_result":
           histToolResults += estimateToolResultTokens(b.content);
           break;
         case "thinking":
-          histText += estimateTextTokens(b.thinking);
+          histThinking += estimateTextTokens(JSON.stringify(b));
           break;
         default:
-          histText += estimateTextTokens(JSON.stringify(b));
+          histOther += estimateTextTokens(JSON.stringify(b));
       }
     }
   }
@@ -1800,7 +1826,7 @@ function getContextBreakdown(ctx) {
   const ledger = ledgerBlock ? estimateTextTokens(ledgerBlock.text) : 0;
   const nextsteps = nextstepsBlock ? estimateTextTokens(nextstepsBlock.text) : 0;
   const toolsTotal = toolsBuiltin + toolsMcp;
-  const historyTotal = histText + histToolResults;
+  const historyTotal = histText + histToolInputs + histToolResults + histThinking + histOther;
   const volatileTotal = ledger + nextsteps;
   const total = systemTotal + toolsTotal + historyTotal + volatileTotal;
   const effectiveMaxContext = resolveEffectiveMaxContext(ctx);
@@ -1816,7 +1842,10 @@ function getContextBreakdown(ctx) {
     history: {
       total: historyTotal,
       text: histText,
+      toolInputs: histToolInputs,
       toolResults: histToolResults,
+      thinking: histThinking,
+      other: histOther,
       messageCount: ctx.messages.length
     },
     volatile: { ledger, nextsteps, total: volatileTotal },
@@ -2453,6 +2482,9 @@ function canonicalProjectRoot(absRoot) {
     const commonDirFile = path3.join(gitDir, "commondir");
     if (!fs3.statSync(commonDirFile).isFile()) return checkoutRoot;
     const commonDir = path3.resolve(gitDir, fs3.readFileSync(commonDirFile, "utf8").trim());
+    const worktreesDir = path3.dirname(gitDir);
+    if (path3.basename(worktreesDir).toLowerCase() !== "worktrees") return checkoutRoot;
+    if (path3.resolve(worktreesDir, "..") !== commonDir) return checkoutRoot;
     if (path3.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
     return path3.dirname(commonDir);
   } catch {
@@ -2475,7 +2507,7 @@ function safeProfileName(name) {
   const safe = (name ?? "").replace(/[/\\:]/g, "_").replace(/\.\./g, "_").trim();
   return safe || "default";
 }
-function activeProfileName(globalRoot) {
+function bootstrapProfileName(globalRoot) {
   try {
     const parsed = JSON.parse(fs3.readFileSync(path3.join(globalRoot, "config.json"), "utf8"));
     return safeProfileName(
@@ -2493,7 +2525,7 @@ function wstackGlobalRoot() {
 function resolveWstackPaths(opts) {
   const globalRoot = opts.globalRoot ?? (opts.userHome ? path3.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
   const homeDir = opts.userHome ?? os.homedir();
-  const profileName = safeProfileName(opts.profileName ?? activeProfileName(globalRoot));
+  const profileName = safeProfileName(opts.profileName ?? bootstrapProfileName(globalRoot));
   const profileDir = path3.join(globalRoot, "profiles", profileName);
   const hash = projectHash(opts.projectRoot);
   const slug = projectSlug(opts.projectRoot);
@@ -2563,7 +2595,12 @@ function resolveWstackPaths(opts) {
     projectRequirementIntakes: path3.join(projectDir, "requirement-intakes"),
     syncConfig: path3.join(profileDir, "sync.json"),
     configHistoryDir: path3.join(globalRoot, "config-history"),
-    projectStatus: (projectHash2) => path3.join(globalRoot, "projects", projectHash2, "status.json")
+    projectStatus: (statusProjectSlug) => {
+      if (!/^[a-z0-9](?:[a-z0-9-]{0,39})-[a-f0-9]{6}$/.test(statusProjectSlug)) {
+        throw new Error(`Invalid project slug: ${statusProjectSlug}`);
+      }
+      return path3.join(globalRoot, "projects", statusProjectSlug, "status.json");
+    }
   };
 }
 
@@ -4068,13 +4105,93 @@ function watchProjectTree(root, listener, opts) {
 }
 
 // src/utils/regex-guard.ts
-var MAX_PATTERN_LEN = 512;
+var MAX_PATTERN_LEN = 256;
 var DANGEROUS_PATTERNS = [
+  // (a+)+, (.*)+, etc — nested quantifier on a group with internal quantifier
   /(\([^)]*[+*][^)]*\))[+*]/,
-  // (a+)+, (.*)+, etc
-  /(\(\?:[^)]*[+*][^)]*\))[+*]/
-  // same, with non-capturing group
+  /(\(\?:[^)]*[+*][^)]*\))[+*]/,
+  // Adjacent quantifiers: a++ a*+
+  /[+*]{2,}/,
+  // Quantifier on alternation with length 2+
+  /\([^|)]+\|[^)]+\)[+*][+*]/,
+  // Greedy quantifier inside lookahead/lookbehind — (?!.*a+)
+  /[([][^)\]]*[+*][^)\]]*[)\]][^)]*\?\??/
 ];
+function hasAmbiguousQuantifiedAlternation(pattern) {
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] !== "(") continue;
+    if (i > 0 && pattern[i - 1] === "\\") continue;
+    let depth = 0;
+    let inClass = false;
+    let j = i;
+    for (; j < pattern.length; j++) {
+      const ch = pattern[j];
+      if (ch === "\\") {
+        j++;
+        continue;
+      }
+      if (inClass) {
+        if (ch === "]") inClass = false;
+        continue;
+      }
+      if (ch === "[") {
+        inClass = true;
+        continue;
+      }
+      if (ch === "(") depth++;
+      else if (ch === ")") {
+        depth--;
+        if (depth === 0) break;
+      }
+    }
+    if (j >= pattern.length) return false;
+    const next = pattern[j + 1];
+    if (next !== "+" && next !== "*" && next !== "{") continue;
+    let inner = pattern.slice(i + 1, j);
+    inner = inner.replace(/^\?(?::|<?[=!])/u, "");
+    const branches = [];
+    let current = "";
+    let d = 0;
+    let cls = false;
+    for (let k = 0; k < inner.length; k++) {
+      const ch = inner[k];
+      if (ch === "\\") {
+        current += ch + (inner[k + 1] ?? "");
+        k++;
+        continue;
+      }
+      if (cls) {
+        if (ch === "]") cls = false;
+        current += ch;
+        continue;
+      }
+      if (ch === "[") {
+        cls = true;
+        current += ch;
+        continue;
+      }
+      if (ch === "(") d++;
+      if (ch === ")") d--;
+      if (ch === "|" && d === 0) {
+        branches.push(current);
+        current = "";
+        continue;
+      }
+      current += ch;
+    }
+    branches.push(current);
+    if (branches.length < 2) continue;
+    for (let a = 0; a < branches.length; a++) {
+      for (let b = a + 1; b < branches.length; b++) {
+        const x = branches[a];
+        const y = branches[b];
+        if (x === "" || y === "") return true;
+        if (x === y || x.startsWith(y) || y.startsWith(x)) return true;
+      }
+    }
+  }
+  return false;
+}
 function compileUserRegex(pattern, flags) {
   if (typeof pattern !== "string") {
     return { ok: false, reason: "pattern must be a string" };
@@ -4093,6 +4210,12 @@ function compileUserRegex(pattern, flags) {
       };
     }
   }
+  if (hasAmbiguousQuantifiedAlternation(pattern)) {
+    return {
+      ok: false,
+      reason: "pattern quantifies an alternation with overlapping branches \u2014 rewrite so no two branches can match the same text"
+    };
+  }
   try {
     return { ok: true, regex: new RegExp(pattern, flags) };
   } catch (err) {
@@ -4102,6 +4225,10 @@ function compileUserRegex(pattern, flags) {
     };
   }
 }
+var MAX_SUBJECT_LEN = 64 * 1024;
+function capSubject(line) {
+  return line.length > MAX_SUBJECT_LEN ? line.slice(0, MAX_SUBJECT_LEN) : line;
+}
 
 // src/utils/safe-json.ts
 function safeParse(input, maxBytes = 5e6) {
@@ -4418,25 +4545,6 @@ function formatTaskList(tasks) {
   return lines.join("\n");
 }
 
-// src/utils/todos-format.ts
-function formatTodosList(todos) {
-  if (todos.length === 0) return "No todos.";
-  const lines = [];
-  const done = todos.filter((t) => t.status === "completed").length;
-  lines.push(color.dim(`Todos (${done}/${todos.length} done):`));
-  todos.forEach((t, i) => {
-    const mark = t.status === "completed" ? color.green("[x]") : t.status === "in_progress" ? color.yellow("[~]") : color.dim("[ ]");
-    const text = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
-    const label = t.status === "completed" ? color.dim(text) : text;
-    lines.push(`  ${color.dim(String(i + 1).padStart(2))}. ${mark} ${label}`);
-  });
-  return lines.join("\n");
-}
-function hasOpenTodos(todos) {
-  if (!Array.isArray(todos) || todos.length === 0) return false;
-  return todos.some((t) => t.status === "pending" || t.status === "in_progress");
-}
-
 // src/utils/tool-description-mode.ts
 var DEFAULT_TOOL_DESCRIPTION_MODE = "extend";
 var ORIGINAL_TOOL_DESCRIPTION = /* @__PURE__ */ Symbol.for("wrongstack.tool.originalDescription");
@@ -5455,6 +5563,7 @@ export {
   MAX_INCOMING_IMAGES,
   MAX_INCOMING_IMAGE_BYTES,
   MAX_PATH_SEGMENT_LENGTH,
+  MAX_SUBJECT_LEN,
   PROJECT_IDENTITY_RELATIVE_PATH,
   PROJECT_IDENTITY_VERSION,
   PROJECT_ID_PREFIX,
@@ -5463,7 +5572,6 @@ export {
   TerminalLifecycle,
   WIRE_TOOL_NAME_MAX_LENGTH,
   WIRE_TOOL_NAME_PATTERN,
-  activeProfileName,
   applyToolDescriptionModeToTool,
   applyToolDescriptionModes,
   applyToolResultRenderModes,
@@ -5474,6 +5582,7 @@ export {
   atomicWrite,
   backupConfigFile,
   base64DecodedBytes,
+  bootstrapProfileName,
   buildChildEnv,
   buildCompletedWorkLedgerBlock,
   buildContextEvidenceDigest,
@@ -5483,6 +5592,7 @@ export {
   buildWin32CmdShimInvocation,
   canonicalProjectRoot,
   capSageLines,
+  capSubject,
   checkConnectivity,
   checkUnixSocketPath,
   coerceAgainstSchema,

package/dist/utils/regex-guard.d.ts

@@ -2,8 +2,13 @@
  * Compile a user-supplied regex with conservative bounds against ReDoS.
  *
  * Duplicated from @wrongstack/tools/_regex.ts to avoid a circular
- * dependency (tools depends on core, not vice versa). Keep both copies
- * in sync if the heuristics change.
+ * dependency (tools depends on core, not vice versa). There is a THIRD copy —
+ * `@wrongstack/kanban/src/verification/safe-regex.ts` — which sits below both
+ * in the workspace DAG for the same reason. This header used to say "keep
+ * both copies in sync", unaware of the third, and this copy had drifted the
+ * furthest: 2 of the 5 heuristics, a 512-character cap instead of 256, and no
+ * subject cap at all. `packages/tools/tests/regex-guard-parity.test.ts` now
+ * holds all three to the same verdicts — change one, change all three.
  *
  * V8's regex engine is backtracking-based and cannot interrupt a
  * synchronous match — a pattern like `(a+)+$` against a sufficiently
@@ -18,4 +23,13 @@ export interface CompileFail {
     reason: string;
 }
 export declare function compileUserRegex(pattern: string, flags: string): CompileResult | CompileFail;
+/**
+ * Truncate a subject line to a safe length for synchronous regex eval.
+ *
+ * The canonical copy has always shipped this; this one did not, so callers
+ * here bounded the pattern but never the SUBJECT — and a linear-time pattern
+ * over a multi-megabyte line is still a stall.
+ */
+export declare const MAX_SUBJECT_LEN: number;
+export declare function capSubject(line: string): string;
 //# sourceMappingURL=regex-guard.d.ts.map

package/dist/utils/sage-output-block.d.ts

@@ -1,11 +1,10 @@
 /**
- * sage-output-block — split the SAGE Memory Injector suffix off a tool result.
+ * sage-output-block — legacy replay support for inline SAGE tool-result suffixes.
  *
- * The SAGE middleware (`packages/sage/src/middleware/tool-call-memory.ts`)
- * appends a `--- SAGE: … (Memory Injector) ---` block to the tool result
- * content the model sees. That block is *memory*, not tool output, and every
- * surface renders it as its own card (TUI `SageMemoryBlock`, WebUI
- * `SageMemoryCard`).
+ * Current SAGE middleware stores retrievals in Context.memoryEvidence and the
+ * provider receives them as separate ephemeral system blocks. Older session
+ * logs may still contain a `--- SAGE: … (Memory Injector) ---` suffix inside a
+ * tool result, so replay surfaces retain this parser for compatibility.
  *
  * Surfaces used to recover the block by re-parsing the `tool.executed` event
  * `output` string — which is a ~400-char preview. When a tool's own output was
@@ -14,7 +13,7 @@
  * candidate, and the whole block fell through to the plain tool-output
  * renderer. The result was raw `--- SAGE: … ---` text dumped into the chat.
  *
- * So the split happens HERE, at the emit site, before any truncation:
+ * For those legacy payloads the split happens HERE, before any truncation:
  * `tool.executed.output` carries tool text only and the block travels
  * separately in `tool.executed.sage`. Surfaces that don't know about SAGE show
  * clean tool output instead of leaking the block, and surfaces that do render
@@ -22,9 +21,7 @@
  *
  * The headings and the memory-line shape mirror
  * `packages/tui/src/components/history/sage-output-format.ts` and
- * `packages/webui/src/lib/sage-block.ts`. Those two keep their own copies
- * because they also parse *replayed* sessions, where the block is still inline
- * in the persisted `tool_result` content. All three must agree.
+ * `packages/webui/src/lib/sage-block.ts`. All three must agree for old logs.
  */
 export interface SageOutputSplit {
     /** Tool result text with the SAGE block removed (trailing whitespace trimmed). */

package/dist/utils/wstack-paths.d.ts

@@ -130,8 +130,8 @@ export interface WstackPaths {
     syncConfig: string;
     /** ~/.wrongstack/config-history — timestamped backups on every config write */
     configHistoryDir: string;
-    /** Function to get the status.json path for a project given its hash. */
-    projectStatus: (projectHash: string) => string;
+    /** Function to get the status.json path for a validated project slug. */
+    projectStatus: (projectSlug: string) => string;
 }
 /**
  * Resolve the stable project identity root used by global WrongStack state.
@@ -167,8 +167,16 @@ export declare function safeProfileName(name: string | undefined): string;
 /**
  * Resolve the selected profile from ~/.wrongstack/config.json. The root file
  * is bootstrap metadata only; a missing/corrupt bootstrap selects `default`.
+ *
+ * Named for its SOURCE, not its meaning. This used to be `activeProfileName`,
+ * the same name `cli/src/profile-config-path.ts` exports for a function that
+ * reads the LIVE `Config` object instead of the bootstrap file on disk. Two
+ * functions, one name, two sources that can disagree — the settings menu
+ * writes `activeProfile` into the profile's own config, while `/profile use`
+ * writes the bootstrap and demands a restart. A caller autocompleting the
+ * wrong one gets a plausible answer about a different profile.
  */
-export declare function activeProfileName(globalRoot: string): string;
+export declare function bootstrapProfileName(globalRoot: string): string;
 /**
  * The global `~/.wrongstack` root, honoring the `WRONGSTACK_HOME` env
  * override. The override exists so tests (and sandboxed runs) can redirect

package/dist/worktree/index.js

@@ -466,11 +466,11 @@ var WorktreeManager = class {
     }
     const mergeArgs = squash ? ["merge", "--squash", handle.branch] : ["merge", "--no-ff", handle.branch];
     const merged = await this.runGit(mergeArgs, this.projectRoot);
-    if (merged.code !== 0) {
-      const fromOutput = parseConflictPaths(`${merged.stdout}
+    const fromOutput = parseConflictPaths(`${merged.stdout}
 ${merged.stderr}`);
-      const fromIndex = await this.unmergedFiles();
-      const conflictFiles = [.../* @__PURE__ */ new Set([...fromOutput, ...fromIndex])];
+    const fromIndex = await this.unmergedFiles();
+    const conflictFiles = [.../* @__PURE__ */ new Set([...fromOutput, ...fromIndex])];
+    if (merged.code !== 0 || conflictFiles.length > 0) {
       if (opts.resolve) {
         const finalized = await this.tryResolveConflict(handle, conflictFiles, opts);
         if (finalized) return finalized;

package/instructions/agents/browser.md

@@ -28,9 +28,6 @@ First-party browser tools (no MCP server configuration required):
   browser_upload(sessionId, selector, files) — confirmed project-local upload
   browser_close(sessionId)                 — close and return the trace artifact
 
-The optional Playwright MCP preset may coexist; its `playwright_*` names do not
-collide with the first-party `browser_*` namespace.
-
 Input format you accept:
 { "task": "navigate | screenshot | extract | interact | verify", "url": "<url>", "steps": ["step1", "step2"] }
 
@@ -49,4 +46,4 @@ Working rules:
 - Always browser_close when finished; run disposal also closes owned sessions as a safety net
 - If a selector fails, try alternative selectors before giving up
 - Report exact CSS selectors used — they're part of the evidence
-- If playwright tools are unavailable, report the error immediately — do not guess
+- If browser tools are unavailable, report the error immediately — do not guess

package/instructions/agents/e2e.md

@@ -4,23 +4,25 @@ 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)
+- Use the first-party browser tools (navigate, click, type, screenshot, evaluate)
   to automate web UI flows — open pages, interact with forms, capture evidence
 - Set up and tear down realistic test state
 - 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)     — open a page at the given URL
-  playwright_screenshot()      — capture a full-page or viewport screenshot
-  playwright_click(selector)   — click on an element matching a CSS selector
-  playwright_type(selector, text) — type text into a focused input element
-  playwright_evaluate(script)  — run arbitrary JavaScript in the page context
-  playwright_select_option(selector, value) — pick a <select> dropdown option
-  playwright_hover(selector)   — hover the mouse over an element
-  playwright_fill_form(fields) — fill multiple form fields in one call
-  playwright_wait_for(selector) — block until an element appears on the page
-  playwright_press_key(key)    — press a keyboard key (Enter, Tab, Escape, …)
-  playwright_drag(from, to)    — drag an element from one selector to another
+Browser tools available:
+  browser_open(url?)                       — open a session and return sessionId
+  browser_navigate(sessionId, url)         — navigate
+  browser_snapshot(sessionId)              — accessibility, console and network evidence
+  browser_screenshot(sessionId, ...)       — capture visual evidence
+  browser_click(sessionId, selector)       — click an element
+  browser_type(sessionId, selector, text)  — fill an input
+  browser_select(sessionId, selector, value) — select an option
+  browser_hover(sessionId, selector)       — hover an element
+  browser_wait(sessionId, selector?)       — bounded wait
+  browser_press(sessionId, key)            — press a key
+  browser_drag(sessionId, from, to)        — drag an element
+  browser_evaluate(sessionId, expression)  — confirmed page evaluation
+  browser_close(sessionId)                 — close the session and retain its trace
 
 Input format you accept:
 { "task": "scenario | smoke | journey", "flow": "<user journey>", "surface": "ui | cli | api" }
@@ -36,5 +38,5 @@ Working rules:
 - Make scenarios deterministic — control time, randomness, and external state
 - 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
+- For browser tests: browser_open first, then navigate/interact, capture browser_screenshot evidence, and browser_close
+- If the browser capability is unavailable, report it and fall back to API/CLI testing

package/instructions/agents/ios.md

@@ -25,7 +25,7 @@ installed before pinning specific CLI flags):
   / `-list` / scheme + destination selection; prefer `-resultBundlePath`
   for machine-readable results and pair with `xcrun xcresulttool get ...
   --legacy` or the modern JSON API for CI parsing
-- `xcrun simctl` for the Simulator: `list`, `boot`, `shutdown`, `install`,
+- `xcrun simctl` for the Simulator: `list`, `boot`, `shutdown`, the install subcommand,
   `launch`, `terminate`, `io`, `screenshot`, `log`, `privacy`, `push`,
   `erase`; run on every supported OS for the project's deployment target
 - `xcrun devicectl` for physical-device management (modern replacement
@@ -77,7 +77,7 @@ Output: Markdown iOS report:
 Working rules:
 - Default to Swift 6 language mode with strict concurrency; isolate
   mutable shared state in actors, never in globals
-- Use `async`/`await` and structured concurrency (TaskGroup,
+- Prefer Swift's `async`/`await` syntax and structured concurrency (TaskGroup,
   AsyncSequence); cancel long-running work and propagate cancellation
 - Prefer SwiftUI's `@Observable` macro on focused reference-type view
   models; reach for plain structs only when observation and identity
@@ -110,4 +110,4 @@ Working rules:
   "Approachable" means less annotation, not looser guarantees
 - Build with Xcode 26 and run the test suite on a real simulator
   before claiming a change is done; a green `xcodebuild` is the
-  minimum bar, not the goal
+  minimum bar, not the goal

package/instructions/agents/search.md

@@ -17,7 +17,7 @@ Output: Markdown result set:
 - ## Not Found (terms searched with zero hits, so the caller can rephrase)
 
 Working rules:
-- Read-only; prefer live `codebase-search` before broad grep/glob/tree exploration. If it reports no index, tell the caller to run `codebase-index`, then use the best read-only fallback; never edit or build the index yourself
+- Read-only; prefer live `codebase-search` before broad grep/glob/tree exploration. If it reports no index, tell the caller that indexing is required, then use the best read-only fallback; never edit or build the index yourself
 - Always rank by relevance and explain the ranking in one clause
 - Distinguish definition sites from usage sites explicitly
 - Report search terms that returned nothing so the caller can refine

package/instructions/autonomy/goal-preamble.md

@@ -8,8 +8,8 @@ YOUR GOAL:
 {{deliverables}}
 
 AUTHORITY YOU HAVE:
-- Spawn as many subagents as the work needs (delegate / spawn_subagent).
-  Parallel + recursive fan-out are both fine. There is no spawn budget.
+- Spawn as many subagents as the work needs when delegation capabilities are
+  available. Parallel + recursive fan-out are both fine. There is no spawn budget.
 - Use any provider/model per subagent — pick the right tool for each
   piece of work. Heavy reasoning model for planning, fast model for
   batch work, specialist model for domain code.
@@ -58,8 +58,8 @@ PERSISTENCE PROTOCOL:
 - If a subagent returns useless output, respawn with a tighter prompt
   or a different role. Do not accept "I could not determine…" as the
   final answer.
-- Use `ask_subagent` for one-shot questions when you don't need a
-  full delegated task.
+- Use a one-shot worker question when you don't need a full delegated task and
+  that capability is available.
 
 REPORTING:
 - Stream short progress notes between major actions so the user can

package/instructions/coordination/director-preamble.md

@@ -43,9 +43,8 @@ results, and return an evidence-backed fleet outcome.
 - `work_complete` stops new spawning and winds the fleet down while running
   workers finish naturally.
 
-Use synchronous `delegate` only when one worker verdict gates your very next
-step. For controlled fan-out, use `spawn_subagent` → `assign_task` →
-`await_tasks`; sequential blocking delegation wastes concurrency.
+For controlled fan-out, use `spawn_subagent` → `assign_task` →
+`await_tasks`, processing results as soon as their dependencies allow.
 
 ## Dispatch contract