@wrongstack/core 0.306.3 → 0.307.0

package/dist/execution/prompt-enhancer.js

@@ -228,6 +228,11 @@ function isValidEnglishRefinement(text) {
   const scores = languageScores(trimmed);
   return scores.nonEnglish === 0 && scores.english > 0;
 }
+var VIBE_TAG_PATTERN = /\[vibe\]/iu;
+function preserveVibeTag(original, candidate) {
+  if (!VIBE_TAG_PATTERN.test(original) || VIBE_TAG_PATTERN.test(candidate)) return candidate;
+  return `[VIBE] ${candidate}`;
+}
 function latestMessageLanguage(text) {
   const scores = languageScores(text);
   if (scores.nonEnglish > scores.english) return "non_english";
@@ -240,9 +245,12 @@ function parseBilingualEnhancement(raw, original) {
   if (matches.length !== 1) return null;
   const [match] = matches;
   if (!match) return null;
-  const refined = raw.slice(0, match.index).trim();
-  const english = raw.slice(match.index + match[0].length).trim();
-  if (!refined || !english || !isValidEnglishRefinement(english)) return null;
+  const rawRefined = raw.slice(0, match.index).trim();
+  const rawEnglish = raw.slice(match.index + match[0].length).trim();
+  if (!rawRefined || !rawEnglish) return null;
+  const refined = preserveVibeTag(original, rawRefined);
+  const english = preserveVibeTag(original, rawEnglish);
+  if (!isValidEnglishRefinement(english)) return null;
   const inputLanguage = latestMessageLanguage(original);
   const refinedLanguage = latestMessageLanguage(refined);
   if (inputLanguage === "non_english" && refinedLanguage === "english") return null;

package/dist/execution/retry-policy.d.ts

@@ -1,5 +1,32 @@
 import { ProviderError } from '../types/provider.js';
 import type { RetryPolicy } from '../types/retry-policy.js';
+/**
+ * Retries a single model gets before the turn moves on to the next entry in
+ * the fallback chain.
+ *
+ * One number for every recoverable failure kind, on purpose. The per-kind
+ * budgets used to range from 2 (timeout, network, stream_hang) to 5
+ * (rate_limit), which made "how long until we try another model?" depend on
+ * which error came back: a rate-limited model could spend five backoff waits —
+ * each honouring a `Retry-After` up to 60s — before the cross-model fallback
+ * engine, which only engages once in-place retries are exhausted, got its
+ * turn, while a timeout gave up after two. The contract is now uniform and
+ * predictable across every surface that runs the agent loop (leader, host
+ * subagents, Chimera reviewers, SDD workers — they all resolve this one
+ * policy from the container): try the model {@link MODEL_RETRIES} times, then
+ * fail over.
+ *
+ * Exhaustive by construction (`Record<ProviderErrorKind, …>`) — adding a new
+ * kind refuses to compile until it gets an attempt budget.
+ *
+ * Zero means "do not replay this request against this model":
+ * - request-shaped failures (auth / invalid_request / context_overflow /
+ *   content_filter) would fail identically on every attempt;
+ * - `quota_exhausted` is a depleted account or plan, not a transient burst, so
+ *   the route is done until it resets — retrying only delays the hop, and the
+ *   kind IS fallback-worthy, so another provider gets tried immediately.
+ */
+export declare const MODEL_RETRIES = 3;
 export declare class DefaultRetryPolicy implements RetryPolicy {
     shouldRetry(err: Error | ProviderError, attempt: number): boolean;
     maxAttempts(err: Error | ProviderError): number;

package/dist/execution/tool-executor-guard.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '../core/context.js';
+import { evaluateToolKanbanBoundary } from '../security/kanban-boundary.js';
+import type { ToolResultBlock, ToolUseBlock } from '../types/blocks.js';
+import type { Tool } from '../types/tool.js';
+import type { ToolExecutorOptions } from '../types/tool-executor.js';
+export type KanbanBoundaryResult = Awaited<ReturnType<typeof evaluateToolKanbanBoundary>>;
+export interface PreExecutionValidationResult {
+    ok: boolean;
+    use: ToolUseBlock;
+    errorResult?: ToolResultBlock | undefined;
+    preToolContext?: {
+        text: string;
+        contextAs: 'inline' | 'separate';
+    } | undefined;
+    boundary?: KanbanBoundaryResult | undefined;
+}
+export declare function validateToolInputAndHooks(tool: Tool, use0: ToolUseBlock, ctx: Context, opts: ToolExecutorOptions): Promise<PreExecutionValidationResult>;
+//# sourceMappingURL=tool-executor-guard.d.ts.map

package/dist/execution/tool-executor-runner.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '../core/context.js';
+import type { Tool } from '../types/tool.js';
+import type { ToolExecutorOptions } from '../types/tool-executor.js';
+export declare function runToolCleanup(tool: Tool, input: unknown, ctx: Context): Promise<void>;
+export declare function runToolWithTimeout(tool: Tool, input: unknown, parentSignal: AbortSignal, ctx: Context, opts: ToolExecutorOptions, config: {
+    iterationTimeoutMs: number;
+    maxToolTimeoutMs: number;
+    progressEmitIntervalMs: number;
+    progressTailChars: number;
+    progressHeadChars: number;
+}, toolUseId?: string | undefined): Promise<unknown>;
+//# sourceMappingURL=tool-executor-runner.d.ts.map

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

@@ -20,53 +20,13 @@ export declare class ToolExecutor {
         get(name: string): Tool | undefined;
         list(): Tool[];
     }, opts: ToolExecutorOptions);
-    /**
-     * Clear the interactive confirm awaiter so the executor returns
-     * `ToolConfirmPendingResult` instead of blocking on stdin. Used by
-     * the CLI to switch from inline prompts (REPL) to event-driven
-     * confirmation (TUI) at runtime.
-     */
     clearConfirmAwaiter(): void;
-    /**
-     * Push the tool's per-tool result-render mode into the renderer as the
-     * next-result render mode. The config key is `tools.resultRenderMode[name]`
-     * — independent of the LLM-side `descriptionMode` so the two can be
-     * toggled separately (`/tool read desc simple` vs `/tool read result
-     * simple`). Defaults to `extend` when no entry is set.
-     *
-     * The hint is one-shot: the renderer consumes it on the next
-     * `writeToolResult` call so an unset follow-up doesn't inherit a
-     * previous tool's mode. Safe no-op when the renderer doesn't implement
-     * `setResultRenderMode` (e.g. headless/test renderers).
-     */
     private hintRenderMode;
     private logToolSuccess;
     private logToolFailure;
-    /**
-     * Execute a batch of tool uses using the configured strategy.
-     * Returns the execution results and the remaining output budget.
-     */
     executeBatch(toolUses: ToolUseBlock[], ctx: Context, strategy: ToolExecutorStrategy): Promise<ToolBatchResult>;
-    /**
-     * Internal batch implementation. Nested meta-tool calls enter here through
-     * the governed bridge so they traverse the same validation, hooks,
-     * permission/capability, timeout, scrubbing, and audit path without
-     * replacing the bridge that is already active for the outer call.
-     */
     private executeBatchInternal;
-    /**
-     * Install the executor-owned bridge used by meta-tools for nested calls.
-     * The bridge deliberately returns the governed, scrubbed ToolResultBlock
-     * content rather than the raw tool value. This prevents a meta-tool from
-     * bypassing output controls while preserving structured success/failure.
-     */
     private withGovernedExecutionBridge;
-    /**
-     * Execute a single tool with timeout and output capping after its permission
-     * decision has already been resolved by executeBatch/the confirmation flow.
-     * Also installs the governed bridge because confirmed tools are re-run
-     * through this method after a pending confirmation.
-     */
     executeTool(tool: Tool, use: ToolUseBlock, ctx: Context, budget: number, preToolContext?: {
         text: string;
         contextAs: 'inline' | 'separate';
@@ -74,44 +34,9 @@ export declare class ToolExecutor {
         block: ToolResultBlock;
         bytes: number;
     }>;
-    /**
-     * Async "produce" phase: run the tool, serialize, scrub, and spill an
-     * oversized output to a disk artifact. Returns the pre-cap text. This is
-     * the long-running, concurrency-safe part — it touches NO shared budget
-     * state, so multiple invocations can run in parallel without racing.
-     *
-     * The `budgetHint` only gates the disk-spill threshold (a heuristic for
-     * "is this output large enough to persist"); it is NOT the output cap.
-     * The authoritative cap is applied synchronously in settleToolOutput()
-     * against the live budget.
-     */
     private produceToolOutput;
-    /**
-     * Synchronous "settle" phase: enforce the output cap against the CURRENT
-     * budget, render, and build the result block. This MUST stay synchronous
-     * (no awaits) so that, in the parallel/smart strategies, two tools settling
-     * one after another against the shared closure budget can't interleave a
-     * stale read with a write. The first to settle consumes its bytes; the next
-     * settles against the reduced budget; once the budget hits 0, enforceCap
-     * truncates — making the per-iteration cap genuinely CUMULATIVE across
-     * parallel tools instead of degrading into a per-tool cap.
-     */
     private settleToolOutput;
     private runWithTimeout;
-    /** Best-effort tool cleanup; never let it mask the original error. */
-    private runToolCleanup;
-    private runStreamedTool;
-    /**
-     * Subtract a string-content result's UTF-8 byte length from the
-     * iteration output budget. Used for synthesized results (unknown tool,
-     * validation error, blocked, threw) where the content is a small
-     * string built in the executor. The success path no longer goes
-     * through here — `executeTool` carries the exact byte count it spent
-     * in its return value, derived from `enforceCap`'s `newBudget`.
-     *
-     * Floors the result at 0 to match the pre-fix `decrementBudget`
-     * semantics (over-budget spends don't underflow the running total).
-     */
     private budgetForString;
 }
 //# sourceMappingURL=tool-executor.d.ts.map

package/dist/goal/index.js

@@ -1113,7 +1113,7 @@ function getReadyPhases(graph) {
     if (phase.status !== "pending") continue;
     const depsDone = phase.dependsOn.every((depId) => {
       const dep = graph.phases.get(depId);
-      return dep?.status === "completed" || dep?.status === "skipped" || dep?.status === "failed";
+      return dep?.status === "completed" || dep?.status === "skipped";
     });
     if (depsDone) {
       ready.push(phase);
@@ -1143,9 +1143,7 @@ function getCompletedTaskCount(trackerFor, phase) {
 }
 function isGraphComplete(graph) {
   const allPhases = Array.from(graph.phases.values());
-  return allPhases.every(
-    (p) => p.status === "completed" || p.status === "skipped" || p.status === "failed"
-  );
+  return allPhases.every((p) => p.status === "completed" || p.status === "skipped");
 }
 function getProgress(graph, trackerFor) {
   const phases = Array.from(graph.phases.values());
@@ -1243,6 +1241,7 @@ async function failPhaseAfterTasks(int, phase, error) {
   phase.actualDurationMs = Date.now() - (phase.startedAt ?? Date.now());
   int.runningPhases.delete(phase.id);
   int.graph.activePhaseIds = int.graph.activePhaseIds.filter((id) => id !== phase.id);
+  if (!int.graph.failedPhaseIds.includes(phase.id)) int.graph.failedPhaseIds.push(phase.id);
   int.emit("phase.failed", { phaseId: phase.id, name: phase.name, error });
   int.ctx.onPhaseFail?.(phase, new Error(error));
   await keepWorktreeForReview(int, phase);
@@ -1454,7 +1453,10 @@ var PhaseOrchestrator = class {
       maxVerifyAttempts: opts.maxVerifyAttempts ?? 2,
       autonomous: opts.autonomous ?? true,
       phaseDelayMs: opts.phaseDelayMs ?? 0,
-      stopOnFailure: opts.stopOnFailure ?? false,
+      // Autonomous goals must fail closed. Continuing after a terminal task or
+      // gate failure can make dependent phases look complete without their
+      // required evidence.
+      stopOnFailure: opts.stopOnFailure ?? true,
       taskTimeoutMs: opts.taskTimeoutMs ?? 6e5,
       events: this.events
     };
@@ -1594,6 +1596,13 @@ var PhaseOrchestrator = class {
     }
     this.emit("phase.started", { phaseId: phase.id, name: phase.name });
     try {
+      if (phase.taskGraph.nodes.size === 0) {
+        await this.failPhaseAfterTasks(
+          phase,
+          "Phase has no executable tasks. Add task evidence before starting this phase."
+        );
+        return;
+      }
       await this.executePhaseTasks(phase);
       const failedTasks = this.getFailedTaskCount(phase);
       const completedTasks = this.getCompletedTaskCount(phase);
@@ -2248,8 +2257,12 @@ ${ctx}
     for (const entry of data) {
       const result = this.coercePhase(entry);
       if (result) {
-        phases.push(result.phase);
         warnings.push(...result.warnings);
+        if (result.phase.taskTemplates?.length) {
+          phases.push(result.phase);
+        } else {
+          warnings.push(`Phase "${result.phase.name}" has no executable tasks and was rejected.`);
+        }
       }
     }
     return { phases, warnings };

package/dist/hq/index.js

@@ -671,10 +671,28 @@ var HQ_TRANSCRIPT_TEXT_CAP = 16e3;
 import { randomUUID } from "node:crypto";
 import * as v8 from "node:v8";
 
-// src/coordination/mailbox-types.ts
+// src/coordination/mailbox-predicates.ts
 var SESSION_RECIPIENT_PREFIX = "@session:";
 
 // src/security/secret-scrubber.ts
+var JSON_CREDENTIAL_KEY_ANCHORS = [
+  'Key"',
+  'key"',
+  'KEY"',
+  'token"',
+  'Token"',
+  'TOKEN"',
+  'secret"',
+  'Secret"',
+  'SECRET"',
+  'password"',
+  'Password"',
+  'PASSWORD"',
+  'authorization"',
+  'Authorization"',
+  'bearer"',
+  'Bearer"'
+];
 var PATTERNS = [
   // Anchored at the start where possible so partial matches inside larger
   // strings don't trigger false positives.
@@ -777,6 +795,30 @@ var PATTERNS = [
     regex: /(^|\s)([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?(?=\s|$)/g,
     anchor: ["KEY", "TOKEN", "SECRET", "PASSWORD", "PWD"]
   },
+  {
+    type: "json_credential_key",
+    // The JSON counterpart to `high_entropy_env`, and the pattern that the
+    // now-deleted `JSON_KEY_ANCHORS` list was written for. Without it those
+    // anchors only widened the cheap pre-scan — `hasCredentialAnchors` said
+    // "this text may hold a secret", every pattern then declined to match, and
+    // the value went out verbatim. `high_entropy_env` cannot cover these: it
+    // requires an UPPERCASE unquoted key (`API_KEY=…`), so `{"apiKey":"…"}`
+    // never matched.
+    //
+    // Tool results are routinely serialised as JSON, and a credential with no
+    // recognisable prefix (Azure, self-hosted gateways, Anthropic/Codex OAuth)
+    // has no other pattern that can catch it — this is the only thing standing
+    // between such a value and the session JSONL, chronicle, HQ broadcast and
+    // the model's own context.
+    //
+    // The key may carry a prefix (`"anthropicApiKey"`), but the credential word
+    // must END the key: `"tokenCount"` and `"maxTokens"` do not match, because
+    // the closing quote has to follow the word immediately.
+    // Value floor of 8 chars keeps enum-ish values (`"authorization":"none"`)
+    // out. Capture groups: 1=key + punctuation, 2=value, 3=closing quote.
+    regex: /("[A-Za-z0-9_]*(?:apiKey|api_key|token|secret|password|authorization|bearer|private_key|access_token|refresh_token|client_secret)"\s*:\s*")([^"\\]{8,512})(")/gi,
+    anchor: JSON_CREDENTIAL_KEY_ANCHORS
+  },
   // ── Ported from packages/plugins credential-patterns.ts (WS-034) ─────────
   // The plugin runtime carried 37 patterns while this scrubber — the one that
   // guards session JSONL, chronicle, HQ broadcast, WebUI events and the auth
@@ -859,9 +901,12 @@ var PATTERNS = [
     anchor: "GOCSPX-"
   }
 ];
-var SIMPLE_PATTERNS = PATTERNS.filter((p) => p.type !== "high_entropy_env");
+var SIMPLE_PATTERNS = PATTERNS.filter(
+  (p) => p.type !== "high_entropy_env" && p.type !== "json_credential_key"
+);
 var COMBINED_REGEX = new RegExp(SIMPLE_PATTERNS.map((p) => `(${p.regex.source})`).join("|"), "g");
 var HIGH_ENTROPY_REGEX = PATTERNS.find((p) => p.type === "high_entropy_env").regex;
+var JSON_CREDENTIAL_REGEX = PATTERNS.find((p) => p.type === "json_credential_key").regex;
 var COMBINED_REPLACEMENTS = SIMPLE_PATTERNS.map((p) => `[REDACTED:${p.type}]`);
 var SCRUB_CHUNK_BYTES = 64 * 1024;
 var SCRUB_OVERLAP_BYTES = 1024;
@@ -872,20 +917,7 @@ var PATTERN_ANCHORS = [
     )
   )
 ];
-var JSON_KEY_ANCHORS = [
-  '"apiKey"',
-  '"api_key"',
-  '"token"',
-  '"secret"',
-  '"password"',
-  '"authorization"',
-  '"bearer"',
-  '"private_key"',
-  '"access_token"',
-  '"refresh_token"',
-  '"client_secret"'
-];
-var ALL_ANCHORS = [...PATTERN_ANCHORS, ...JSON_KEY_ANCHORS];
+var ALL_ANCHORS = PATTERN_ANCHORS;
 function hasCredentialAnchors(text) {
   for (const anchor of ALL_ANCHORS) {
     if (text.includes(anchor)) return true;
@@ -934,6 +966,9 @@ var DefaultSecretScrubber = class {
     out = out.replace(HIGH_ENTROPY_REGEX, (_match, lead, key, _value) => {
       return `${lead}${key}=[REDACTED:high_entropy_env]`;
     });
+    out = out.replace(JSON_CREDENTIAL_REGEX, (_match, keyPrefix, _value, closingQuote) => {
+      return `${keyPrefix}[REDACTED:json_credential_key]${closingQuote}`;
+    });
     return out;
   }
   /**
@@ -3019,6 +3054,8 @@ var VALID_AGENT_STATUS = /* @__PURE__ */ new Set([
 ]);
 var MAX_TRANSCRIPT_BATCH_ENTRIES = 32;
 var MAX_TRANSCRIPT_BATCH_BYTES = 512 * 1024;
+var HQ_STALE_SNAPSHOT_WINDOW_MS = 5 * 6e4;
+var KEEPALIVE_REPUBLISH_MS = Math.floor(HQ_STALE_SNAPSHOT_WINDOW_MS * 0.8);
 function toAgentSummary(a) {
   const status = VALID_AGENT_STATUS.has(a.status) ? a.status : "idle";
   return {
@@ -3060,6 +3097,7 @@ function startSessionTelemetryBridge(opts) {
     startedAt
   );
   let lastSnapshotHash = "";
+  let lastPublishedAtMs = Date.now();
   let disposed = false;
   function buildSnapshot() {
     return {
@@ -3087,6 +3125,7 @@ function startSessionTelemetryBridge(opts) {
     lastSnapshotHash = hash;
     try {
       publisher.publishSessionSnapshot(snap);
+      lastPublishedAtMs = Date.now();
     } catch {
     }
   }
@@ -3149,7 +3188,9 @@ function startSessionTelemetryBridge(opts) {
   let seqEmitted = 0;
   let watcher = null;
   let tailTimer = null;
-  const snapshotTimer = setInterval(() => publishSnapshot(true), opts.snapshotIntervalMs ?? 2500);
+  const snapshotTimer = setInterval(() => {
+    publishSnapshot(Date.now() - lastPublishedAtMs >= KEEPALIVE_REPUBLISH_MS);
+  }, opts.snapshotIntervalMs ?? 2500);
   snapshotTimer.unref?.();
   if (!opts.writer?.setOnAppend) {
     let setupWatcher2 = function() {

package/dist/index.d.ts

@@ -48,7 +48,7 @@ export { Context, type ContextInit, type ProviderMemoryEvidence, type RunOptions
 export { type ContinuationInput, type ContinuationSource, detectContinueIntent, type ResolvedContinuation, resolveContinuation, } from './core/continue-intent.js';
 export { type ContinueDirective, makeContinueToNextIterationTool, parseContinueDirective, } from './core/continue-to-next-iteration.js';
 export { ConversationState, type ReadonlyConversationState, type StateChange, type StateChangeHandler, wrapAsState, } from './core/conversation-state.js';
-export { createFallbackModelExtension, effectiveFallbackChain, type FallbackModelDeps, fallbackProfileChain, formatModelRef, normalizeModelRef, parseModelRef, smartDefaultFallbackChain, } from './core/fallback-model.js';
+export { createFallbackModelExtension, effectiveFallbackChain, type FallbackModelDeps, fallbackProfileChain, formatModelRef, normalizeModelRef, parseModelRef, runtimeFallbackChain, smartDefaultFallbackChain, } from './core/fallback-model.js';
 export type { FallbackChain, FallbackChainEntry, ProviderHealth, } from './core/fallback-profile-manager.js';
 export { FallbackProfileManager } from './core/fallback-profile-manager.js';
 export { InputBuilder, type InputBuilderEvent, type InputBuilderOptions, } from './core/input-builder.js';
@@ -151,4 +151,5 @@ export { readBundledInstructionText, renderInstructionTemplate, } from './utils/
 export { safeParse, safeStringify, sanitizeJsonString, stripCodeFences, } from './utils/safe-json.js';
 export { getTermSize, isInteractive, isStdinTTY, isStdoutTTY, type OutputLineGuard, onResize, setOutputLineGuard, setRawMode, writeErr, writeOut, } from './utils/term.js';
 export { type AllocateOpts, assertSafePath, type MergeOpts, type MergeResult, type WorktreeHandle, WorktreeManager, type WorktreeManagerOptions, type WorktreeRunResult, type WorktreeStatus, } from './worktree/index.js';
+export { ensureGitignore, getPromptJournalEntries, recordPromptJournalEntry, type PromptCategory, type PromptJournalEntry, type PromptJournalFilter, type RecordPromptOptions, } from './prompts/index.js';
 //# sourceMappingURL=index.d.ts.map