@yagni-app/code 0.1.0 → 0.2.0

package/dist/extension/advisor.js

@@ -0,0 +1,101 @@
+/**
+ * The PURE half of the ask_advisor escalation (YAG-380).
+ *
+ * Balanced sessions drive on `advanced` and escalate hard judgment calls to
+ * `peak`. This module owns every decision about whether a consult may happen and
+ * what it cost; `askAdvisorTool.ts` owns the spawn. Same split as `permission.ts`
+ * (`decideGate` pure, wiring separate), for the same reason: the rules are what
+ * need exhaustive tests, and they must not require a child process to exercise.
+ *
+ * Two bounds, both necessarily POST-HOC. pi exposes no pre-emptive turn or token
+ * ceiling (see `pipeline/budget.ts`), so a consult's cost is only knowable once
+ * the child has exited:
+ *
+ *   - `maxConsults` is the real product bound. It makes escalation predictable
+ *     and priceable, which is the point of the cap.
+ *   - `maxSpend` is a RUNAWAY CATCH, not a budget — deliberately generous, in
+ *     the same spirit as `DEFAULT_RUN_BUDGET`. A thorough consult on a large
+ *     repo runs $0.40-$1.00, so a full 5-consult session lands near $2-$5 and
+ *     never approaches this. It exists only so an advisor stuck in a loop has
+ *     something to stop it.
+ *
+ * State is held in a closure via {@link makeAdvisorState}; no module-level
+ * mutable state, so two sessions in one process cannot bleed into each other.
+ */
+/** The session tier that may escalate. Balanced only, by design. */
+export const ADVISOR_TIER = "balanced";
+/** The tier a consult itself runs on. */
+export const ADVISOR_MODEL_TIER = "peak";
+export const DEFAULT_ADVISOR_LIMITS = {
+    maxConsults: 5,
+    maxSpend: 10,
+};
+export function makeAdvisorState() {
+    const state = { consults: 0, spend: 0 };
+    return {
+        read: () => ({ ...state }),
+        record(cost) {
+            state.consults += 1;
+            // A child that reports no usage still counts as a consult — the cap is
+            // about escalation attempts, not only about money.
+            state.spend += Number.isFinite(cost) && cost > 0 ? cost : 0;
+            return { ...state };
+        },
+    };
+}
+/**
+ * Decide whether one consult may proceed. PURE.
+ *
+ * The tier check reads the model at CALL time rather than at registration time:
+ * tools register once at activation but pi's picker can switch the session model
+ * afterwards, so a registration-time check would both leave the tool live after
+ * switching away from Balanced and hide it forever from a session that switched
+ * to Balanced.
+ */
+export function decideConsult(input) {
+    const { model, state, limits } = input;
+    if (model !== ADVISOR_TIER) {
+        return {
+            allow: false,
+            reason: `ask_advisor is only available on the Balanced tier (this session is on ` +
+                `"${model ?? "unknown"}"). Switch the model to Balanced to consult the ` +
+                `peak-tier advisor, or reason it through on the current tier.`,
+        };
+    }
+    if (state.consults >= limits.maxConsults) {
+        return {
+            allow: false,
+            reason: `Advisor consult cap reached (${state.consults} of ${limits.maxConsults} ` +
+                `used this session). Escalation is capped so a session's cost stays ` +
+                `predictable. Decide this one yourself, or start a fresh session.`,
+        };
+    }
+    if (state.spend >= limits.maxSpend) {
+        return {
+            allow: false,
+            reason: `Advisor spend ceiling reached ($${state.spend.toFixed(2)} this session). ` +
+                `This is a runaway guard rather than a budget, so hitting it usually ` +
+                `means a consult looped. Decide this one yourself, or start a fresh session.`,
+        };
+    }
+    return { allow: true };
+}
+/**
+ * The line appended to a consult's advice so spend is visible at the moment it
+ * happens. `/cost` cannot see child processes at all (it accumulates off the
+ * parent's `turn_end`), so without this an advisor consult is invisible — see
+ * YAG-383 for the server-authoritative fix.
+ */
+export function formatConsultCost(input) {
+    const { cost, consults, limits } = input;
+    return `Advisor consult: $${cost.toFixed(2)} (${consults} of ${limits.maxConsults} used this session).`;
+}
+/** The advisor subtotal line `/cost` appends when a session has escalated. */
+export function formatAdvisorSubtotal(state, limits) {
+    if (state.consults === 0)
+        return "";
+    const plural = state.consults === 1 ? "consult" : "consults";
+    return (`Advisor: ${state.consults} ${plural} of ${limits.maxConsults}, ` +
+        `$${state.spend.toFixed(2)} on peak.`);
+}
+//# sourceMappingURL=advisor.js.map

package/dist/extension/askAdvisorTool.d.ts

@@ -0,0 +1,83 @@
+/**
+ * `ask_advisor` — the peak-tier escalation available to Balanced sessions (YAG-380).
+ *
+ * Cheap driver, expensive consultant: a Balanced session drives on `advanced` and
+ * calls this when it hits a judgment call worth the strongest model. The consult
+ * spawns a child pi at `peak` through the same `runStage` seam `/go` uses, and
+ * returns the advice as plain TEXT the driver acts on — text we own, so
+ * `record_decision` can bank it into the corpus afterwards.
+ *
+ * Two deliberate design calls, both of which cost money and buy quality:
+ *
+ *   1. The advisor gets REAL read-only recon (read/grep/find/ls), the same set
+ *      the plan stage uses. An advisor limited to what the driver pre-digested
+ *      rubber-stamps the driver's framing; half the value of escalation is
+ *      looking where the driver did not think to look. This makes a consult an
+ *      agentic loop, so a thorough one on a large repo runs $0.40-$1.00 rather
+ *      than the ~4c a single-shot completion would cost. That is the price of
+ *      the advisor being useful. It gets NO bash: a consultant reasons and
+ *      reads, it must not build, run, or write.
+ *   2. The input schema is NARROW on purpose — question, what was tried,
+ *      relevant excerpts. There is deliberately no field a conversation
+ *      transcript fits into, because passing the transcript is how a consult
+ *      silently becomes more expensive than just running peak.
+ *
+ * The gate, the cap and the spend ceiling live in `advisor.ts` and are pure;
+ * this module is the I/O.
+ */
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { type AdvisorLimits, type AdvisorStateHandle } from "./advisor.js";
+import { runStage as defaultRunStage } from "./pipeline/runner.js";
+import type { PipelineStage } from "./pipeline/types.js";
+/**
+ * Read-only recon plus grounding. Mirrors the `plan` stage's allowlist for the
+ * reason documented there: enough tools to navigate instead of flailing on a
+ * single `read`. No `bash`.
+ */
+export declare const ADVISOR_TOOLS: string[];
+declare const parameters: Type.TObject<{
+    question: Type.TString;
+    tried: Type.TOptional<Type.TString>;
+    excerpts: Type.TOptional<Type.TString>;
+}>;
+export interface MakeAskAdvisorToolOptions {
+    /** Per-session consult accounting. Created once per session in index.ts. */
+    state: AdvisorStateHandle;
+    limits?: AdvisorLimits;
+    /** Injectable so tests never spawn a child. */
+    runStage?: typeof defaultRunStage;
+}
+/**
+ * Assemble the consult brief. The advisor's persona already tells it not to take
+ * this framing on trust, so the brief orients rather than constrains.
+ */
+export declare function buildConsultBrief(params: {
+    question: string;
+    tried?: string;
+    excerpts?: string;
+}): string;
+/**
+ * The synthetic stage a consult runs as.
+ *
+ * `id` reuses the existing `plan` StageId rather than adding an advisor member:
+ * the advisor is NOT a pipeline stage, and a new StageId would ripple into the
+ * feed/activity reducers that switch over it. `agent` is what selects the
+ * persona, and that is the advisor's own.
+ */
+export declare function advisorStage(): PipelineStage;
+export declare function makeAskAdvisorTool(opts: MakeAskAdvisorToolOptions): ToolDefinition<typeof parameters, {
+    consults: number;
+    cost: number;
+}>;
+/**
+ * `/advise <question>` — the manual escalation lever.
+ *
+ * Runs the SAME tool the model calls, sharing one state handle, so a manual
+ * consult draws on the same cap rather than opening a side channel around it.
+ * The advice is sent into the conversation (like /go-compare's report) so the
+ * driver sees it in context and can act on it.
+ */
+export declare function registerAdviseCommand(pi: ExtensionAPI, tool: ReturnType<typeof makeAskAdvisorTool>): void;
+export {};
+//# sourceMappingURL=askAdvisorTool.d.ts.map

package/dist/extension/askAdvisorTool.js

@@ -0,0 +1,194 @@
+/**
+ * `ask_advisor` — the peak-tier escalation available to Balanced sessions (YAG-380).
+ *
+ * Cheap driver, expensive consultant: a Balanced session drives on `advanced` and
+ * calls this when it hits a judgment call worth the strongest model. The consult
+ * spawns a child pi at `peak` through the same `runStage` seam `/go` uses, and
+ * returns the advice as plain TEXT the driver acts on — text we own, so
+ * `record_decision` can bank it into the corpus afterwards.
+ *
+ * Two deliberate design calls, both of which cost money and buy quality:
+ *
+ *   1. The advisor gets REAL read-only recon (read/grep/find/ls), the same set
+ *      the plan stage uses. An advisor limited to what the driver pre-digested
+ *      rubber-stamps the driver's framing; half the value of escalation is
+ *      looking where the driver did not think to look. This makes a consult an
+ *      agentic loop, so a thorough one on a large repo runs $0.40-$1.00 rather
+ *      than the ~4c a single-shot completion would cost. That is the price of
+ *      the advisor being useful. It gets NO bash: a consultant reasons and
+ *      reads, it must not build, run, or write.
+ *   2. The input schema is NARROW on purpose — question, what was tried,
+ *      relevant excerpts. There is deliberately no field a conversation
+ *      transcript fits into, because passing the transcript is how a consult
+ *      silently becomes more expensive than just running peak.
+ *
+ * The gate, the cap and the spend ceiling live in `advisor.ts` and are pure;
+ * this module is the I/O.
+ */
+import { Type } from "typebox";
+import { ADVISOR_MODEL_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatConsultCost, } from "./advisor.js";
+import { runStage as defaultRunStage } from "./pipeline/runner.js";
+/**
+ * Read-only recon plus grounding. Mirrors the `plan` stage's allowlist for the
+ * reason documented there: enough tools to navigate instead of flailing on a
+ * single `read`. No `bash`.
+ */
+export const ADVISOR_TOOLS = ["read", "grep", "find", "ls", "ask_yagni"];
+const parameters = Type.Object({
+    question: Type.String({
+        description: "The single judgment call you want a second opinion on. Be specific.",
+    }),
+    tried: Type.Optional(Type.String({ description: "What you have already tried or ruled out, and why." })),
+    excerpts: Type.Optional(Type.String({ description: "Relevant code excerpts or file paths. Not a transcript." })),
+});
+/**
+ * Assemble the consult brief. The advisor's persona already tells it not to take
+ * this framing on trust, so the brief orients rather than constrains.
+ */
+export function buildConsultBrief(params) {
+    const parts = [`Question: ${params.question}`];
+    if (params.tried?.trim())
+        parts.push(`Already tried / ruled out:\n${params.tried.trim()}`);
+    if (params.excerpts?.trim())
+        parts.push(`Relevant excerpts:\n${params.excerpts.trim()}`);
+    parts.push("Read the code yourself before answering. Do not assume the framing above is complete.");
+    return parts.join("\n\n");
+}
+/**
+ * The synthetic stage a consult runs as.
+ *
+ * `id` reuses the existing `plan` StageId rather than adding an advisor member:
+ * the advisor is NOT a pipeline stage, and a new StageId would ripple into the
+ * feed/activity reducers that switch over it. `agent` is what selects the
+ * persona, and that is the advisor's own.
+ */
+export function advisorStage() {
+    return {
+        id: "plan",
+        agent: "advisor",
+        model: ADVISOR_MODEL_TIER,
+        tools: ADVISOR_TOOLS,
+        taskTemplate: "{ticket}",
+    };
+}
+export function makeAskAdvisorTool(opts) {
+    const limits = opts.limits ?? DEFAULT_ADVISOR_LIMITS;
+    const runStage = opts.runStage ?? defaultRunStage;
+    return {
+        name: "ask_advisor",
+        label: "Ask the advisor",
+        description: "Escalate ONE hard judgment call to the peak-tier advisor — the strongest " +
+            "model available, which reads the code itself and returns a recommendation. " +
+            "Available only on the Balanced tier, and capped per session, so use it for " +
+            "calls that are genuinely worth it: an architectural fork with no obvious " +
+            "right answer, a subtle correctness question you cannot settle by reading, " +
+            "a change whose blast radius you are unsure of, or a second opinion before " +
+            "committing to an approach you would have to unwind. Do NOT use it for " +
+            "lookups (use ask_yagni), for anything you can settle by reading the code, " +
+            "or to review work you have already finished. Pass a sharp question plus the " +
+            "relevant excerpts — never a conversation transcript.",
+        promptSnippet: "ask_advisor: escalate one hard judgment call to the peak-tier advisor (Balanced sessions, capped).",
+        promptGuidelines: [
+            "Call ask_advisor only for a genuine judgment fork — an architectural choice, a subtle correctness question, or a second opinion before an approach you would have to unwind. Reading the code is cheaper; do that first.",
+            "Ask ONE specific question per consult, and include the excerpts that matter. The advisor reads the repo itself, so point it at the right place rather than pasting everything.",
+            "Consults are capped per session. Spend them on the calls you would otherwise get wrong.",
+            "The advice comes back as plain text: act on it, and call record_decision when it settles a product-intent call so the next agent inherits it.",
+        ],
+        parameters,
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+            // Read the LIVE session model: pi's picker can change it after this tool
+            // was registered, in both directions.
+            const decision = decideConsult({
+                model: ctx?.model?.id,
+                state: opts.state.read(),
+                limits,
+            });
+            if (!decision.allow) {
+                return {
+                    content: [{ type: "text", text: decision.reason ?? "ask_advisor is unavailable." }],
+                    details: { consults: opts.state.read().consults, cost: 0 },
+                };
+            }
+            onUpdate?.({
+                content: [{ type: "text", text: "Consulting the advisor…" }],
+                details: { consults: opts.state.read().consults, cost: 0 },
+            });
+            const result = await runStage(advisorStage(), { ticket: buildConsultBrief(params) }, {
+                cwd: ctx?.cwd ?? process.cwd(),
+                ...(signal ? { signal } : {}),
+                // YAG-471: attribute the consult's completions to the advisor, not
+                // the "plan" stage id advisorStage() borrows (see its docblock).
+                callerLabel: "advisor",
+            });
+            const cost = result.usage?.cost ?? 0;
+            const state = opts.state.record(cost);
+            if (result.exitCode !== 0 && !result.finalOutput.trim()) {
+                // Fail honestly rather than returning an empty recommendation. The
+                // consult still counts: it spawned, and it may well have spent.
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `The advisor consult failed (exit ${result.exitCode}). ` +
+                                `${formatConsultCost({ cost, consults: state.consults, limits })} ` +
+                                `Decide this one yourself.`,
+                        },
+                    ],
+                    details: { consults: state.consults, cost },
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${result.finalOutput.trim()}\n\n${formatConsultCost({ cost, consults: state.consults, limits })}`,
+                    },
+                ],
+                details: { consults: state.consults, cost },
+            };
+        },
+    };
+}
+/**
+ * `/advise <question>` — the manual escalation lever.
+ *
+ * Runs the SAME tool the model calls, sharing one state handle, so a manual
+ * consult draws on the same cap rather than opening a side channel around it.
+ * The advice is sent into the conversation (like /go-compare's report) so the
+ * driver sees it in context and can act on it.
+ */
+export function registerAdviseCommand(pi, tool) {
+    pi.registerCommand("advise", {
+        description: "Escalate one hard call to the peak-tier advisor (Balanced sessions only, capped per session).",
+        handler: async (args, ctx) => {
+            const notify = (message, type) => {
+                if (ctx.hasUI)
+                    ctx.ui.notify(message, type);
+            };
+            const question = args.trim();
+            if (!question) {
+                notify("Usage: /advise <the judgment call you want a second opinion on>", "warning");
+                return;
+            }
+            if (!ctx.isIdle()) {
+                notify("YAGNI Code is busy; wait for the current turn to finish before /advise.", "warning");
+                return;
+            }
+            notify("Consulting the peak-tier advisor. This reads the repo, so it takes a moment.", "info");
+            try {
+                const out = await tool.execute("advise", { question }, ctx.signal, undefined, ctx);
+                const text = out.content
+                    .map((c) => c.text ?? "")
+                    .join("\n")
+                    .trim();
+                await pi.sendUserMessage(text || "The advisor returned nothing.");
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                notify(`/advise failed: ${message}`, "error");
+                await pi.sendUserMessage(`/advise failed: ${message}`);
+            }
+        },
+    });
+}
+//# sourceMappingURL=askAdvisorTool.js.map

package/dist/extension/askYagniTool.d.ts

@@ -0,0 +1,39 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { type RepoDocSnippet } from "./repoDocs.js";
+/** A single source citation returned by the YAGNI `ask` endpoint. */
+export interface Citation {
+    title: string;
+    url: string;
+}
+/** Options for {@link makeAskYagniTool}. */
+export interface MakeAskYagniToolOptions {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+    /**
+     * Repo-doc grounding seam (default: the real bounded collector). The tool
+     * sends the working tree's most relevant docs (ADRs, CONTEXT.md, AGENTS.md,
+     * docs/*.md) alongside the question so the backend can ground its answer in
+     * repo-level knowledge the workspace corpus does not hold — always at the
+     * checkout's own era, since the docs are read from the tree being edited.
+     */
+    collectDocs?: (cwd: string, query: string) => RepoDocSnippet[];
+}
+declare const parameters: Type.TObject<{
+    question: Type.TString;
+    context: Type.TOptional<Type.TString>;
+}>;
+/**
+ * Build the `ask_yagni` tool definition.
+ *
+ * The tool asks the YAGNI app a question grounded in the company's business and
+ * codebase context, returning a grounded answer plus source citations. It is the
+ * preferred way for the agent to learn anything org- or codebase-specific
+ * (conventions, policies, architecture, ownership) before guessing.
+ */
+export declare function makeAskYagniTool(opts: MakeAskYagniToolOptions): ToolDefinition<typeof parameters, {
+    citations: Citation[];
+}>;
+export {};
+//# sourceMappingURL=askYagniTool.d.ts.map

package/dist/extension/askYagniTool.js

@@ -0,0 +1,63 @@
+import { Type } from "typebox";
+import { collectRepoDocs } from "./repoDocs.js";
+import { friendlyFetchError, METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
+const parameters = Type.Object({
+    question: Type.String(),
+    context: Type.Optional(Type.String()),
+});
+/**
+ * Build the `ask_yagni` tool definition.
+ *
+ * The tool asks the YAGNI app a question grounded in the company's business and
+ * codebase context, returning a grounded answer plus source citations. It is the
+ * preferred way for the agent to learn anything org- or codebase-specific
+ * (conventions, policies, architecture, ownership) before guessing.
+ */
+export function makeAskYagniTool(opts) {
+    return {
+        name: "ask_yagni",
+        label: "Ask YAGNI",
+        description: "Ask the YAGNI app a question grounded in this company's business and codebase context. " +
+            "Returns a grounded answer plus source citations. Use this BEFORE guessing about anything " +
+            "organization- or codebase-specific — conventions, policies, architecture, ownership, " +
+            "product decisions, or who/what/why. Prefer asking over assuming.",
+        promptSnippet: "ask_yagni: ask the YAGNI app a question grounded in company + codebase context (returns a cited answer).",
+        promptGuidelines: [
+            "Call ask_yagni BEFORE guessing about anything organization- or codebase-specific (conventions, policies, architecture, ownership, product decisions).",
+            "Pass the user's actual question; add relevant local context (file paths, snippets) in the optional `context` field.",
+            "When you use an answer, quote or reference its citations so the user can verify the source.",
+        ],
+        parameters,
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+            onUpdate?.({ content: [{ type: "text", text: "Asking YAGNI…" }], details: { citations: [] } });
+            // Era-correct repo grounding: gather the working tree's most relevant docs
+            // for this question. Never blocking and never fatal — an empty list sends
+            // nothing and the backend answers from workspace context alone.
+            const collect = opts.collectDocs ?? collectRepoDocs;
+            const repoQuery = params.context ? `${params.question}\n${params.context}` : params.question;
+            const repoDocs = ctx?.cwd ? collect(ctx.cwd, repoQuery) : [];
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/ask`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${opts.getToken() ?? ""}`,
+                },
+                body: JSON.stringify({
+                    question: params.question,
+                    context: params.context,
+                    cwd: ctx?.cwd,
+                    ...(repoDocs.length > 0 ? { repoDocs } : {}),
+                }),
+            }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+            if (!res.ok) {
+                throw new Error(await friendlyFetchError("ask_yagni", res));
+            }
+            const data = (await res.json());
+            return {
+                content: [{ type: "text", text: data.answer }],
+                details: { citations: data.citations ?? [] },
+            };
+        },
+    };
+}
+//# sourceMappingURL=askYagniTool.js.map

package/dist/extension/bless.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Session-scoped bless store for review-mode "don't ask again" (spec §4, W4).
+ *
+ * A bless rule is (tool + directory prefix). It is created ONLY when the user
+ * picks "Yes, and don't ask again for <tool> in <dir>" at the review gate, and
+ * it is:
+ *   - SESSION-SCOPED: held in memory for the life of THIS process only.
+ *   - NEVER persisted (no disk, no backend) — a new session starts unblessed,
+ *     and (per the gate wiring) it is never consulted in plan mode.
+ *   - PATH-PREFIX-bound: a rule blesses a tool within one directory subtree, so
+ *     approving `write` under `src/api/` never auto-approves a `write` elsewhere.
+ *   - Only for path-bearing tools (read/write/edit expose `path`). `bash` carries
+ *     no path, so it is NOT blessable and always re-prompts (fail toward asking).
+ *
+ * Paths are resolved to absolute against the session cwd at BOTH bless-time and
+ * match-time, so a rule created from a relative `path` still matches an absolute
+ * one (and vice versa). Everything is pure except the in-memory rule list.
+ */
+/** One session bless: this tool is auto-approved within this directory subtree. */
+export interface BlessRule {
+    tool: string;
+    /** Absolute directory prefix the rule blesses (subtree-inclusive). */
+    prefix: string;
+}
+export interface BlessStore {
+    /** Can a bless rule be formed for this call? (path-bearing tools only.) */
+    canBless(params: Record<string, unknown>): boolean;
+    /**
+     * A short, cwd-relative directory label for the "don't ask again" option, or
+     * null when the call carries no path (bash). Absolute when outside the tree,
+     * "." at the repo root, otherwise the relative directory.
+     */
+    describeDir(params: Record<string, unknown>): string | null;
+    /** Add a (tool + dir-prefix) rule from a blessed call. Null if not blessable. */
+    add(tool: string, params: Record<string, unknown>): BlessRule | null;
+    /** Does an existing rule already bless this call? */
+    isBlessed(tool: string, params: Record<string, unknown>): boolean;
+    /** The current rules (test/debug visibility). */
+    rules(): BlessRule[];
+}
+/** The file path a call targets, or null for path-less tools (bash). */
+export declare function blessPath(params: Record<string, unknown>): string | null;
+/** Build a fresh, empty session bless store rooted at `cwd`. */
+export declare function makeBlessStore(cwd: string): BlessStore;
+//# sourceMappingURL=bless.d.ts.map

package/dist/extension/bless.js

@@ -0,0 +1,87 @@
+/**
+ * Session-scoped bless store for review-mode "don't ask again" (spec §4, W4).
+ *
+ * A bless rule is (tool + directory prefix). It is created ONLY when the user
+ * picks "Yes, and don't ask again for <tool> in <dir>" at the review gate, and
+ * it is:
+ *   - SESSION-SCOPED: held in memory for the life of THIS process only.
+ *   - NEVER persisted (no disk, no backend) — a new session starts unblessed,
+ *     and (per the gate wiring) it is never consulted in plan mode.
+ *   - PATH-PREFIX-bound: a rule blesses a tool within one directory subtree, so
+ *     approving `write` under `src/api/` never auto-approves a `write` elsewhere.
+ *   - Only for path-bearing tools (read/write/edit expose `path`). `bash` carries
+ *     no path, so it is NOT blessable and always re-prompts (fail toward asking).
+ *
+ * Paths are resolved to absolute against the session cwd at BOTH bless-time and
+ * match-time, so a rule created from a relative `path` still matches an absolute
+ * one (and vice versa). Everything is pure except the in-memory rule list.
+ */
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+/**
+ * Windows-only separator normalization so prefixes compare and display with
+ * `/` on every platform: pi's tools emit forward-slash paths even on Windows,
+ * and a rule keyed `C:\repo\src\api` would silently never match a call for
+ * `C:/repo/src/api/a.ts`. On POSIX this is the identity (a `\` there is a
+ * legal filename character, not a separator).
+ */
+const norm = sep === "\\" ? (p) => p.split("\\").join("/") : (p) => p;
+/** The file path a call targets, or null for path-less tools (bash). */
+export function blessPath(params) {
+    const p = params.path;
+    return typeof p === "string" && p.trim().length > 0 ? p.trim() : null;
+}
+/** Build a fresh, empty session bless store rooted at `cwd`. */
+export function makeBlessStore(cwd) {
+    const rules = [];
+    // Always THROUGH resolve, even for absolute inputs: on Windows a bare
+    // "/repo/…" is drive-relative and resolve() drive-qualifies it, so a rule
+    // minted from a relative path and a call carrying an absolute one land on
+    // the same canonical form. (For an already-absolute POSIX path this is just
+    // normalization.)
+    const abs = (p) => norm(resolve(cwd, p));
+    /** Absolute directory prefix a bless of this call would cover, or null. */
+    function prefixFor(params) {
+        const p = blessPath(params);
+        if (p === null)
+            return null;
+        return abs(dirname(p));
+    }
+    return {
+        canBless(params) {
+            return blessPath(params) !== null;
+        },
+        describeDir(params) {
+            const prefix = prefixFor(params);
+            if (prefix === null)
+                return null;
+            const rel = norm(relative(cwd, prefix));
+            // Inside the tree → the relative dir (or "." for the repo root); outside →
+            // the absolute path so the user sees exactly what they are blessing.
+            if (rel === "")
+                return ".";
+            if (!rel.startsWith("..") && !isAbsolute(rel))
+                return rel;
+            return prefix;
+        },
+        add(tool, params) {
+            const prefix = prefixFor(params);
+            if (prefix === null)
+                return null;
+            if (!rules.some((r) => r.tool === tool && r.prefix === prefix)) {
+                rules.push({ tool, prefix });
+            }
+            return { tool, prefix };
+        },
+        isBlessed(tool, params) {
+            const p = blessPath(params);
+            if (p === null)
+                return false; // path-less (bash) never auto-approves
+            const target = abs(p);
+            return rules.some((r) => r.tool === tool && (target === r.prefix || target.startsWith(`${r.prefix}/`)));
+        },
+        rules() {
+            return rules.slice();
+        },
+    };
+}
+//# sourceMappingURL=bless.js.map