@wrongstack/core 0.281.1 → 0.282.0

package/dist/utils/index.d.ts

@@ -1,14 +1,125 @@
-import { E as CompletedWorkSource, d as Context, G as ContextEvidenceState, D as CompletedWorkEvidence, o as ToolOutputMetadata, J as JSONSchema, M as Message, y as TodoItem, g as Tool } from '../tool-LVSLiE1s.js';
+import { M as Message, E as CompletedWorkSource, d as Context, G as ContextEvidenceState, D as CompletedWorkEvidence, o as ToolOutputMetadata, J as JSONSchema, y as TodoItem, g as Tool } from '../tool-LVSLiE1s.js';
 export { H as HttpDispatcher, a as HttpsAgentAsDispatcher } from '../dispatcher-types.d-BBeXBQgS.js';
 export { toErrorMessage } from './error.js';
 export { expectDefined } from './expect-defined.js';
-import { y as CustomModelDefinition, c as ModelsDevPayload, a3 as ToolDescriptionMode, a4 as ToolDescriptionModeConfig, T as ToolResultRenderMode, a5 as ToolResultRenderModeConfig } from '../config-CN-vdDEI.js';
+import { y as CustomModelDefinition, c as ModelsDevPayload, a3 as ToolDescriptionMode, a4 as ToolDescriptionModeConfig, T as ToolResultRenderMode, a5 as ToolResultRenderModeConfig } from '../config-BCAEJicb.js';
 export { T as TaskItem, c as computeTaskItemProgress, f as formatTaskList, a as formatTaskProgress } from '../task-format-vGOIftmK.js';
 export { a as WstackPathOptions, W as WstackPaths, p as projectHash, b as projectSlug, r as resolveWstackPaths, w as wstackGlobalRoot } from '../wstack-paths-C3K40Qst.js';
 export { a as TaskPriority, b as TaskStatus, T as TaskType } from '../task-graph-u1q9Jkyk.js';
 import 'node:https';
 import 'undici';
 
+/**
+ * Estimate tokens for a tool_use block input.
+ * Caches the stringified result keyed by the stable string representation
+ * to avoid repeated JSON.stringify calls during context window checks.
+ */
+declare function estimateToolInputTokens(input: unknown): number;
+/**
+ * Estimate tokens for a tool_result content.
+ */
+declare function estimateToolResultTokens(content: string | unknown): number;
+/**
+ * Estimate tokens for a text block.
+ */
+declare function estimateTextTokens(text: string): number;
+/**
+ * Compute and cache the token estimate for a single message. This is the
+ * canonical per-message estimator — called once by ConversationState on
+ * append/replace so the O(n·m) content-block walk happens at mutation time,
+ * not on every context-pressure check.
+ */
+declare function computeMessageTokens(msg: Message): number;
+/**
+ * Estimate tokens for an array of messages (text + tool I/O), using the shared
+ * 3.5 chars/token basis. This is the single canonical message-array estimator —
+ * compactors, the context_manager tool, and the `/context` display all route
+ * through it so the number a user sees matches the number compaction decides on.
+ *
+ * When a message carries a pre-computed `_estTokens` field (set by
+ * ConversationState on append/replace), it is used directly instead of
+ * re-walking the content blocks — turning the O(n·m) scan into an O(n)
+ * sum for fully-cached arrays.
+ */
+declare function estimateMessageTokens(messages: readonly Message[]): number;
+/**
+ * Rough estimate of tokens in a tool definition (name + description + schema).
+ * Accounts for the JSON-serialized inputSchema which is sent to the API
+ * but NOT included in roughEstimate(content).
+ */
+declare function estimateToolDefTokens(tool: {
+    name: string;
+    description?: string | undefined;
+    inputSchema: unknown;
+}): number;
+/**
+ * Estimate the total API request token count: system prompt + tool definitions
+ * + conversation messages. Use this for context-window bar calculations
+ * instead of roughEstimate (which only counts messages).
+ *
+ * The overhead ratio (overhead / messages) varies by conversation length:
+ *   - Short conversations (< 10 messages): ~30-50% overhead (large system+tools)
+ *   - Medium (10-50 messages): ~15-30%
+ *   - Long (> 50 messages): ~5-15%
+ *
+ * Returns { messages, systemPrompt, tools, total } for debugging display.
+ */
+interface RequestTokenBreakdown {
+    messages: number;
+    systemPrompt: number;
+    tools: number;
+    total: number;
+}
+declare function estimateRequestTokens(messages: unknown, systemPrompt: unknown, tools: {
+    name: string;
+    description?: string | undefined;
+    inputSchema: unknown;
+}[], calibrationKey?: string): RequestTokenBreakdown;
+/**
+ * Record the actual API input token count after a provider call so
+ * `estimateRequestTokensCalibrated` can self-correct on subsequent calls.
+ *
+ * Prefer passing `estimatedInputTokens` explicitly (the calibrated pre-flight
+ * estimate from the middleware) — this avoids race conditions when other code
+ * also calls `estimateRequestTokens` between the pre-flight and this call
+ * (e.g. audit logging in agent.ts).
+ *
+ * When `estimatedInputTokens` is omitted, falls back to the keyed bucket's
+ * `prevEst` for backward compatibility with callers that don't have the
+ * pre-flight value. `calibrationKey` selects the per-(provider,model) bucket
+ * (defaults to the shared global bucket).
+ */
+declare function recordActualUsage(actualInputTokens: number, estimatedInputTokens?: number, calibrationKey?: string): void;
+/**
+ * Returns the current calibration state for a bucket. Exposed for debugging
+ * and tests — not needed by normal callers.
+ */
+declare function getCalibrationState(calibrationKey?: string): {
+    ratio: number;
+    count: number;
+    calibrated: boolean;
+};
+/**
+ * Like `estimateRequestTokens` but applies the rolling calibration factor
+ * so context pressure readings converge on reality within a few iterations.
+ *
+ * Before any `recordActualUsage` samples are collected, returns the same
+ * result as `estimateRequestTokens` (ratio = 1.0, no distortion).
+ * After `MIN_SAMPLES_FOR_CALIBRATION` samples, applies the calibrated
+ * multiplier capped to the range [0.5, 1.5] as a sanity bound.
+ */
+declare function estimateRequestTokensCalibrated(messages: unknown, systemPrompt: unknown, tools: {
+    name: string;
+    description?: string | undefined;
+    inputSchema: unknown;
+}[], calibrationKey?: string): RequestTokenBreakdown;
+/**
+ * Resets calibration state. Primarily for tests that run in the same
+ * process and need a clean slate between suites. With no argument it clears
+ * every bucket (including the global one); pass a key to reset just that bucket.
+ */
+declare function resetCalibration(calibrationKey?: string): void;
+
 /**
  * Exhaustiveness check for discriminated union switches.
  * Place in the `default` branch of a switch over a union type
@@ -638,117 +749,6 @@ declare function normalizePathSubject(value: string): string;
 declare function isPathSubjectKey(subjectKey: string): boolean;
 declare function subjectForToolInput(toolName: string, input: unknown, subjectKey?: string): string | undefined;
 
-/**
- * Estimate tokens for a tool_use block input.
- * Caches the stringified result keyed by the stable string representation
- * to avoid repeated JSON.stringify calls during context window checks.
- */
-declare function estimateToolInputTokens(input: unknown): number;
-/**
- * Estimate tokens for a tool_result content.
- */
-declare function estimateToolResultTokens(content: string | unknown): number;
-/**
- * Estimate tokens for a text block.
- */
-declare function estimateTextTokens(text: string): number;
-/**
- * Compute and cache the token estimate for a single message. This is the
- * canonical per-message estimator — called once by ConversationState on
- * append/replace so the O(n·m) content-block walk happens at mutation time,
- * not on every context-pressure check.
- */
-declare function computeMessageTokens(msg: Message): number;
-/**
- * Estimate tokens for an array of messages (text + tool I/O), using the shared
- * 3.5 chars/token basis. This is the single canonical message-array estimator —
- * compactors, the context_manager tool, and the `/context` display all route
- * through it so the number a user sees matches the number compaction decides on.
- *
- * When a message carries a pre-computed `_estTokens` field (set by
- * ConversationState on append/replace), it is used directly instead of
- * re-walking the content blocks — turning the O(n·m) scan into an O(n)
- * sum for fully-cached arrays.
- */
-declare function estimateMessageTokens(messages: readonly Message[]): number;
-/**
- * Rough estimate of tokens in a tool definition (name + description + schema).
- * Accounts for the JSON-serialized inputSchema which is sent to the API
- * but NOT included in roughEstimate(content).
- */
-declare function estimateToolDefTokens(tool: {
-    name: string;
-    description?: string | undefined;
-    inputSchema: unknown;
-}): number;
-/**
- * Estimate the total API request token count: system prompt + tool definitions
- * + conversation messages. Use this for context-window bar calculations
- * instead of roughEstimate (which only counts messages).
- *
- * The overhead ratio (overhead / messages) varies by conversation length:
- *   - Short conversations (< 10 messages): ~30-50% overhead (large system+tools)
- *   - Medium (10-50 messages): ~15-30%
- *   - Long (> 50 messages): ~5-15%
- *
- * Returns { messages, systemPrompt, tools, total } for debugging display.
- */
-interface RequestTokenBreakdown {
-    messages: number;
-    systemPrompt: number;
-    tools: number;
-    total: number;
-}
-declare function estimateRequestTokens(messages: unknown, systemPrompt: unknown, tools: {
-    name: string;
-    description?: string | undefined;
-    inputSchema: unknown;
-}[], calibrationKey?: string): RequestTokenBreakdown;
-/**
- * Record the actual API input token count after a provider call so
- * `estimateRequestTokensCalibrated` can self-correct on subsequent calls.
- *
- * Prefer passing `estimatedInputTokens` explicitly (the calibrated pre-flight
- * estimate from the middleware) — this avoids race conditions when other code
- * also calls `estimateRequestTokens` between the pre-flight and this call
- * (e.g. audit logging in agent.ts).
- *
- * When `estimatedInputTokens` is omitted, falls back to the keyed bucket's
- * `prevEst` for backward compatibility with callers that don't have the
- * pre-flight value. `calibrationKey` selects the per-(provider,model) bucket
- * (defaults to the shared global bucket).
- */
-declare function recordActualUsage(actualInputTokens: number, estimatedInputTokens?: number, calibrationKey?: string): void;
-/**
- * Returns the current calibration state for a bucket. Exposed for debugging
- * and tests — not needed by normal callers.
- */
-declare function getCalibrationState(calibrationKey?: string): {
-    ratio: number;
-    count: number;
-    calibrated: boolean;
-};
-/**
- * Like `estimateRequestTokens` but applies the rolling calibration factor
- * so context pressure readings converge on reality within a few iterations.
- *
- * Before any `recordActualUsage` samples are collected, returns the same
- * result as `estimateRequestTokens` (ratio = 1.0, no distortion).
- * After `MIN_SAMPLES_FOR_CALIBRATION` samples, applies the calibrated
- * multiplier capped to the range [0.5, 1.5] as a sanity bound.
- */
-declare function estimateRequestTokensCalibrated(messages: unknown, systemPrompt: unknown, tools: {
-    name: string;
-    description?: string | undefined;
-    inputSchema: unknown;
-}[], calibrationKey?: string): RequestTokenBreakdown;
-/**
- * Resets calibration state. Primarily for tests that run in the same
- * process and need a clean slate between suites. With no argument it clears
- * every bucket (including the global one); pass a key to reset just that bucket.
- */
-declare function resetCalibration(calibrationKey?: string): void;
-
 /**
  * Tool output serialization utilities.
  * Extracted from Agent.executeTools to allow reuse and consistent output handling.

package/dist/{worktree-manager-C6CIilTT.d.ts → worktree-manager-BBXdJq-Y.d.ts}

@@ -1,4 +1,4 @@
-import { E as EventBus } from './events-C5hLU0AT.js';
+import { E as EventBus } from './events-CovDylaH.js';
 
 /**
  * Lifecycle of a single worktree handle.

package/instructions/agents/reviewer.md

@@ -0,0 +1,25 @@
+You are the Reviewer agent. Your job is independent quality control over
+another agent's work. You do not implement; you inspect the output, evidence,
+and changed files, then decide whether the work is safe to accept.
+
+Scope:
+- Review changed code, tests, commands run, and the implementer's final report
+- Look for correctness bugs, missing edge cases, weak verification, and scope creep
+- Identify uncertainty explicitly instead of smoothing it over
+- Reduce correlated error risk by challenging assumptions the implementer likely made
+
+Input format you accept:
+{ "task": "review", "implementation": "<summary or task id>", "targets": ["src/x.ts"], "evidence": "<tests/logs/diff>" }
+
+Output: Markdown review:
+- ## Verdict (approve / request changes / needs verification)
+- ## Must Fix (file:line, bug, concrete fix)
+- ## Verification Gaps (checks that must run before acceptance)
+- ## Uncertainty Flags (assumptions, missing context, confidence)
+- ## Notes (non-blocking observations)
+
+Working rules:
+- Read-only: never edit files or run mutating commands
+- Treat "tests not run" or vague verification as a finding
+- Every blocking finding needs a file:line or a reproducible missing check
+- If you cannot prove a claim, mark it as uncertain and say what would prove it

package/instructions/agents/verifier.md

@@ -0,0 +1,24 @@
+You are the Verifier agent. Your job is to prove whether a change works by
+running the right checks and turning failures into actionable feedback.
+
+Scope:
+- Identify the smallest meaningful verification set for the task
+- Run lint, typecheck, unit, integration, or smoke checks as appropriate
+- Re-run checks after an implementer fixes failures until the gate is green
+- Report exact failures when the gate is not green
+
+Input format you accept:
+{ "task": "verify", "targets": ["src/x.ts"], "commands": ["pnpm test"], "expected": "<behavior>" }
+
+Output: Markdown verification report:
+- ## Verdict (pass / fail / blocked)
+- ## Commands Run (command, cwd, result)
+- ## Failures (exact failing test/error and likely owner)
+- ## Evidence (relevant output excerpts, durations)
+- ## Uncertainty Flags (missing env, skipped checks, flaky behavior)
+
+Working rules:
+- Do not edit code. Verification is independent of implementation.
+- Prefer project-native commands over invented ones.
+- If a check fails, stop claiming completion and return the precise failure.
+- If no reliable command exists, describe the manual or missing verification gate.

package/instructions/coordination/director-preamble.md

@@ -36,12 +36,34 @@ Working rules:
   6. Never claim a subagent's work as your own without verifying it. If a
      result looks wrong, ask_subagent for clarification before passing it
      to the user.
-  7. **Act on subagent mail immediately**. Subagent messages (result, ask,
+  7. Treat implementation as a quality-gated loop, not a one-shot. For
+     code-changing work, "done" means: implementer report received,
+     verifier evidence is green (tests/typecheck/lint/smoke as relevant),
+     and reviewer has no must-fix findings. If verification or review fails,
+     feed the concrete failures back to the implementer and repeat until the
+     gate passes or a real blocker is identified. Prefer `quality_gate` for
+     this standard reviewer+verifier loop; use low-level spawn/assign/await
+     only when you need custom choreography.
+  8. Prefer isolated git worktrees for side-effectful parallel subagents so
+     two agents do not write the same checkout at the same time. This is a
+     preference, not a law: read-only review/research agents can stay on the
+     shared cwd, and the host may disable worktrees for workflows that cannot
+     use them. Use the `worktree` spawn override only when there is a reason
+     (`required` for risky parallel editing, `off` for truly read-only work).
+  9. Use the dedicated `verifier` role for independent proof and the
+     dedicated `reviewer` role for independent AI review. Prefer pinning
+     reviewer with `/setmodel set reviewer <provider>/<model>` or a review
+     phase route; otherwise WrongStack will try to avoid using the same
+     provider/model as the implementation lane.
+  10. Self-flag uncertainty. When you or a subagent are guessing, missing
+     evidence, or relying on an assumption, surface that as an uncertainty
+     flag and route it to reviewer/verifier instead of presenting it as fact.
+  11. **Act on subagent mail immediately**. Subagent messages (result, ask,
      assign, note) are injected inline before every step — even mid-task.
      When you see one, address it before continuing: reply to asks, factor
      in results, act on assignments. Use `mailbox action=ack` to mark
      completed messages.
-  8. Wind down when satisfied. When the results are good enough, call
+  12. Wind down when satisfied. When the results are good enough, call
      work_complete — no new subagents will spawn and queued tasks complete
      as aborted. Running subagents finish naturally. Call terminate_subagent
      only for ones you need to stop immediately.

package/instructions/coordination/subagent-baseline.md

@@ -8,6 +8,9 @@ Capabilities & operating rules:
     permission to read, edit, or build.
   - Stay inside the project root. Do not touch machine config, credentials,
     or global state — those require an explicit grant you do not have.
+  - Respect your current working directory. When the Director gives you an
+    isolated git worktree, all reads/writes/build commands for this task belong
+    in that checkout; do not switch back to the parent checkout to edit files.
   - Prefer the least-destructive path. No irreversible commands (`rm -rf`,
     `git push --force`, history rewrites, dropping databases, mass deletes)
     unless the task explicitly requires it and names the target.
@@ -15,6 +18,10 @@ Capabilities & operating rules:
     tests and fix what you broke before reporting done.
   - Make only the changes the task calls for — no unrelated refactors or
     reformatting.
+  - Self-flag uncertainty. If your conclusion depends on an assumption,
+    skipped check, flaky result, missing file, or incomplete evidence, include
+    an "Uncertainty Flags" section in your final output instead of smoothing
+    it over.
 
 Bridge contract:
   - You may call `request` on the parent bridge to ask the Director a
@@ -24,7 +31,7 @@ Bridge contract:
   - Your final task output is all the Director sees. Be concise, structured,
     and self-contained — assume it is pasted into the Director's context.
     Cover: what you accomplished, what you changed (files/commands), how it
-    was verified, and any blockers or leftovers. Never end with a bare
+    was verified, uncertainty flags, and any blockers or leftovers. Never end with a bare
     "done" — an unverifiable report forces the Director to redo your work.
 
 CRITICAL CONSTRAINT — NO FURTHER DELEGATION:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/core",
-  "version": "0.281.1",
+  "version": "0.282.0",
   "license": "MIT",
   "description": "WrongStack core: kernel, types, defaults, and shared utilities for the WrongStack CLI agent.",
   "repository": {