jeopi-cli 16.2.13 → 16.2.14

package/src/task/critic-gate.ts

@@ -0,0 +1,148 @@
+/**
+ * Critic gate — the hard, code-enforced counterpart of the prompt rule
+ * "You NEVER execute a plan whose latest critic verdict is not `okay`".
+ *
+ * When a `critic` subagent completes with a schema-validated verdict, the
+ * parent session records it here. While the latest verdict is `iterate` or
+ * `reject` the runtime — not the prompt — blocks execution:
+ *
+ * - `task` refuses to spawn non-read-only agents (read-only lanes such as
+ *   `plan`, `explore`, and `critic` itself stay open so the plan can be
+ *   revised and re-gated).
+ * - Working-tree mutations through `write`/`edit`/patch are rejected; the
+ *   `local://` artifact sandbox stays writable for seeds, plans, and notes.
+ *
+ * The gate clears in exactly two ways: a subsequent critic verdict of `okay`,
+ * or the next user-authored prompt (the user regaining control is the only
+ * override — mirroring jeo-code's `approve` hard gate, scoped to a turn-chain
+ * instead of a state file).
+ *
+ * A strike counter bounds the iterate loop: after
+ * {@link CRITIC_GATE_MAX_STRIKES} consecutive non-okay verdicts without user
+ * input, even re-submitting to `critic` is refused — the agent must stop and
+ * report the surviving gaps instead of burning tokens on convergence-free
+ * re-planning.
+ */
+
+/** Agent name whose structured verdicts drive the gate. */
+export const CRITIC_AGENT_NAME = "critic";
+
+/** Consecutive non-okay verdicts allowed before the gate forces a stop-and-report. */
+export const CRITIC_GATE_MAX_STRIKES = 3;
+
+/** Non-okay verdicts that engage the gate. */
+export type CriticGateVerdict = "iterate" | "reject";
+
+/** Gate state held by the parent session while the latest verdict is not `okay`. */
+export interface CriticGateState {
+	/** Latest non-okay verdict. */
+	verdict: CriticGateVerdict;
+	/** Agent id of the critic run that produced the verdict. */
+	agentId: string;
+	/** Epoch ms when the verdict was recorded. */
+	at: number;
+	/** `required_fixes` from the critic's structured output (empty for reject without fixes). */
+	requiredFixes: string[];
+	/** Consecutive non-okay verdicts since the last okay/user prompt. */
+	strikes: number;
+}
+
+/** Verdict parsed from a critic subagent's validated structured output. */
+export interface ParsedCriticVerdict {
+	verdict: "okay" | CriticGateVerdict;
+	requiredFixes: string[];
+	summary?: string;
+}
+
+/**
+ * Parse a critic verdict from the subagent's final output payload (the
+ * JSON-serialized, schema-validated yield data). Returns undefined when the
+ * payload is not a critic-shaped verdict — the gate then stays untouched.
+ */
+export function parseCriticVerdict(output: string): ParsedCriticVerdict | undefined {
+	let data: unknown;
+	try {
+		data = JSON.parse(output);
+	} catch {
+		return undefined;
+	}
+	if (data === null || typeof data !== "object") return undefined;
+	const record = data as Record<string, unknown>;
+	const verdict = record.verdict;
+	if (verdict !== "okay" && verdict !== "iterate" && verdict !== "reject") return undefined;
+	const rawFixes = record.required_fixes;
+	const requiredFixes = Array.isArray(rawFixes)
+		? rawFixes.filter((fix): fix is string => typeof fix === "string")
+		: [];
+	const summary = typeof record.summary === "string" ? record.summary : undefined;
+	return { verdict, requiredFixes, summary };
+}
+
+/**
+ * Fold a new verdict into the gate state. `okay` clears the gate; a non-okay
+ * verdict engages it and increments the consecutive-strike counter.
+ */
+export function updateCriticGateState(
+	previous: CriticGateState | undefined,
+	parsed: ParsedCriticVerdict,
+	agentId: string,
+	now: number = Date.now(),
+): CriticGateState | undefined {
+	if (parsed.verdict === "okay") return undefined;
+	return {
+		verdict: parsed.verdict,
+		agentId,
+		at: now,
+		requiredFixes: parsed.requiredFixes,
+		strikes: (previous?.strikes ?? 0) + 1,
+	};
+}
+
+function formatRequiredFixes(state: CriticGateState): string {
+	if (state.requiredFixes.length === 0) return "";
+	const bullets = state.requiredFixes.map(fix => `- ${fix}`).join("\n");
+	return `\nUnresolved required fixes:\n${bullets}`;
+}
+
+function gateSummaryLine(state: CriticGateState): string {
+	return `Critic gate engaged: the latest critic verdict (from \`${state.agentId}\`) was \`${state.verdict}\`, not \`okay\`.`;
+}
+
+/**
+ * Decide whether a spawn is allowed under the current gate state. Returns the
+ * rejection message when blocked, undefined when allowed.
+ *
+ * Read-only agents (plan revision, exploration, re-gating via critic) stay
+ * allowed — except that once the strike budget is exhausted, even a fresh
+ * critic run is refused so the loop terminates at the user instead of cycling.
+ */
+export function evaluateCriticGateSpawn(
+	state: CriticGateState | undefined,
+	agentName: string,
+	agentIsReadOnly: boolean,
+): string | undefined {
+	if (!state) return undefined;
+	if (agentName === CRITIC_AGENT_NAME && state.strikes >= CRITIC_GATE_MAX_STRIKES) {
+		return (
+			`Critic gate: ${state.strikes} consecutive non-okay critic verdicts without user input — the iterate loop is closed. ` +
+			`Do NOT re-submit to critic. Stop and report the surviving gaps to the user; the gate clears on the next user message.${formatRequiredFixes(state)}`
+		);
+	}
+	if (agentIsReadOnly) return undefined;
+	return (
+		`${gateSummaryLine(state)} Spawning non-read-only agent "${agentName}" is blocked by the runtime, not just the prompt. ` +
+		`To proceed: revise the plan (read-only \`plan\` agent), re-submit to a fresh \`critic\`, and execute only after an \`okay\` verdict — or stop and report to the user (the gate clears on the next user message).${formatRequiredFixes(state)}`
+	);
+}
+
+/**
+ * Error text for a working-tree mutation attempted while the gate is engaged.
+ * The `local://` sandbox is exempt (seeds/plans/notes live there); callers
+ * check that before invoking this.
+ */
+export function criticGateWriteMessage(state: CriticGateState): string {
+	return (
+		`${gateSummaryLine(state)} The working tree is locked until a critic returns \`okay\` for the revised plan ` +
+		`(or the user sends a new message). Write plans and notes to local:// files instead.${formatRequiredFixes(state)}`
+	);
+}

package/src/task/discovery.ts

@@ -2,8 +2,8 @@
  * Agent discovery from filesystem.
  *
  * Discovers agent definitions from OMP-native task-agent roots:
- *   - ~/.omp/agent/agents/*.md (user-level)
- *   - .omp/agents/*.md (project-level)
+ *   - ~/.jeopi/agent/agents/*.md (user-level)
+ *   - .jeopi/agents/*.md (project-level)
  *
  * Claude Code marketplace plugin agents are discovered separately via the
  * claude-plugins provider. Direct cross-harness roots such as .claude/agents
@@ -15,14 +15,14 @@
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
-import { logger } from "jeopi-utils";
+import { CONFIG_DIR_NAME, logger } from "jeopi-utils";
 import { isProviderEnabled } from "../capability";
 import { findAllNearestProjectConfigDirs, getConfigDirs } from "../config";
 import { listClaudePluginRoots } from "../discovery/helpers";
 import { loadBundledAgents, parseAgent } from "./agents";
 import type { AgentDefinition, AgentSource } from "./types";
 
-const TASK_AGENT_CONFIG_SOURCE = ".omp";
+const TASK_AGENT_CONFIG_SOURCE = CONFIG_DIR_NAME;
 
 /** Result of agent discovery */
 export interface DiscoveryResult {
@@ -55,7 +55,7 @@ async function loadAgentsFromDir(dir: string, source: AgentSource): Promise<Agen
 /**
  * Discover agents from filesystem and merge with bundled agents.
  *
- * Precedence (highest wins): project .omp, user .omp, Claude plugin agents, then bundled
+ * Precedence (highest wins): project .jeopi, user .jeopi, Claude plugin agents, then bundled
  * @param cwd - Current working directory for project agent discovery
  */
 export async function discoverAgents(cwd: string, home: string = os.homedir()): Promise<DiscoveryResult> {

package/src/task/executor.ts

@@ -342,7 +342,7 @@ export interface ExecutorOptions {
 	preloadedExtensionPaths?: string[];
 	/**
 	 * Parent's discovered custom-tool source paths. Forwarded to skip the
-	 * `.omp/tools/` FS scan in the subagent; the subagent then re-binds each
+	 * `.jeopi/tools/` FS scan in the subagent; the subagent then re-binds each
 	 * tool against its own `CustomToolAPI` (cwd, exec, pushPendingAction, UI).
 	 */
 	preloadedCustomToolPaths?: ToolPathWithSource[];

package/src/task/index.ts

@@ -3,8 +3,8 @@
  *
  * Discovers agent definitions from:
  *   - Bundled agents (shipped with omp-coding-agent)
- *   - ~/.omp/agent/agents/*.md (user-level)
- *   - .omp/agents/*.md (project-level)
+ *   - ~/.jeopi/agent/agents/*.md (user-level)
+ *   - .jeopi/agents/*.md (project-level)
  *
  * Supports:
  *   - Single agent spawn per call (parallelism = parallel task calls)
@@ -48,6 +48,7 @@ import type { AsyncJobManager } from "../async";
 import type { LocalProtocolOptions } from "../internal-urls";
 import { loadOverallPlanReference } from "../plan-mode/plan-handoff";
 import { AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
+import { CRITIC_AGENT_NAME, evaluateCriticGateSpawn, parseCriticVerdict, updateCriticGateState } from "./critic-gate";
 import { type DiscoveryResult, discoverAgents, getAgent } from "./discovery";
 import { runSubprocess } from "./executor";
 import {
@@ -1118,6 +1119,21 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			};
 		}
 
+		// Critic gate: while the latest critic verdict is non-okay, only
+		// read-only agents may spawn (plan revision / re-gating); execution
+		// lanes are blocked by the runtime, not just the prompt.
+		const criticGateRejection = evaluateCriticGateSpawn(
+			this.session.getCriticGateState?.(),
+			agentName,
+			isReadOnlyAgent(agent),
+		);
+		if (criticGateRejection) {
+			return {
+				content: [{ type: "text", text: criticGateRejection }],
+				details: { projectAgentsDir, results: [], totalDurationMs: 0 },
+			};
+		}
+
 		const planModeState = this.session.getPlanModeState?.();
 		const planModeBaseTools = ["read", "grep", "glob", "lsp", "web_search"];
 		const planModeTools = [
@@ -1388,6 +1404,23 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 
 			const result = await runTask();
 
+			// Record critic verdicts into the session's hard execution gate. Only
+			// clean, schema-validated completions move the gate — a failed or
+			// aborted critic run leaves the previous state untouched.
+			if (
+				agent.name === CRITIC_AGENT_NAME &&
+				this.session.setCriticGateState &&
+				result.exitCode === 0 &&
+				!result.aborted
+			) {
+				const parsed = parseCriticVerdict(result.output);
+				if (parsed) {
+					this.session.setCriticGateState(
+						updateCriticGateState(this.session.getCriticGateState?.(), parsed, result.id),
+					);
+				}
+			}
+
 			let mergeSummary = "";
 			let changesApplied: boolean | null = null;
 			let mergedBranchForNestedPatches = false;

package/src/tools/acp-bridge.ts

@@ -3,7 +3,7 @@
  *
  * When an ACP client (e.g. Zed) advertises the `fs.writeTextFile` capability,
  * all write-mode tools must route through it so the editor's open buffer is
- * updated immediately. Internal artifacts ('/Users/theo/.omp/agent/sessions/-Projects-oh-my-pi/2026-06-10T09-11-41-506Z_019eb0cd-3ec2-7000-92aa-1b82aa4d78f0/local' plan files, other scheme
+ * updated immediately. Internal artifacts ('/Users/theo/.jeopi/agent/sessions/-Projects-oh-my-pi/2026-06-10T09-11-41-506Z_019eb0cd-3ec2-7000-92aa-1b82aa4d78f0/local' plan files, other scheme
  * URLs) are always written directly to disk — those are OMP-owned and should
  * never be pushed into the editor.
  */
@@ -16,7 +16,7 @@ import { ToolError } from "./tool-errors";
 /**
  * Return `true` when an ACP client bridge write is appropriate for this path.
  *
- * Returns `false` for internal-URL paths (e.g. `'/Users/theo/.omp/agent/sessions/-Projects-oh-my-pi/2026-06-10T09-11-41-506Z_019eb0cd-3ec2-7000-92aa-1b82aa4d78f0/local/PLAN.md'`) and for the
+ * Returns `false` for internal-URL paths (e.g. `'/Users/theo/.jeopi/agent/sessions/-Projects-oh-my-pi/2026-06-10T09-11-41-506Z_019eb0cd-3ec2-7000-92aa-1b82aa4d78f0/local/PLAN.md'`) and for the
  * active plan file while plan mode is enabled — both are OMP-internal artifacts
  * that must stay off the editor's buffer.
  */

package/src/tools/browser/launch.ts

@@ -101,7 +101,7 @@ async function loadBrowsers(): Promise<typeof BrowsersNs> {
 /**
  * Lazily download Chromium on first browser launch via @puppeteer/browsers.
  * Skipped when a system Chromium (NixOS) or PUPPETEER_EXECUTABLE_PATH is set.
- * The browser is cached under ~/.omp/puppeteer (getPuppeteerDir).
+ * The browser is cached under ~/.jeopi/puppeteer (getPuppeteerDir).
  */
 let chromiumExecutablePromise: Promise<string | undefined> | undefined;
 async function ensureChromiumExecutable(): Promise<string | undefined> {

package/src/tools/index.ts

@@ -27,6 +27,7 @@ import type { CustomMessage } from "../session/messages";
 import type { UsageStatistics } from "../session/session-entries";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue";
 import { TaskTool } from "../task";
+import type { CriticGateState } from "../task/critic-gate";
 import type { AgentOutputManager } from "../task/output-manager";
 import { canSpawnAtDepth } from "../task/types";
 import { countToolsForAutoDiscovery, resolveEffectiveToolDiscoveryMode } from "../tool-discovery/mode";
@@ -187,7 +188,7 @@ export interface ToolSession {
 	 */
 	extensionPaths?: string[];
 	/**
-	 * Pre-discovered custom-tool source paths from `.omp/tools/`, `.claude/tools/`,
+	 * Pre-discovered custom-tool source paths from `.jeopi/tools/`, `.claude/tools/`,
 	 * plugins, etc. Forwarded to subagents so they skip the FS scan but still
 	 * re-bind tools to their own session-scoped `CustomToolAPI`.
 	 */
@@ -273,6 +274,10 @@ export interface ToolSession {
 	getPlanModeState?: () => PlanModeState | undefined;
 	/** Path of the session's active plan reference (e.g. `local://<title>.md`); defaults to `local://PLAN.md`. */
 	getPlanReferencePath?: () => string;
+	/** Critic gate state — engaged after a non-okay `critic` verdict; cleared by an okay verdict or the next user prompt. */
+	getCriticGateState?: () => CriticGateState | undefined;
+	/** Replace the critic gate state (undefined clears the gate). */
+	setCriticGateState?: (state: CriticGateState | undefined) => void;
 	/** Goal mode state (if active or paused) */
 	getGoalModeState?: () => GoalModeState | undefined;
 	/** Goal runtime for the active agent session. */

package/src/tools/plan-mode-guard.ts

@@ -7,6 +7,7 @@ import {
 	resolveLocalUrlToPath,
 	resolveVaultUrlToPath,
 } from "../internal-urls";
+import { criticGateWriteMessage } from "../task/critic-gate";
 import type { ToolSession } from ".";
 import { normalizeLocalScheme, resolveToCwd } from "./path-utils";
 import { ToolError } from "./tool-errors";
@@ -136,6 +137,7 @@ export function enforcePlanModeWrite(
 	targetPath: string,
 	options?: { move?: string; op?: "create" | "update" | "delete" },
 ): void {
+	enforceCriticGateWrite(session, targetPath);
 	const state = session.getPlanModeState?.();
 	if (!state?.enabled) return;
 
@@ -153,3 +155,17 @@ export function enforcePlanModeWrite(
 		"Plan mode: the working tree is read-only. Write your plan to a local://<slug>-plan.md file instead.",
 	);
 }
+
+/**
+ * Critic gate — while the session's latest critic verdict is not `okay`,
+ * working-tree mutations are rejected at the runtime level. The `local://`
+ * artifact sandbox stays writable (seeds, plans, and scratch notes live
+ * there). Runs inside {@link enforcePlanModeWrite} so every mutating tool
+ * (`write`, `edit` replace/patch/hashline) hits one choke point.
+ */
+export function enforceCriticGateWrite(session: ToolSession, targetPath: string): void {
+	const gate = session.getCriticGateState?.();
+	if (!gate) return;
+	if (targetsLocalSandbox(session, targetPath)) return;
+	throw new ToolError(criticGateWriteMessage(gate));
+}

package/src/tools/report-tool-issue.ts

@@ -187,7 +187,7 @@ let cachedDb: Database | null = null;
 
 /**
  * Open (or return the cached handle for) the auto-QA SQLite database at
- * `~/.omp/agent/autoqa.db`. Idempotently runs schema creation, the
+ * `~/.jeopi/agent/autoqa.db`. Idempotently runs schema creation, the
  * `pushed`-column migration, and index setup so every consumer — tool
  * execute path, manual `jeopi grievances push`, future debug scripts —
  * sees the same prepared schema. Returns `null` only on a hard open
@@ -474,7 +474,7 @@ export function createReportToolIssueTool(session: ToolSession, activeBuiltinNam
 		intent: "omit",
 		async execute(_toolCallId, rawParams) {
 			// Save is unconditional: the row lives in the user's own SQLite
-			// at ~/.omp/agent/autoqa.db regardless of consent — they always
+			// at ~/.jeopi/agent/autoqa.db regardless of consent — they always
 			// own their local data and can inspect or wipe it via `jeopi grievances`.
 			// Consent only gates whether the row is *shipped* to the shared
 			// backend; that decision rides on `dev.autoqa.consent` and is

package/src/utils/changelog.ts

@@ -106,8 +106,8 @@ export function getNewEntries(entries: ChangelogEntry[], lastVersion: string): C
 export { getChangelogPath } from "../config";
 
 /**
- * Last omp version whose changelog the user has seen. Stored as a plain-text
- * marker file (`~/.omp/agent/last-changelog-version`) rather than in
+ * Last jeopi version whose changelog the user has seen. Stored as a plain-text
+ * marker file (`~/.jeopi/agent/last-changelog-version`) rather than in
  * `config.yml`, so version bumps never dirty user-tracked config files.
  */
 export async function readLastChangelogVersion(agentDir?: string): Promise<string | undefined> {

package/dist/types/advisor/__tests__/advisor.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/advisor/__tests__/config.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/advisor/__tests__/emission-guard.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/advisor/advise-tool.d.ts

@@ -1,106 +0,0 @@
-import type { AgentIdentity, AgentTelemetryConfig, AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
-declare const adviseSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-    note: string;
-    severity?: "blocker" | "concern" | "nit" | undefined;
-}, {}>;
-export type AdviseParams = typeof adviseSchema.infer;
-export type AdvisorSeverity = "nit" | "concern" | "blocker";
-export interface AdviseDetails {
-    note: string;
-    severity?: AdvisorSeverity;
-    /** Which configured advisor produced this note (omitted for the default advisor). */
-    advisor?: string;
-}
-/** One queued advice note. */
-export interface AdvisorNote {
-    note: string;
-    severity?: AdvisorSeverity;
-    /** Which configured advisor produced this note (omitted for the default advisor). */
-    advisor?: string;
-}
-/** Details payload on the batched `advisor` custom message rendered in the transcript. */
-export interface AdvisorMessageDetails {
-    notes: AdvisorNote[];
-}
-/**
- * Render a batch of advisor notes as the agent-facing message body: one
- * `<advisory>` element per note, severity as an attribute. Shared by the
- * non-interrupting YieldQueue dispatcher and the interrupting steer path so both
- * build byte-identical content.
- */
-export declare function formatAdvisorBatchContent(notes: readonly AdvisorNote[]): string;
-/**
- * Whether advice at this severity should interrupt the running agent (delivered
- * via the steering channel, aborting in-flight tools) rather than ride the
- * non-interrupting aside queue that lands at the next step boundary. `concern`
- * and `blocker` interrupt; a plain `nit` queues.
- */
-export declare function isInterruptingSeverity(severity: AdvisorSeverity | undefined): boolean;
-/** How an advisor note is routed to the primary. */
-export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
-/** Half-open turn-count fence for the post-interrupt cooldown. */
-export declare function isAdvisorInterruptImmuneTurnActive(opts: {
-    completedTurns: number;
-    immuneTurnStart: number | undefined;
-    immuneTurns: number;
-}): boolean;
-/**
- * Decide how one advisor note reaches the primary agent.
- *
- * - A non-interrupting `nit` always rides the non-interrupting aside queue.
- * - An interrupting `concern`/`blocker` is normally steered into the agent: into
- *   the live turn while one is streaming, or (when idle) a triggered turn so the
- *   advice is acted on immediately.
- * - After a deliberate user interrupt (`autoResumeSuppressed`) the advisor must
- *   not auto-resume the stopped run. While the agent is idle — or still tearing
- *   the interrupted turn down (`aborting`) — the note is preserved as a visible
- *   card instead of restarting the run. But once a turn is actively streaming
- *   again (a resume the user already drove), steering the note in does NOT
- *   auto-resume anything, so it is delivered live. Parking it during an active
- *   run instead strands it (it never reaches the running agent) and the withheld
- *   notes dump as one burst at the next user prompt — the bug this guards.
- * - During the post-interrupt immune-turn window, further `concern`/`blocker`
- *   notes are downgraded to asides; suppression preservation still wins.
- */
-export declare function resolveAdvisorDeliveryChannel(opts: {
-    severity: AdvisorSeverity | undefined;
-    autoResumeSuppressed: boolean;
-    streaming: boolean;
-    aborting: boolean;
-    interruptImmuneTurnActive?: boolean;
-}): AdvisorDeliveryChannel;
-/**
- * Derive the advisor loop's telemetry from the primary session's config so the
- * advisor model's GenAI spans and usage/cost hooks (onChatUsage, onCostDelta,
- * costEstimator) fire under the same pipeline as every other model call —
- * stamped with the advisor's own agent identity. `conversationId` is cleared so
- * the advisor loop falls back to its own `-advisor` session id for
- * `gen_ai.conversation.id` instead of inheriting the primary's conversation.
- *
- * Returns undefined when the primary has no telemetry (instrumentation off), so
- * the advisor `Agent` stays a zero-overhead no-op as well.
- */
-export declare function deriveAdvisorTelemetry(primaryTelemetry: AgentTelemetryConfig | undefined, identity: AgentIdentity): AgentTelemetryConfig | undefined;
-/**
- * The tools an advisor receives by default when its config omits `tools` — the
- * read-only investigative set. The full available pool is every built tool the
- * session has (the advisor is a full agent); a config's `tools` selects from it.
- */
-export declare const ADVISOR_DEFAULT_TOOL_NAMES: ReadonlySet<string>;
-export declare class AdviseTool implements AgentTool<typeof adviseSchema, AdviseDetails> {
-    #private;
-    private readonly onAdvice;
-    readonly name = "advise";
-    readonly label = "Advise";
-    readonly description: string;
-    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
-        note: string;
-        severity?: "blocker" | "concern" | "nit" | undefined;
-    }, {}>;
-    readonly intent: "omit";
-    constructor(onAdvice: (note: string, severity?: AdviseDetails["severity"]) => void);
-    /** Clear delivered-note memory when the advisor starts a fresh conversation. */
-    resetDeliveredNotes(): void;
-    execute(_toolCallId: string, args: AdviseParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AdviseDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AdviseDetails>>;
-}
-export {};

package/dist/types/advisor/config.d.ts

@@ -1,90 +0,0 @@
-/**
- * One advisor declared in a `WATCHDOG.yml` file. `model` is a model selector
- * with an optional `:level` thinking suffix (e.g. `x-ai/grok-code-fast:high`),
- * resolved exactly like any other model override; `tools` is a subset of
- * `BUILTIN_TOOL_NAMES` — any built-in name, including mutating tools such as
- * `edit`/`write`/`bash` (the advisor is a full agent). Omitted or empty falls
- * back to the default `read`/`grep`/`glob` subset. `instructions` is the
- * advisor's specialization, appended to the shared baseline.
- */
-export interface AdvisorConfig {
-    name: string;
-    model?: string;
-    tools?: string[];
-    instructions?: string;
-}
-/**
- * The result of walking the `WATCHDOG.yml`/`WATCHDOG.yaml` search path: the
- * deduped advisor roster plus the concatenated top-level `instructions` baseline
- * that is prepended (alongside `WATCHDOG.md`) to every advisor.
- */
-export interface DiscoveredAdvisors {
-    advisors: AdvisorConfig[];
-    sharedInstructions: string | undefined;
-}
-/**
- * Normalize an advisor name into a filesystem-/id-safe slug used for its
- * transcript filename and session id: lowercase, non-alphanumerics collapsed to
- * `-`, leading/trailing `-` trimmed. Falls back to `"advisor"` when nothing
- * survives; callers dedupe collisions.
- */
-export declare function slugifyAdvisorName(name: string): string;
-/**
- * Discover advisor configs from `WATCHDOG.yml`/`WATCHDOG.yaml` files on the same
- * user + project search path as `WATCHDOG.md`. Advisors are keyed by slug; a
- * more-specific file (project leaf > project ancestor > user) replaces an earlier
- * entry with the same slug. Top-level `instructions` across all files concatenate
- * into the shared baseline. A malformed file is logged and skipped — never
- * thrown — so a bad project config can't kill the session.
- */
-export declare function discoverAdvisorConfigs(cwd: string, agentDir?: string): Promise<DiscoveredAdvisors>;
-/** Which level a `WATCHDOG.yml` lives at: the project root or the user agent dir. */
-export type AdvisorConfigScope = "project" | "user";
-/**
- * The editable contents of a single `WATCHDOG.yml` file: the shared top-level
- * `instructions` plus the advisor roster. Unlike {@link DiscoveredAdvisors}, this
- * is one file's raw view (no cross-level merge, no `@import` expansion) so the
- * config editor round-trips exactly what the user wrote.
- */
-export interface WatchdogConfigDoc {
-    instructions?: string;
-    advisors: AdvisorConfig[];
-}
-/**
- * Resolve the `WATCHDOG.yml` path for a scope: `project` → `<projectDir>/WATCHDOG.yml`
- * (discovered by the project-level walk), `user` → `<agentDir>/WATCHDOG.yml` (the
- * user-level candidate).
- */
-export declare function advisorConfigFilePath(scope: AdvisorConfigScope, dirs: {
-    projectDir: string;
-    agentDir: string;
-}): string;
-/**
- * Resolve which `WATCHDOG.{yml,yaml}` to edit for a scope: prefer the canonical
- * `.yml`, but when only a `.yaml` exists for that scope, edit it in place so an
- * existing `.yaml` user isn't shown a blank editor and left with two files at the
- * same precedence. Falls back to `.yml` when neither exists.
- */
-export declare function resolveAdvisorConfigEditPath(scope: AdvisorConfigScope, dirs: {
-    projectDir: string;
-    agentDir: string;
-}): Promise<string>;
-/**
- * Load one `WATCHDOG.yml` file for editing — raw, un-merged, un-expanded. Missing,
- * unparseable, or schema-invalid files yield an empty doc (never throws) so the
- * editor opens cleanly on a fresh or broken file.
- */
-export declare function loadWatchdogConfigFile(filePath: string): Promise<WatchdogConfigDoc>;
-/**
- * Serialize an editable doc back to block-style `WATCHDOG.yml` text via Bun's
- * `YAML.stringify` (the same API the repo uses for other hand-editable config),
- * omitting empty fields. Round-trips through {@link loadWatchdogConfigFile}.
- * Returns `""` for an empty doc.
- */
-export declare function serializeWatchdogConfig(doc: WatchdogConfigDoc): string;
-/**
- * Write an editable doc to `WATCHDOG.yml`. An empty doc removes the file so
- * discovery falls back to the legacy single-advisor path rather than leaving an
- * empty config behind.
- */
-export declare function saveWatchdogConfigFile(filePath: string, doc: WatchdogConfigDoc): Promise<void>;

package/dist/types/advisor/emission-guard.d.ts

@@ -1,73 +0,0 @@
-/**
- * Per-session policy gate for advisor `advise()` calls.
- *
- * The advisor system prompt tells the watcher model:
- *
- * > at most one `advise` per update
- * > NEVER repeat advice you already gave, and NEVER send the same advice twice
- *
- * Real advisor models violate this. Issue #3520 captured a session where
- * `__advisor.jsonl` recorded 309 `advise` calls covering 92 unique notes —
- * 114× `Stop.`, 52× `No issue; continue.`, 41× `Done.` — flooding the primary
- * transcript with `<advisory severity="blocker">Stop.</advisory>` after the
- * task was already complete. The fix is to make the rules load-bearing in code
- * instead of prose: silently drop duplicates, content-free self-talk, and
- * over-budget calls at the `enqueueAdvice` boundary so the primary stays
- * clean even when the advisor misbehaves.
- *
- * The gate is intentionally invisible to the advisor model — `AdviseTool`
- * still returns `Recorded.` for a suppressed call. Surfacing "suppressed"
- * back into advisor context risks the model rephrasing the same useless note
- * to bypass the dedupe ("Stop.", then "Halt." then "Stop now.").
- */
-/**
- * Case-insensitive, punctuation-folded normalization. Collapses every run of
- * non-letter / non-digit characters into a single space and trims, so
- * `"Stop."`, `"*Stop*"`, and `"  stop  "` all key to `stop`, while
- * `"No issue; continue."` keys to `no issue continue`.
- *
- * Exported for tests.
- */
-export declare function normalizeAdvisorNote(note: string): string;
-/**
- * Decides whether an advisor `advise()` call should reach the primary agent.
- *
- * Enforces — in this order — the noise filter, session-scoped exact-text
- * dedupe (FIFO-evicted at {@link DEFAULT_HISTORY_CAPACITY}), and a per-update
- * rate limit of one accepted note per advisor model prompt. Suppressed calls
- * never consume the per-update budget — a noise call doesn't burn the slot
- * for a real concern that follows in the same update.
- *
- * Reset on advisor reset (compaction, session switch, `/new`) via
- * {@link reset}. Per-update gate is cleared at the start of every advisor
- * `agent.prompt()` cycle via {@link beginUpdate}.
- */
-export declare class AdvisorEmissionGuard {
-    #private;
-    constructor(opts?: {
-        capacity?: number;
-    });
-    /**
-     * Drop all dedupe and per-update state. Called from
-     * `AgentSession#resetAdvisorSessionState()` whenever the advisor runtime is
-     * reset — same boundary as `yieldQueue.clear("advisor")`, so a re-primed
-     * advisor can re-raise old issues (the primary transcript was rewritten).
-     */
-    reset(): void;
-    /**
-     * Clear the per-update rate-limit gate. Called by `AdvisorRuntime` right
-     * before each `agent.prompt(batch)` invocation so the next advisor model
-     * cycle starts with a fresh budget of one advise.
-     */
-    beginUpdate(): void;
-    /**
-     * Whether the proposed note should reach the primary. On `true` the gate
-     * has already recorded the note (consumed the per-update budget and added
-     * it to the dedupe history) — caller delivers the note. On `false` the
-     * caller drops it.
-     *
-     * Empty / whitespace-only notes are suppressed; the model's
-     * tool-args contract still requires a non-empty string but defense-in-depth.
-     */
-    accept(note: string): boolean;
-}