@yagni-app/code-staging 1.0.1-staging.1194.1 → 1.0.1-staging.1199.1

package/dist/extension/index.js

@@ -40,12 +40,13 @@ import { registerDecisionCommands } from "./decisions.js";
 import { makeDecisionCapture } from "./decisionCapture.js";
 import { registerAmbientRecall } from "./recall.js";
 import { resilientFetch } from "./resilientFetch.js";
-import { installUncaughtExceptionMonitor, makeCrashReporter } from "./crashReport.js";
+import { installUncaughtExceptionMonitor, makeCrashReporter, runningUnderTest } from "./crashReport.js";
 import { flushSpool as defaultFlushSpool } from "./spool.js";
 import { makeAuthedFetch, makeTokenProvider } from "./tokenProvider.js";
 import { attributionHeaders, fetchCatalog as defaultFetchCatalog, fetchContextBrief as defaultFetchContextBrief, getToken, getTokenExpiresAt as defaultGetTokenExpiresAt, getWorkspaceId as defaultGetWorkspaceId, isDriverCaller, resolveBaseUrl, tokenExpiryNotice, } from "./config.js";
 import { buildYagniProvider } from "./provider.js";
 import { registerChipEditor } from "./chipEditor.js";
+import { registerSlashCommandFilter } from "./slashCommandFilter.js";
 import { defaultMineBeatGit, fileMineBeatMarkers, maybeOfferMiningBeat as defaultMaybeOfferMiningBeat, } from "./mineBeat.js";
 import { makeFlywheelState } from "./flywheel.js";
 import { registerSilentTurnReminder } from "./silentTurnReminder.js";
@@ -219,6 +220,11 @@ export async function registerYagni(pi, deps = {}) {
     // temp path, and registers the input transform that turns chips into image
     // attachments for the model. No-op outside TUI mode.
     registerChipEditor(pi);
+    // Hide pi's built-in slash commands that contradict YAGNI's single-provider,
+    // single-identity model (e.g. /share gist upload, /login <provider>) from
+    // slash-discovery. TUI autocomplete only; the desktop palette already
+    // excludes built-ins, and this is a no-op in RPC/print modes.
+    registerSlashCommandFilter(pi);
     // The general subagent tool: delegate self-contained tasks (optionally in
     // parallel) to fresh-context agents defined in .claude/agents / .pi/agents,
     // riding the /go pipeline's child runner. /agents lists what's available.
@@ -326,7 +332,10 @@ export async function registerYagni(pi, deps = {}) {
         const { event: _ignored, ...fields } = payload;
         logEvent({
             source: "guardian",
-            level: event === "guardian_event_post_failed" ? "error" : "info",
+            // `malformed` is a real failure (this is the "unclear verdict" bug the
+            // whole capture exists to diagnose) — an error, not routine info. The
+            // failed-telemetry event is already an error.
+            level: event === "guardian_event_post_failed" || payload.outcome === "malformed" ? "error" : "info",
             event,
             sessionId: env.YAGNI_SESSION_ID ?? undefined,
             fields,
@@ -351,7 +360,43 @@ export async function registerYagni(pi, deps = {}) {
         guardianTier,
         guardianDisabled,
         guardianReview: (command, deps) => reviewCommand(command, { ...deps, modelTier: guardianTier }),
-        onGuardianReview: (ev) => guardianLogSink(ev),
+        onGuardianReview: (ev) => {
+            guardianLogSink(ev);
+            // A malformed verdict is a real failure on our side that must reach
+            // Sentry for EVERY workspace (independent of the opt-in storage tier).
+            // Fire-and-forget to the dedicated telemetry endpoint; fail-soft, and
+            // suppressed under test/eval so a CI run never phones prod.
+            if (ev.outcome === "malformed" && !evalMode && !runningUnderTest(env)) {
+                void (async () => {
+                    try {
+                        const body = {
+                            outcome: ev.outcome,
+                            ...(ev.rawOutput ? { rawOutput: ev.rawOutput } : {}),
+                            ...(ev.durationMs !== undefined ? { durationMs: ev.durationMs } : {}),
+                            ...(ev.tier ? { tier: ev.tier } : {}),
+                        };
+                        const res = await resilientFetch(`${baseUrl}/api/yagni-code/guardian-error`, {
+                            method: "POST",
+                            headers: {
+                                "content-type": "application/json",
+                                authorization: `Bearer ${getTokenFn() ?? ""}`,
+                                ...attributionHeaders(deps.env),
+                            },
+                            body: JSON.stringify(body),
+                        }, {
+                            fetchImpl: authedFetch,
+                            policy: { maxAttempts: 1, backoffBaseMs: 0, backoffMaxMs: 0, timeoutMs: GUARDIAN_EVENT_TIMEOUT_MS, jitterRatio: 0 },
+                        });
+                        if (!res.ok) {
+                            guardianLogSink({ event: "guardian_error_post_failed", status: res.status });
+                        }
+                    }
+                    catch {
+                        guardianLogSink({ event: "guardian_error_post_failed", kind: "network" });
+                    }
+                })();
+            }
+        },
         grants: sessionGrants,
         resolveRepoKey,
         persistGrant: (grant) => {

package/dist/extension/permission/gate.js

@@ -561,13 +561,14 @@ export function registerPermissionGate(pi, deps = {}) {
                             ctx.ui.setStatus?.("yagni-guardian", undefined);
                     }
                     const durationMs = Date.now() - startMs;
-                    const emitDiag = (outcome, rationale) => {
+                    const emitDiag = (outcome, rationale, rawOutput) => {
                         if (!deps.onGuardianReview)
                             return;
                         void Promise.resolve(deps.onGuardianReview(buildDiagnosticEvent(outcome, {
                             durationMs,
                             tier: guardianTier,
                             ...(rationale ? { rationale } : {}),
+                            ...(rawOutput ? { rawOutput } : {}),
                             debug: isDebug(),
                         }))).catch(() => { });
                     };
@@ -734,7 +735,7 @@ export function registerPermissionGate(pi, deps = {}) {
                     }
                     // Guardian failed (timeout/malformed/network/empty/aborted).
                     const error = reviewResult.error ?? "network";
-                    emitDiag(error);
+                    emitDiag(error, undefined, reviewResult.rawOutput);
                     if (error === "aborted" || ctx?.signal?.aborted) {
                         // The user aborted mid-consult — silent block: no dialog, no
                         // "Guardian unavailable" warning on a turn they deliberately

package/dist/extension/permission/guardian.d.ts

@@ -106,7 +106,20 @@ export interface ReviewResult {
     verdict: GuardianVerdict | null;
     error?: GuardianError;
     cost: number;
+    /**
+     * Scrubbed + capped copy of the model output when the verdict failed to
+     * parse (`error: "malformed"`). Present so the sink can capture the exact
+     * failure shape. Never contains the raw command unredacted: `scrubSecrets`
+     * removes secret-shaped values before this is stored.
+     */
+    rawOutput?: string;
 }
+/**
+ * Cap on the malformed-output capture. The model's unparseable verdict is
+ * usually a single short JSON-ish blob; this bounds a pathological output so
+ * it cannot balloon a log line or a Sentry payload.
+ */
+export declare const GUARDIAN_RAW_OUTPUT_CAP = 2048;
 export interface ReviewCommandDeps {
     runStage?: typeof defaultRunStage;
     cwd: string;
@@ -143,6 +156,12 @@ export interface GuardianDiagnosticEvent {
     commandHash?: string;
     /** Debug-only: the Guardian's rationale. */
     rationale?: string;
+    /**
+     * Scrubbed + capped copy of the unparseable model output, present only for
+     * `outcome: "malformed"`. Always-on (NOT debug-gated): it is already
+     * `scrubSecrets`-redacted and size-capped at the source.
+     */
+    rawOutput?: string;
 }
 /**
  * Create a sanitized diagnostic event. Never includes the raw command text
@@ -153,6 +172,7 @@ export declare function buildDiagnosticEvent(outcome: GuardianOutcome | Guardian
     tier?: string;
     rationale?: string;
     commandHash?: string;
+    rawOutput?: string;
     debug?: boolean;
 }): GuardianDiagnosticEvent;
 //# sourceMappingURL=guardian.d.ts.map

package/dist/extension/permission/guardian.js

@@ -28,6 +28,7 @@
  * alternating deny/ask.
  */
 import { runStage as defaultRunStage } from "../pipeline/runner.js";
+import { scrubSecrets } from "../pipeline/scrubSecrets.js";
 export const DEFAULT_GUARDIAN_LIMITS = {
     maxReviews: 120,
     maxConsecutiveDenials: 3,
@@ -161,6 +162,12 @@ export function formatGuardianSubtotal(state, limits) {
     const plural = state.reviews === 1 ? "review" : "reviews";
     return `Guardian: ${state.reviews} ${plural}.`;
 }
+/**
+ * Cap on the malformed-output capture. The model's unparseable verdict is
+ * usually a single short JSON-ish blob; this bounds a pathological output so
+ * it cannot balloon a log line or a Sentry payload.
+ */
+export const GUARDIAN_RAW_OUTPUT_CAP = 2048;
 /**
  * The synthetic stage a Guardian consult runs as. Borrows the `plan` StageId
  * (same pattern as the advisor) so it doesn't ripple into feed/reducers. The
@@ -231,7 +238,14 @@ export async function reviewCommand(command, deps) {
         }
         const verdict = parseVerdict(output);
         if (!verdict) {
-            return { verdict: null, error: "malformed", cost };
+            // Scrubbed + capped so the local sink and Sentry can see the exact
+            // failure shape without carrying a raw command or a secret it echoed.
+            return {
+                verdict: null,
+                error: "malformed",
+                cost,
+                rawOutput: scrubSecrets(output).slice(0, GUARDIAN_RAW_OUTPUT_CAP),
+            };
         }
         return { verdict, cost };
     }
@@ -261,6 +275,7 @@ export function buildDiagnosticEvent(outcome, opts) {
         outcome,
         ...(opts.durationMs !== undefined ? { durationMs: opts.durationMs } : {}),
         ...(opts.tier !== undefined ? { tier: opts.tier } : {}),
+        ...(opts.rawOutput !== undefined ? { rawOutput: opts.rawOutput } : {}),
     };
     if (opts.debug) {
         if (opts.rationale)

package/dist/extension/slashCommandFilter.d.ts

@@ -0,0 +1,30 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/**
+ * Slash-command filtering for the CLI.
+ *
+ * pi ships its own built-in slash commands (see `BUILTIN_SLASH_COMMANDS` in
+ * pi's `core/slash-commands.js`) and bakes them directly into its interactive
+ * autocomplete provider (`createBaseAutocompleteProvider`). Most are
+ * pi-generic and harmless (`/new`, `/compact`, `/settings`), but a subset
+ * contradict YAGNI's single-provider, single-identity model — or leak pi
+ * features YAGNI deliberately does not surface — and only confuse a YAGNI Code
+ * user. We hide those from slash-discovery.
+ *
+ * Scope note: this filters DISCOVERY only. pi dispatches built-in commands in
+ * its own private `onSubmit` chain (not from the autocomplete list), so a
+ * hidden command can still be typed by hand — the same bar pi itself draws for
+ * its easter-egg commands, which are also absent from autocomplete. Removing
+ * them from the list is the whole intent: a YAGNI user should not be offered
+ * `/share` (ships a transcript to a GitHub gist) or `/login <provider>` (pi
+ * provider auth) when YAGNI's model is a single `yagni` provider.
+ *
+ * The desktop palette is unaffected: pi's RPC `get_commands` (which the desktop
+ * app reads) already returns extension commands + prompt templates + skills and
+ * never includes built-ins. This wrapper is inert outside interactive TUI mode,
+ * where `addAutocompleteProvider` is handed a no-op factory.
+ */
+/** pi built-in slash commands hidden from YAGNI Code autocomplete. */
+export declare const HIDDEN_BUILTIN_SLASH_COMMANDS: readonly string[];
+/** Register the slash-command filter on `session_start` (TUI autocomplete only). */
+export declare function registerSlashCommandFilter(pi: ExtensionAPI): void;
+//# sourceMappingURL=slashCommandFilter.d.ts.map

package/dist/extension/slashCommandFilter.js

@@ -0,0 +1,89 @@
+/**
+ * Slash-command filtering for the CLI.
+ *
+ * pi ships its own built-in slash commands (see `BUILTIN_SLASH_COMMANDS` in
+ * pi's `core/slash-commands.js`) and bakes them directly into its interactive
+ * autocomplete provider (`createBaseAutocompleteProvider`). Most are
+ * pi-generic and harmless (`/new`, `/compact`, `/settings`), but a subset
+ * contradict YAGNI's single-provider, single-identity model — or leak pi
+ * features YAGNI deliberately does not surface — and only confuse a YAGNI Code
+ * user. We hide those from slash-discovery.
+ *
+ * Scope note: this filters DISCOVERY only. pi dispatches built-in commands in
+ * its own private `onSubmit` chain (not from the autocomplete list), so a
+ * hidden command can still be typed by hand — the same bar pi itself draws for
+ * its easter-egg commands, which are also absent from autocomplete. Removing
+ * them from the list is the whole intent: a YAGNI user should not be offered
+ * `/share` (ships a transcript to a GitHub gist) or `/login <provider>` (pi
+ * provider auth) when YAGNI's model is a single `yagni` provider.
+ *
+ * The desktop palette is unaffected: pi's RPC `get_commands` (which the desktop
+ * app reads) already returns extension commands + prompt templates + skills and
+ * never includes built-ins. This wrapper is inert outside interactive TUI mode,
+ * where `addAutocompleteProvider` is handed a no-op factory.
+ */
+/** pi built-in slash commands hidden from YAGNI Code autocomplete. */
+export const HIDDEN_BUILTIN_SLASH_COMMANDS = [
+    "share", // ships a session transcript to a secret GitHub gist (off-brand + privacy footgun)
+    "login", // pi provider auth; YAGNI auth is `yagni login`, one provider
+    "logout", // pi provider auth; YAGNI auth is `yagni logout`
+    "scoped-models", // pi multi-model Ctrl+P cycling; YAGNI pins a single tier
+    "fork", // pi session-fork feature YAGNI never surfaces
+    "clone", // pi session-clone feature YAGNI never surfaces
+    "tree", // pi session-tree feature YAGNI never surfaces
+    "trust", // pi project-trust prompt; collides with YAGNI guardrails
+    "changelog", // pi's own changelog, not YAGNI's
+];
+const HIDDEN = new Set(HIDDEN_BUILTIN_SLASH_COMMANDS);
+/**
+ * True when the text before the cursor is a slash-COMMAND name being typed —
+ * a leading `/` plus a name with no interior `/` or space. This mirrors pi's
+ * own slash-command detection (its `applyCompletion` treats a prefix with an
+ * interior `/` as a file path, e.g. the absolute path `/usr/local/...`), so we
+ * never strip a legitimate file-named completion.
+ */
+function isSlashCommandName(textBeforeCursor) {
+    return textBeforeCursor.startsWith("/")
+        && !textBeforeCursor.slice(1).includes("/")
+        && !textBeforeCursor.slice(1).includes(" ");
+}
+function filterHiddenSlashSuggestions(suggestions) {
+    const items = suggestions.items.filter((item) => !HIDDEN.has(item.value));
+    if (items.length === 0)
+        return null;
+    return { ...suggestions, items };
+}
+/** Wrap pi's built-in autocomplete provider so hidden built-ins never complete. */
+function makeYagniAutocompleteProvider(current) {
+    return {
+        triggerCharacters: current.triggerCharacters,
+        async getSuggestions(lines, cursorLine, cursorCol, options) {
+            const textBeforeCursor = (lines[cursorLine] ?? "").slice(0, cursorCol);
+            if (!isSlashCommandName(textBeforeCursor)) {
+                return current.getSuggestions(lines, cursorLine, cursorCol, options);
+            }
+            const suggestions = await current.getSuggestions(lines, cursorLine, cursorCol, options);
+            return suggestions ? filterHiddenSlashSuggestions(suggestions) : null;
+        },
+        applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+            return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+        },
+        shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+            return current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
+        },
+    };
+}
+/** Register the slash-command filter on `session_start` (TUI autocomplete only). */
+export function registerSlashCommandFilter(pi) {
+    pi.on("session_start", (_event, ctx) => {
+        if (ctx.mode !== "tui" || !ctx.hasUI)
+            return;
+        try {
+            ctx.ui.addAutocompleteProvider(makeYagniAutocompleteProvider);
+        }
+        catch {
+            // Filtering is cosmetic; a failure must never break session start.
+        }
+    });
+}
+//# sourceMappingURL=slashCommandFilter.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.0.1-staging.1194.1",
+  "version": "1.0.1-staging.1199.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -41,5 +41,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "35074745ec6180e38a015e902c91bd2e10a1fa7d"
+  "yagniSourceSha": "b28af96b1b6e11135b4be8a910f3a4b51b069cbe"
 }