@wrongstack/core 0.306.4 → 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/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,7 +671,7 @@ 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
@@ -3054,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 {
@@ -3095,6 +3097,7 @@ function startSessionTelemetryBridge(opts) {
     startedAt
   );
   let lastSnapshotHash = "";
+  let lastPublishedAtMs = Date.now();
   let disposed = false;
   function buildSnapshot() {
     return {
@@ -3122,6 +3125,7 @@ function startSessionTelemetryBridge(opts) {
     lastSnapshotHash = hash;
     try {
       publisher.publishSessionSnapshot(snap);
+      lastPublishedAtMs = Date.now();
     } catch {
     }
   }
@@ -3184,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

@@ -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