@wrongstack/core 0.308.7 → 0.309.0

package/dist/kernel/events/agent-events.d.ts

@@ -144,8 +144,8 @@ export interface AgentEventMap {
     /**
      * A spawn resolved fewer skills than it selected. Emitted so a skill that
      * silently failed to load — missing from the loader, gated by a capability
-     * the subagent lacks, or cut by the prompt budget — is observable instead of
-     * leaving the agent believing it received guidance it never got.
+     * the subagent lacks, or cut by the prompt budget — is observable instead
+     * of leaving the agent believing it received guidance it never got.
      */
     'subagent.skills.dropped': {
         sessionId?: string | undefined;
@@ -155,6 +155,35 @@ export interface AgentEventMap {
         /** skill → reason it was dropped. */
         dropped: Record<string, string>;
     };
+    /**
+     * In-band graceful-finish request for a background subagent (see
+     * coordination/subagent-finish.ts). Emitted on the subagent's OWN EventBus
+     * when its wall-clock deadline is crossed — or the leader explicitly asked
+     * it to finish (session shutdown) — and the subagent's config opted into
+     * `gracefulFinish`. The runner folds the notice into the conversation as a
+     * `/btw` note at the next iteration boundary; the model then completes its
+     * task in its own turn within the granted grace window. This event is a
+     * notification, never an interrupt: nothing aborts when it fires.
+     */
+    'subagent.finish_requested': {
+        /** Parent/host session id. */
+        sessionId?: string | undefined;
+        /**
+         * Owning subagent id when the budget knows it; omitted when the budget
+         * was constructed without one. An empty string would look like an
+         * address that matches nothing — the runner treats an omitted id as
+         * deliverable (`if (e.subagentId && …)`), so omission is safe.
+         */
+        subagentId?: string | undefined;
+        /** Why the finish was requested (deadline crossed / leader finished). */
+        reason: string;
+        /** Epoch ms by which the subagent should have produced its final output. */
+        deadlineMs: number;
+        /** Granted working-time window in ms. */
+        graceMs: number;
+        /** Ready-to-read notice text; the loop folds it in as a `/btw` note. */
+        notice: string;
+    };
     /**
      * A background learning-distillation pass finished for a roster role.
      * Emitted by the fleet host's auto-optimize scheduler so surfaces can show

package/dist/models/index.js

@@ -877,7 +877,17 @@ function normalizeModelsDevModel(model) {
   const reasoningConfig = {
     default: disableSupported ? "enabled" : "always_on",
     disableSupported,
-    effortSupported: effortLevels.length > 0,
+    // Tri-state (see ReasoningConfig.effortSupported):
+    //   options present  → documented answer (true when effort values exist;
+    //                      an explicitly EMPTY array is a documented "no
+    //                      effort control", not an absent field).
+    //   field ABSENT     → the model is known to reason but its vocabulary is
+    //                      undocumented → `undefined`, so the resolver forwards
+    //                      the request and each wire adapter applies its own
+    //                      transport gating. Sending `false` here would make
+    //                      the resolver claim "does not support effort" — an
+    //                      assertion the catalog never made.
+    ...raw === void 0 ? {} : { effortSupported: effortLevels.length > 0 },
     effortLevels,
     preserveThinking: model.interleaved ? "always_on" : "unsupported"
   };

package/dist/types/index.d.ts

@@ -34,7 +34,7 @@ export { BUILTIN_PROMPT_CATEGORIES, isBuiltinCategory, PROMPT_CATEGORY_LABELS }
 export type { InstalledPromptEntry, ManifestValidation, PromptManifestData, PromptRegistryManifest, PromptRegistryRef, RegistryDiff, } from './prompt-registry.js';
 export { diffRegistry, validateRegistryManifest } from './prompt-registry.js';
 export type { CacheTtl, Capabilities, JsonSchemaSpec, Provider, ProviderContextLimit, ProviderErrorBody, ProviderErrorKind, ReasoningConfig, ReasoningEffort, ReasoningRequest, Request, RequestCacheControl, Response, ResponseFormat, SafetySetting, StopReason, StreamEvent, Usage, } from './provider.js';
-export { classifyProviderError, effectiveInputTokens, isContextOverflowShaped, isFallbackWorthy, isRetryableKind, ProviderError, StreamHangError, } from './provider.js';
+export { classifyProviderError, effectiveInputTokens, isContextOverflowShaped, isFallbackWorthy, isReasoningEffort, isRetryableKind, ProviderError, REASONING_EFFORT_LEVELS, StreamHangError, } from './provider.js';
 export type { ProviderRunner, RunProviderOptions } from './provider-runner.js';
 export type { Renderer } from './renderer.js';
 export type { SecretScrubber } from './secret-scrubber.js';

package/dist/types/index.js

@@ -914,6 +914,18 @@ function truncate(s, max) {
 var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)(?:\s+(?:has|have))?(?:\s+been)?[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit|usage[-_\s]*limit[-_\s]*(?:reached|exceeded)/i;
 
 // src/types/provider.ts
+var REASONING_EFFORT_LEVELS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function isReasoningEffort(value) {
+  return typeof value === "string" && REASONING_EFFORT_LEVELS.includes(value);
+}
 function effectiveInputTokens(usage) {
   return usage.input + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
 }
@@ -1346,6 +1358,7 @@ export {
   ParseError,
   PluginError,
   ProviderError,
+  REASONING_EFFORT_LEVELS,
   SESSION_MARKER_EVENT_TYPES,
   SYSTEM_INJECTION_PREFIXES,
   SddError,
@@ -1377,6 +1390,7 @@ export {
   isImageBlock,
   isParseError,
   isPluginError,
+  isReasoningEffort,
   isRetryableKind,
   isSddError,
   isSessionError,

package/dist/types/multi-agent.d.ts

@@ -142,6 +142,21 @@ export interface SubagentConfig {
         end: string;
         mode?: 'advisory' | 'enforce' | undefined;
     } | undefined;
+    /**
+     * Model-driven completion policy. When set, this subagent is NEVER killed
+     * by the wall-clock watchdog at its deadline: instead the deadline (or an
+     * explicit `Director.requestFinish()`) triggers an in-band
+     * `subagent.finish_requested` notification that the agent loop folds into
+     * the conversation between tool batches — the model then finishes its task
+     * in its own turn within `graceMs` of legitimate working time. Only after
+     * that grace window elapses does the existing terminal stop apply, so the
+     * subagent still has a bounded maximum lifetime.
+     *
+     * `undefined` (default) keeps the legacy watchdog behavior unchanged.
+     */
+    gracefulFinish?: boolean | {
+        graceMs?: number | undefined;
+    } | undefined;
     /**
      * Runtime request overrides for THIS subagent. When present, these are merged
      * over the leader's `Config.modelRuntime` before the subagent request pipeline

package/dist/types/provider.d.ts

@@ -23,6 +23,21 @@ import type { Tool } from './tool.js';
  * cached tokens twice and skew cache-hit-ratio reporting.
  */
 export type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/**
+ * The canonical runtime list of {@link ReasoningEffort} values, in
+ * menu/display order. Single source of truth for every surface that needs to
+ * iterate the levels (CLI `/settings` + `/setmodel`, the TUI picker, the
+ * WebUI dropdown) — import this instead of re-declaring a local array, which
+ * is how drift crept in before.
+ *
+ * `satisfies` pins the literal to the union: a value here core's type doesn't
+ * know is a compile error. Note the reverse is NOT caught — core adding a
+ * level does not force this array to grow, so consumers validating user input
+ * against it must decide deliberately whether to expose the new level.
+ */
+export declare const REASONING_EFFORT_LEVELS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+/** Type guard for untrusted strings (CLI args, WS payloads, config files). */
+export declare function isReasoningEffort(value: unknown): value is ReasoningEffort;
 export type CacheTtl = '5m' | '1h';
 /**
  * Provider-agnostic response-format directive.
@@ -119,7 +134,20 @@ export interface RequestCacheControl {
 export interface ReasoningConfig {
     default: 'enabled' | 'disabled' | 'adaptive' | 'always_on';
     disableSupported: boolean;
-    effortSupported: boolean;
+    /**
+     * Tri-state effort support:
+     *   `true`      — the catalog documents this model's effort levels
+     *                 (`effortLevels` is authoritative).
+     *   `false`     — the catalog documents effort control as absent
+     *                 (toggle-only or budget_tokens-only reasoning options).
+     *   `undefined` — the model is known to reason (`reasoning: true`) but its
+     *                 effort vocabulary is not documented. The resolver forwards
+     *                 the requested effort; each wire adapter then applies its
+     *                 own transport-level gating (allowlist, mapping, or omit),
+     *                 so an undocumented model can only match-or-omit — never
+     *                 receive a field shape it did not advertise.
+     */
+    effortSupported?: boolean | undefined;
     effortLevels: ReasoningEffort[];
     preserveThinking: 'unsupported' | 'optional' | 'always_on';
 }

package/instructions/agents/chaos-monkey.md

@@ -0,0 +1,57 @@
+You are the Chaos Monkey ("Kaos Maymunu") — a mutation-testing saboteur for the
+WrongStack fleet. Your job is to prove whether a test suite actually pins down
+the code it claims to cover, by deliberately breaking that code and watching
+which mutants survive.
+
+Core belief: green tests prove nothing if they cannot detect sabotage. A mutant
+that survives means the tests are fake or insufficient — and that is the most
+valuable finding you can return.
+
+## Your task contract
+
+The director hands you a mutation plan: an exact list of mutation ids, each with
+file, line, column, kind, original token and replacement token. The plan is
+authoritative — you NEVER invent, move, or "improve" mutations. Your freedom is
+execution order and diagnosis, never the mutation set.
+
+## Check pass (per mutant)
+
+1. Apply exactly ONE mutation from the plan to its anchored (file, line, column).
+   If the anchored token no longer matches `original`, mark the mutant
+   `skipped` with the drift as evidence — do not hunt for a "similar" site.
+2. Run the provided test command exactly as given.
+3. Record the outcome:
+   - Tests fail → mutant `killed` (quote the first failing assertion).
+   - Tests pass → mutant `survived` (this is a weak-test finding, not your failure).
+4. Restore the original source byte-for-byte before moving to the next mutant.
+   The suite is only honest if every mutant ran against pristine code except
+   its own single mutation.
+
+## Hard rules
+
+- **One mutation at a time.** Never stack mutants; a stacked run measures nothing.
+- **Always restore.** Your worktree must be clean of sabotage at the end of the
+  pass. If restore fails, stop and report which file is left mutated.
+- **Stay inside the plan's files.** No refactors, no fixes, no formatting churn
+  — even when the mutated code looks wrong to you. You are the saboteur, not
+  the reviewer.
+- **Deterministic.** Same plan + same suite → same report.
+- **One-shot lifecycle.** Finish the assigned pass, submit the report, stop.
+
+## Report
+
+Submit via `submit_result`, then repeat it as your final text (fenced JSON):
+
+```json
+{
+  "summary": "<one line: N killed / M survived / K skipped>",
+  "mutants": [
+    { "id": "<plan id>", "file": "...", "line": 0, "kind": "...",
+      "status": "killed | survived | skipped",
+      "evidence": "<failing assertion, or 'suite green' for survivors>" }
+  ]
+}
+```
+
+Order survivors first — they are the actionable findings. For each survivor,
+name the boundary or behavior the tests failed to assert.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/core",
-  "version": "0.308.7",
+  "version": "0.309.0",
   "license": "MIT",
   "description": "WrongStack core: kernel, types, defaults, and shared utilities for the WrongStack CLI agent.",
   "repository": {
@@ -182,8 +182,8 @@
   "wrongstackApiVersion": "0.1.10",
   "dependencies": {
     "zod": "4.4.3",
-    "@wrongstack/persistence": "0.308.7",
-    "@wrongstack/kanban": "0.308.7"
+    "@wrongstack/kanban": "0.309.0",
+    "@wrongstack/persistence": "0.309.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",