@yagni-app/code 0.2.1 → 0.3.1

package/dist/extension/index.js

@@ -1,39 +1,48 @@
+import { createHash } from "node:crypto";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { Text } from "@earendil-works/pi-tui";
 import { DEFAULT_ADVISOR_LIMITS, formatAdvisorSubtotal, makeAdvisorState } from "./advisor.js";
+import { appendGrant, loadGrants, resolveRepoKey, storagePrefix } from "./approvedPrefixes.js";
+import { redactCommand } from "./redact.js";
+import { formatGuardianSubtotal, GUARDIAN_MODEL_TIER, makeGuardianState, resolveGuardianLimits, reviewCommand } from "./guardian.js";
 import { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
-import { registerBoostCommand } from "./boostCommand.js";
 import { makeAskYagniTool } from "./askYagniTool.js";
+import { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
 import { makeReviewBusinessMatchTool } from "./reviewTool.js";
+import { registerCmuxBridge } from "./cmux/index.js";
 import { makeRecordEngineeringContextTool } from "./recordContextTool.js";
 import { makeRecordDecisionTool } from "./recordDecisionTool.js";
 import { makeSuggestNextWorkTool } from "./nextWorkTool.js";
-import { BRAND_NAME, brandSystemPrompt, brandingDisabled, buildMastheadString, YAGNI_IDENTITY_DRIVER } from "./branding.js";
-import { appendClaudeRules, claudeRulesSection } from "./claudeRules.js";
+import { BRAND_NAME, brandSystemPrompt, brandingDisabled, buildMastheadString, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY_ULTRA } from "./branding.js";
+import { claudeRulesSection } from "./claudeRules.js";
 import { registerCostCommand } from "./costHud.js";
 import { isDebug } from "./diagnostics.js";
 import { droppedSessionRuns, sessionRunIds } from "./sessionRuns.js";
 import { codeStateHome } from "./stateHome.js";
+import { createYagniFooterFactory, cyclePermissionMode, formatCwd, GIT_MUTATING_PATTERN, isShiftTab } from "./footer.js";
 import { RerouteNotifier } from "./rerouteNotice.js";
 import { isFreshWorkspace, registerTeamSetupCommand, runInitPass as defaultRunInitPass } from "./initPass.js";
 import { isInitDone as defaultIsInitDone, markInitDone as defaultMarkInitDone } from "./initDone.js";
 import { fetchMcpServers as defaultFetchMcpServers, registerMcpCommand, registerMcpTools, } from "./mcpTools.js";
 import { registerGoCommand } from "./pipeline/goCommand.js";
 import { registerGoCompareCommand } from "./pipeline/goCompareCommand.js";
-import { DEFAULT_PERMISSION_POLICY, registerPermissionGate } from "./permission.js";
+import { DEFAULT_PERMISSION_POLICY, createModeHolder, registerPermissionGate } from "./permission.js";
 import { registerSubagents } from "./subagents.js";
+import { createUltraHolder, registerUltraCommand } from "./ultra.js";
 import { registerTodos } from "./todos.js";
 import { registerDecisionCommands } from "./decisions.js";
 import { makeDecisionCapture } from "./decisionCapture.js";
 import { registerAmbientRecall } from "./recall.js";
 import { resilientFetch } from "./resilientFetch.js";
-import { installUncaughtExceptionMonitor } from "./crashReport.js";
+import { installUncaughtExceptionMonitor, makeCrashReporter } 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 { defaultMineBeatGit, fileMineBeatMarkers, maybeOfferMiningBeat as defaultMaybeOfferMiningBeat, } from "./mineBeat.js";
+import { makeFlywheelState } from "./flywheel.js";
 function isEvalMode(env = process.env) {
     return env.YAGNI_CODE_EVAL_MODE === "1";
 }
@@ -111,19 +120,48 @@ export async function registerYagni(pi, deps = {}) {
     if (!evalMode) {
         installUncaughtExceptionMonitor({ baseUrl, getToken: getTokenFn, env: deps.env });
     }
-    const catalog = await fetchCatalog({ baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
+    // YAG-500 Fix E: non-fatal auth-event reporter for 401s on the model path.
+    // Reuses the crash endpoint (/api/yagni-code/crash) with a distinct context
+    // so auth failures are visible in Sentry/backend logs. Gated on !evalMode
+    // like every other external side effect; injectable for tests.
+    const authReporter = deps.authReporter ??
+        (!evalMode
+            ? makeCrashReporter({ baseUrl, getToken: getTokenFn, fetchImpl: deps.fetchImpl, env: deps.env })
+            : async () => { });
+    // YAG-500 Fix A+C: the model-path 401 recovery outcome, set by the
+    // message_end handler so it can produce the right user-facing message. The
+    // after_provider_response event does NOT fire on a 401 (the OpenAI SDK throws
+    // before onResponse is reached), so message_end is the only seam.
+    let lastAuthRecovery = null;
+    const { models: fullCatalog, guardianEnabled: workspaceGuardianEnabled, guardianStorage: guardianStorageTier, } = await fetchCatalog({ baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
+    // Lock the interactive session to the `advanced` tier only. The backend
+    // catalog returns all tiers, but only `advanced` is registered with the
+    // `yagni` provider, so /model and Ctrl+P show a single entry. Child
+    // processes (/go, subagents, advisor) fetch their own catalog and register
+    // their own provider, so they are unaffected by this filter.
+    const catalog = fullCatalog.filter((m) => m.id === "advanced");
     // YAG-471: the driver's own completions carry attribution headers read from
     // this process's env (YAGNI_SESSION_ID minted by the launcher; YAGNI_CALLER
     // defaults to "driver" when unset, i.e. every session that is not a /go
     // child, a subagent, or an advisor consult).
     pi.registerProvider("yagni", buildYagniProvider(catalog, baseUrl, attributionHeaders(deps.env)));
     const toolOpts = { baseUrl, getToken: getTokenFn, fetchImpl: authedFetch };
-    pi.registerTool(makeAskYagniTool(toolOpts));
-    // The peak-tier escalation for Balanced sessions (YAG-380). Registered
+    // One flywheel state per session, shared by ask_yagni (caps how many
+    // no-position record suggestions reach the model) and record_decision
+    // (flywheel-attributed records send dedupe: true). Run 7.
+    const flywheelState = makeFlywheelState();
+    pi.registerTool(makeAskYagniTool({ ...toolOpts, flywheel: flywheelState, getRepo: () => sessionRepo }));
+    // Ticket write-back (spec 2026-08-09): explicit user-intent writes to the
+    // workspace tracker, attributed to the developer via per-user credentials.
+    if (!evalMode) {
+        pi.registerTool(makeFileTicketTool(toolOpts));
+        pi.registerTool(makeUpdateTicketStatusTool(toolOpts));
+    }
+    // The peak-tier escalation for Advanced sessions (YAG-380). Registered
     // UNCONDITIONALLY and gated at execute time on the live session model: pi's
     // picker can switch the model after activation, so a registration-time tier
-    // check would both leave the tool live after switching away from Balanced and
-    // hide it forever from a session that switched TO Balanced. One state handle
+    // check would both leave the tool live after switching away from Advanced and
+    // hide it forever from a session that switched TO Advanced. One state handle
     // per session, shared with /advise so they draw on the same cap.
     const advisorState = makeAdvisorState();
     const askAdvisorTool = makeAskAdvisorTool({ state: advisorState });
@@ -131,12 +169,6 @@ export async function registerYagni(pi, deps = {}) {
     // /advise runs the SAME tool, sharing the state handle, so a manual consult
     // draws on the same cap rather than opening a side channel around it.
     registerAdviseCommand(pi, askAdvisorTool);
-    // /boost — the sanctioned session-scoped escalation to Peak (spec §7,
-    // YAG-380 follow-on). Unlike /advise's per-call consult, this flips the
-    // DRIVER's own live model to peak until /boost off or the session ends.
-    // The returned handle threads isBoosted() into /cost below, the same way
-    // advisorState threads into advisorSubtotal.
-    const boostCommand = registerBoostCommand(pi, { env });
     // The differentiated business-grounded tools (loop bricks): review a change
     // for business fit, rank the next work by business priority, and record the
     // engineering rationale back onto the work-item.
@@ -146,7 +178,7 @@ export async function registerYagni(pi, deps = {}) {
         pi.registerTool(makeRecordEngineeringContextTool(toolOpts));
         // The capture half of the judgment loop: bank a product-intent decision so
         // ask_yagni answers the same question next time instead of interrupting a human.
-        pi.registerTool(makeRecordDecisionTool(toolOpts));
+        pi.registerTool(makeRecordDecisionTool({ ...toolOpts, flywheel: flywheelState }));
     }
     // The visible checklist for multi-step work: the todo_write tool, its
     // above-editor widget, and /todos. Branch-replayed, so forks and resumes
@@ -160,7 +192,12 @@ export async function registerYagni(pi, deps = {}) {
     // 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.
-    registerSubagents(pi);
+    // Ultra mode (/ultra) is an explicit orchestration dial: it swaps the
+    // driver's delegation identity for the diamond directive (see the
+    // before_agent_start handler below) and widens the tool's fan-out ceiling.
+    const ultraHolder = createUltraHolder();
+    registerSubagents(pi, { isUltra: () => ultraHolder.get() });
+    registerUltraCommand(pi, ultraHolder);
     // Shared fetch timeout for the small, interactive display-path reads below
     // (/cost's spend + headroom, and Task 8's per-run spend for /go's summary):
     // 5s, not the 10s other boot/grounding fetches use, because the user is
@@ -212,7 +249,101 @@ export async function registerYagni(pi, deps = {}) {
     // drafts a decision on "don't ask again". Default auto, so still additive.
     // Mutating MCP tools join write/edit/bash in the gate policy: plan mode
     // holds them, review mode confirms them.
+    const modeHolder = createModeHolder();
+    const footerInvalidateHandle = { invalidateGit: () => { }, requestRender: () => { } };
+    const guardianState = makeGuardianState();
+    // Disabled by the local env override OR the workspace kill switch
+    // (yagni_code.guardian, read from the catalog response at launch). The env
+    // var wins for a single developer's debugging; the flag turns it off for
+    // every session in the workspace.
+    const guardianDisabled = env.YAGNI_DISABLE_GUARDIAN === "1" ||
+        env.YAGNI_DISABLE_GUARDIAN === "true" ||
+        !workspaceGuardianEnabled;
+    const guardianTier = env.YAGNI_GUARDIAN_TIER ?? GUARDIAN_MODEL_TIER;
+    const guardianLimits = resolveGuardianLimits(env);
+    // YAG-510: guardian.log stays the sanitized local debug sink (hash-only,
+    // never the command). The remote guardian-events stream below is the
+    // separate, opt-in, per-workspace analytics sink; the two are independent.
+    const guardianLogSink = (payload) => {
+        try {
+            if (process.env.NODE_TEST_CONTEXT)
+                return;
+            const logPath = join(codeStateHome(null), "logs", "guardian.log");
+            mkdirSync(dirname(logPath), { recursive: true });
+            appendFileSync(logPath, JSON.stringify({ ts: new Date().toISOString(), ...payload }) + "\n", "utf8");
+        }
+        catch { /* logging must never break the session */ }
+    };
+    // YAG-510: persisted "don't ask again" grants, per-repo keyed. Loaded once
+    // at startup (grants added by other concurrent sessions appear next launch —
+    // the startup load is the trust boundary; live reload was reviewed and
+    // rejected as a same-session self-authorization path, PR #1698).
+    const sessionGrants = evalMode ? [] : loadGrants();
+    const GUARDIAN_EVENT_TIMEOUT_MS = 5_000;
     registerPermissionGate(pi, {
+        modeHolder,
+        guardianState,
+        guardianLimits,
+        guardianTier,
+        guardianDisabled,
+        guardianReview: (command, deps) => reviewCommand(command, { ...deps, modelTier: guardianTier }),
+        onGuardianReview: (ev) => guardianLogSink(ev),
+        grants: sessionGrants,
+        resolveRepoKey,
+        persistGrant: (grant) => {
+            if (!evalMode)
+                appendGrant(grant);
+        },
+        // Opt-in storage stream (YAG-510). Tier decides what leaves the machine:
+        // "off" → nothing (not even sent); "hash" → sha256 + family prefix +
+        // metadata, no command content; "raw" → adds client-REDACTED command and
+        // rationale. Fire-and-forget: one attempt, short timeout, failures logged
+        // fail-soft to guardian.log — a storage outage never touches the session.
+        onGuardianEvent: guardianStorageTier === "off" || evalMode
+            ? undefined
+            : (ev) => {
+                void (async () => {
+                    try {
+                        const body = {
+                            sessionId: env.YAGNI_SESSION_ID ?? null,
+                            commandHash: createHash("sha256").update(ev.command).digest("hex"),
+                            commandPrefix: storagePrefix(ev.command),
+                            outcome: ev.outcome,
+                            mode: ev.mode,
+                            ...(ev.execJustification ? { execJustification: ev.execJustification } : {}),
+                            ...(ev.riskLevel ? { riskLevel: ev.riskLevel } : {}),
+                            ...(ev.tier ? { tier: ev.tier } : {}),
+                            ...(ev.durationMs !== undefined ? { durationMs: ev.durationMs } : {}),
+                        };
+                        if (guardianStorageTier === "raw") {
+                            body.command = redactCommand(ev.command);
+                            if (ev.rationale)
+                                body.rationale = redactCommand(ev.rationale);
+                        }
+                        const res = await resilientFetch(`${baseUrl}/api/yagni-code/guardian-events`, {
+                            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_event_post_failed", status: res.status });
+                        }
+                    }
+                    catch (err) {
+                        guardianLogSink({
+                            event: "guardian_event_post_failed",
+                            error: err instanceof Error ? err.message : "unknown",
+                        });
+                    }
+                })();
+            },
         ...(mcpMutatingTools.length > 0
             ? {
                 policy: {
@@ -224,6 +355,7 @@ export async function registerYagni(pi, deps = {}) {
                         ...DEFAULT_PERMISSION_POLICY.reviewConfirmTools,
                         ...mcpMutatingTools,
                     ],
+                    alwaysConfirmTools: DEFAULT_PERMISSION_POLICY.alwaysConfirmTools,
                 },
             }
             : {}),
@@ -247,12 +379,11 @@ export async function registerYagni(pi, deps = {}) {
         // turn_end accumulator. Thread the subtotal in explicitly for the local
         // fallback line; the server-authoritative line already counts advisor
         // spend as an ordinary caller row.
-        advisorSubtotal: () => formatAdvisorSubtotal(advisorState.read(), DEFAULT_ADVISOR_LIMITS),
-        // YAG-380 follow-on: a boosted session that only chats never produces a
-        // server-side boosted row (see boostCommand.ts's KNOWN-asymmetry
-        // docblock), so /cost needs the live client-side toggle on top of
-        // whatever the server rows show.
-        isBoosted: () => boostCommand.isBoosted(),
+        advisorSubtotal: () => {
+            const advisor = formatAdvisorSubtotal(advisorState.read(), DEFAULT_ADVISOR_LIMITS);
+            const guardian = formatGuardianSubtotal(guardianState.read(), guardianLimits);
+            return [advisor, guardian].filter(Boolean).join(" ");
+        },
         fetchHeadroom: async (signal) => {
             try {
                 const res = await resilientFetch(`${baseUrl}/api/yagni-code/credits`, { method: "GET", headers: { authorization: `Bearer ${getTokenFn() ?? ""}` } }, { fetchImpl: authedFetch, signal, policy: { maxAttempts: 1, backoffBaseMs: 0, backoffMaxMs: 0, timeoutMs: COST_FETCH_TIMEOUT_MS, jitterRatio: 0 } });
@@ -336,11 +467,27 @@ export async function registerYagni(pi, deps = {}) {
     // must never block the agent), then inject it into the system prompt so the
     // very first turn already knows how this company and codebase work.
     const fetchBrief = deps.fetchContextBrief ?? defaultFetchContextBrief;
+    // Resolved BEFORE the brief fetch so /context can answer repoDecisionCount
+    // in the same round-trip (the mining beat's signal). Best-effort: undefined
+    // outside a git repo or without an origin remote.
+    const resolveRepoFn = deps.resolveRepoFullName ?? ((cwd) => defaultMineBeatGit.repoFullName(cwd));
+    let sessionRepo;
+    try {
+        sessionRepo = evalMode ? undefined : resolveRepoFn(process.cwd());
+    }
+    catch {
+        sessionRepo = undefined;
+    }
     let contextBrief;
     let briefResult = null;
     if (!evalMode) {
         try {
-            briefResult = await fetchBrief({ baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
+            briefResult = await fetchBrief({
+                baseUrl,
+                getToken: getTokenFn,
+                fetchImpl: authedFetch,
+                repo: sessionRepo,
+            });
             contextBrief = briefResult?.brief?.trim() ? briefResult.brief : undefined;
         }
         catch {
@@ -401,11 +548,21 @@ export async function registerYagni(pi, deps = {}) {
     // assembled prompt passes through byte-exact (no rewrite, no brief
     // injection, no rules section, no delegation identity).
     const noBranding = brandingDisabled(env);
-    const identity = isDriverCaller(env) ? YAGNI_IDENTITY_DRIVER : undefined;
+    // Resolved per turn (not once at activation): /ultra can flip the driver
+    // between the delegation and diamond identities mid-session.
+    const isDriver = isDriverCaller(env);
     pi.on("before_agent_start", (event) => noBranding
         ? undefined
         : {
-            systemPrompt: appendClaudeRules(brandSystemPrompt(event.systemPrompt, { contextBrief, identity }), rulesSection),
+            systemPrompt: brandSystemPrompt(event.systemPrompt, {
+                contextBrief,
+                identity: isDriver
+                    ? ultraHolder.get()
+                        ? YAGNI_IDENTITY_ULTRA
+                        : YAGNI_IDENTITY_DRIVER
+                    : undefined,
+                rulesSection,
+            }),
         });
     // Two finalized-message guards share this handler (their conditions are
     // mutually exclusive: YAG-460 takes error-stopped messages, YAG-466 takes
@@ -425,7 +582,7 @@ export async function registerYagni(pi, deps = {}) {
     // renders. The message text deliberately matches neither pi's overflow nor
     // retryable-error patterns: a deterministic empty response should not burn
     // auto-retries or trigger compaction — the user decides what to do next.
-    pi.on("message_end", (event, ctx) => {
+    pi.on("message_end", async (event, ctx) => {
         const msg = event.message;
         if (msg.role !== "assistant")
             return;
@@ -440,6 +597,71 @@ export async function registerYagni(pi, deps = {}) {
         // post-replacement message, and dropping the marker would defeat the very
         // recovery this error exists to trigger.
         if (msg.stopReason === "error" && msg.errorMessage) {
+            // YAG-500: a 401 from the model proxy means the session token expired
+            // (or was revoked). Unlike tool 401s (handled by makeAuthedFetch), the
+            // model completion path has no 401-retry seam — pi's retryProviderRequest
+            // treats 401 as non-retryable, and after_provider_response never fires
+            // (the SDK throws before onResponse is reached). So message_end is the
+            // only place to detect it and trigger recovery. The regex matches
+            // "yagni login" (the backend's auth-error message) but NOT
+            // "request_too_large" (YAG-460's overflow marker).
+            const isAuthError = /yagni login/i.test(msg.errorMessage)
+                && !/request_too_large|context_too_large/i.test(msg.errorMessage);
+            if (isAuthError) {
+                lastAuthRecovery = null;
+                let rotated = false;
+                try {
+                    rotated = await tokenProvider.refresh();
+                }
+                catch {
+                    rotated = false;
+                }
+                lastAuthRecovery = rotated ? "refreshed" : "failed";
+                const explanation = rotated
+                    ? "Your session token expired but was refreshed automatically. Re-send your prompt to continue."
+                    : "Your session token expired and could not be refreshed. Run `yagni login`, then re-send your prompt. If the issue persists, restart YAGNI Code.";
+                if (ctx.hasUI) {
+                    try {
+                        ctx.ui.notify(explanation, rotated ? "info" : "error");
+                    }
+                    catch {
+                        // Surfacing the problem must never break the session itself.
+                    }
+                }
+                // YAG-500 Fix E: fire a non-fatal crash report so auth failures are
+                // visible in Sentry/backend logs. Reuses the crash endpoint with a
+                // distinct context. Fire-and-forget, fail-soft. The crash endpoint is
+                // now public (no token required), so the report lands even when the
+                // session token is expired and refresh failed — the most critical
+                // failure signal is no longer silently dropped.
+                void authReporter(new Error(`auth_401 on model path; refresh=${rotated ? "succeeded" : "failed"}`), "auth-failure").catch(() => { });
+                // YAG-500 Fix F: local diagnostics log under YAGNI_DEBUG.
+                if (isDebug(env)) {
+                    try {
+                        const logPath = join(codeStateHome(null, env), "logs", "auth-events.log");
+                        mkdirSync(dirname(logPath), { recursive: true });
+                        appendFileSync(logPath, JSON.stringify({
+                            ts: new Date().toISOString(),
+                            status: 401,
+                            refresh: rotated ? "succeeded" : "failed",
+                        }) + "\n", "utf8");
+                    }
+                    catch {
+                        // A diagnostic must never break the session.
+                    }
+                }
+                return { message: { ...msg, errorMessage: explanation } };
+            }
+            // YAG-460: the backend proxy answers an oversized conversation with an
+            // OpenAI-format 413 whose type is `request_too_large`. pi's own overflow
+            // detection matches that marker and runs full recovery — compact, then
+            // auto-retry the failed turn — so this branch must NOT call ctx.compact()
+            // (it would race the built-in recovery and lose the retry). Its only job
+            // is UX: replace the raw `413: {"error":{...}}` JSON with a readable
+            // message and tell the user what is happening. The rewritten text KEEPS
+            // the `request_too_large` marker verbatim: pi's _checkCompaction reads the
+            // post-replacement message, and dropping the marker would defeat the very
+            // recovery this error exists to trigger.
             const isContextTooLarge = /request_too_large|context_too_large/i.test(msg.errorMessage);
             if (!isContextTooLarge)
                 return;
@@ -486,7 +708,47 @@ export async function registerYagni(pi, deps = {}) {
             ctx.ui?.setStatus?.("brand", BRAND_NAME);
             // setHeader replaces the built-in header in place (verified against pi
             // 0.80.2 setExtensionHeader); the factory returns a simple Text component.
-            ctx.ui?.setHeader?.((_tui, theme) => new Text(buildMastheadString(theme)));
+            // Pass the launcher-forwarded CLI version (YAGNI_CODE_VERSION) and the
+            // home-collapsed cwd so the masthead shows them like the reference.
+            const mastheadVersion = process.env.YAGNI_CODE_VERSION?.trim() || undefined;
+            const mastheadCwd = formatCwd(process.cwd(), process.env.HOME);
+            ctx.ui?.setHeader?.((_tui, theme) => new Text(buildMastheadString(theme, { version: mastheadVersion, cwd: mastheadCwd })));
+            // Replace the built-in footer with the YAGNI status bar: folder +
+            // [worktree] + branch on line 1, model + token/cost stats + integer
+            // context % on line 2, and extension statuses (brand, todos, mode) on
+            // line 3. The factory captures ctx so the footer can read session data
+            // (token stats, context usage) that isn't on the footerData provider.
+            ctx.ui?.setFooter?.((tui, theme, footerData) => createYagniFooterFactory(ctx, modeHolder, footerInvalidateHandle)(tui, theme, footerData));
+            ctx.ui?.onTerminalInput?.((data) => {
+                if (isShiftTab(data)) {
+                    modeHolder.set(cyclePermissionMode(modeHolder.get()));
+                    footerInvalidateHandle.requestRender();
+                    return { consume: true };
+                }
+                return undefined;
+            });
+            // Label the collapsed chain-of-thought line so users know it is reasoning
+            // and how to reveal the full trace. Harmless when reasoning is expanded
+            // (the label only shows on hidden thinking blocks). Fails closed to pi's
+            // default "Thinking..." label.
+            try {
+                ctx.ui?.setHiddenThinkingLabel?.("Reasoning — Ctrl+T to expand");
+            }
+            catch {
+                // A label must never disrupt session start.
+            }
+            // One-time hint naming what changed now that reasoning is collapsed by
+            // default (option 2). Gated on the launcher's YAGNI_HIDE_THINKING_SEEDED
+            // marker so it fires only on the launch that actually seeded the key — it
+            // never re-nags on subsequent runs, even though the label above persists.
+            if (env.YAGNI_HIDE_THINKING_SEEDED === "1") {
+                try {
+                    ctx.ui?.notify("Reasoning is collapsed by default — Ctrl+T shows the full trace at any time.", "info");
+                }
+                catch {
+                    // A hint must never disrupt session start.
+                }
+            }
         }
         // Best-effort, once at session start: if the token is at or near expiry, say
         // so via a single notice so a long session does not silently start 401-ing
@@ -538,14 +800,54 @@ export async function registerYagni(pi, deps = {}) {
                 // The init pass is best-effort; a failure never blocks the session.
             }
         }
+        // Run 7: the opt-in repo seeding beat. Fires only on a genuine startup
+        // when /context reported an explicitly-empty repo-scoped ledger, once per
+        // repo (marker store). Fully fail-soft — a beat failure never blocks the
+        // session.
+        if (event.reason === "startup" && !evalMode) {
+            try {
+                const offerBeat = deps.offerMiningBeat ?? defaultMaybeOfferMiningBeat;
+                const markers = deps.mineBeatMarkers ?? fileMineBeatMarkers(codeStateHome(null, env));
+                await offerBeat(ctx, {
+                    repoFullName: sessionRepo,
+                    repoDecisionCount: briefResult?.repoDecisionCount,
+                    cwd: process.cwd(),
+                    baseUrl,
+                    getToken: getTokenFn,
+                    fetchImpl: authedFetch,
+                    markers,
+                });
+            }
+            catch {
+                // Seeding is best-effort; a failure never blocks the session.
+            }
+        }
+    });
+    pi.on("tool_result", (event) => {
+        if (event.toolName !== "bash")
+            return;
+        const command = typeof event.input?.command === "string"
+            ? event.input.command
+            : "";
+        if (GIT_MUTATING_PATTERN.test(command)) {
+            footerInvalidateHandle.invalidateGit();
+        }
     });
 }
 export default async function (pi) {
     await registerYagni(pi);
+    // cmux session bridge: report lifecycle state (running/idle), workspace
+    // naming, and resume bindings to cmux when running inside it. Complete
+    // no-op outside cmux — guarded by CMUX_SURFACE_ID. Registered in the
+    // default export (not registerYagni) so tests that call registerYagni
+    // directly don't get the bridge's handlers.
+    registerCmuxBridge(pi);
 }
 export { makeAskYagniTool } from "./askYagniTool.js";
+export { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
 export { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
 export { ADVISOR_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatAdvisorSubtotal, makeAdvisorState, } from "./advisor.js";
+export { DEFAULT_GUARDIAN_LIMITS, GUARDIAN_MODEL_TIER, formatGuardianSubtotal, makeGuardianState, resolveGuardianLimits, reviewCommand, } from "./guardian.js";
 export { makeReviewBusinessMatchTool } from "./reviewTool.js";
 export { makeRecordEngineeringContextTool } from "./recordContextTool.js";
 export { makeRecordDecisionTool } from "./recordDecisionTool.js";
@@ -556,7 +858,9 @@ export { recordDecision } from "./recordDecisionTool.js";
 export { runInitPass, runTeamSetup, registerTeamSetupCommand, isFreshWorkspace, readRepoIntake, draftEngineering, summarizeDraft, FRESH_BRIEF_MIN_CHARS, } from "./initPass.js";
 // Onramp Door B (F2a): the one-time init-pass idempotency marker.
 export { isInitDone, markInitDone, initDoneMarkerFile, _setInitDoneHomeForTest } from "./initDone.js";
-export { brandSystemPrompt, YAGNI_IDENTITY, YAGNI_IDENTITY_DRIVER, BRAND_NAME } from "./branding.js";
+export { brandSystemPrompt, YAGNI_IDENTITY, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY_ULTRA, BRAND_NAME } from "./branding.js";
+// Ultra mode (/ultra): the aggressive fan-out/verify/synthesize dial.
+export { createUltraHolder, registerUltraCommand } from "./ultra.js";
 export { attributionHeaders, isDriverCaller, fetchCatalog, getToken, getWorkspaceId, resolveBaseUrl, sanitizeCallerSegment, } from "./config.js";
 export { buildYagniProvider } from "./provider.js";
 export { registerGoCommand } from "./pipeline/goCommand.js";
@@ -571,12 +875,13 @@ export { buildVerifyEnv, detectVerifyCommand, makeRunVerify, parseVerifyFailures
 export { blindStages, reportOnlyStages, makeGroundedVsBlindEval, formatComparisonReport } from "./pipeline/eval.js";
 export { registerGoCompareCommand } from "./pipeline/goCompareCommand.js";
 // The general subagent tool: Claude Code-format agent discovery + fan-out.
-export { registerSubagents, makeSubagentTool, discoverSubagents, parseAgentMarkdown, buildSubagentStage, formatAgentList, mapModelTier, SUBAGENT_TOOL_NAME, GENERAL_AGENT_NAME, MAX_PARALLEL_SUBAGENTS, DEFAULT_SUBAGENT_TOOLS, } from "./subagents.js";
+export { registerSubagents, makeSubagentTool, discoverSubagents, parseAgentMarkdown, buildSubagentStage, formatAgentList, mapModelTier, SUBAGENT_TOOL_NAME, GENERAL_AGENT_NAME, MAX_PARALLEL_SUBAGENTS, MAX_PARALLEL_SUBAGENTS_ULTRA, DEFAULT_SUBAGENT_TOOLS, } from "./subagents.js";
 // The session todo checklist: todo_write tool, widget renderer, /todos.
-export { registerTodos, makeTodoTool, normalizeTodos, reconstructTodos, renderTodoWidget, formatTodoList, todoSummary, TODO_TOOL_NAME, MAX_TODOS, } from "./todos.js";
+export { registerTodos, makeTodoTool, normalizeTodos, reconstructTodos, renderTodoWidget, formatTodoList, formatTodoReminder, shouldRemindTodos, todoSummary, TODO_TOOL_NAME, TODO_REMINDER_TURNS, MAX_TODOS, } from "./todos.js";
 // P3 + W4: the permission gate seam (decideGate is pure; policy injectable) plus
 // the session bless-with-remember capture hook.
-export { decideGate, registerPermissionGate, filterStalePlanContext, DEFAULT_PERMISSION_POLICY, PLAN_CONTEXT_TYPE, PLAN_CONTEXT_MESSAGE, } from "./permission.js";
+export { decideGate, registerPermissionGate, filterStaleModeContext, filterStalePlanContext, buildModeContextMessage, DEFAULT_PERMISSION_POLICY, MODE_CONTEXT_TYPE, PLAN_CONTEXT_TYPE, PLAN_CONTEXT_MESSAGE, } from "./permission.js";
+export { classifyCommand, DEFAULT_EXEC_POLICY, } from "./execPolicy.js";
 // W4 judgment loop: the session bless store (tool + path-prefix, session-only).
 export { makeBlessStore, blessPath } from "./bless.js";
 // W4 judgment loop: the decisions surface (/decide + /decisions) + shared bank.

package/dist/extension/mineBeat.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The opt-in repo seeding beat (org plane, Run 7).
+ *
+ * On the first interactive session in a repo whose repo-scoped decision
+ * ledger is empty (`/context?repo=` reports `repoDecisionCount: 0`), YAGNI
+ * Code offers — once — to read the repo's own decision record and seed the
+ * ledger: "Read this repo's ADRs and docs and seed the decision ledger?".
+ * One keystroke, then the backend extracts, dedupes, and banks at most 12
+ * `repo_mined` asserted rows, and the beat prints the banked count plus the
+ * Library review deep link.
+ *
+ * Never automatic, never a nag: a decline writes a per-repo marker so the
+ * beat does not recur; an accepted pass marks the repo only after the server
+ * confirms (a transport failure leaves the offer available next session).
+ * The corpus is collected at git HEAD (same echo-chamber guard as
+ * repoDocs.ts) — ADR directories, agent-instruction root docs, top-level
+ * docs/*.md, and recent merge subjects — bounded client-side to the same
+ * limits the backend enforces.
+ */
+/**
+ * Client-side bounds on the mining corpus — mirror of the backend's
+ * MINE_INPUT_LIMITS so nothing is silently truncated server-side.
+ */
+export declare const MINE_BEAT_LIMITS: {
+    readonly maxDocs: 40;
+    readonly maxPathChars: 300;
+    readonly maxExcerptChars: 8000;
+    readonly maxCommitSubjects: 200;
+    readonly maxSubjectChars: 200;
+};
+/** One document offered to the mining pass. */
+export interface MineBeatDoc {
+    path: string;
+    excerpt: string;
+}
+/** Injectable git seam (default: execFileSync; every call fail-soft). */
+export interface MineBeatGit {
+    /** `owner/name` from the origin remote, or undefined outside a repo. */
+    repoFullName: (cwd: string) => string | undefined;
+    /** Tracked paths at HEAD, or null when cwd is not a usable git tree. */
+    listAtHead: (cwd: string) => string[] | null;
+    /** One file's HEAD content, or null when unreadable. */
+    readAtHead: (cwd: string, rel: string) => string | null;
+    /** Recent merge-commit subjects (fallback: plain subjects on squash repos). */
+    mergeSubjects: (cwd: string, max: number) => string[];
+}
+/** Parse `owner/name` from an origin remote URL (ssh or https). */
+export declare function parseRepoFullName(remote: string | null | undefined): string | undefined;
+export declare const defaultMineBeatGit: MineBeatGit;
+/** Is this HEAD-tracked path part of the repo's decision record? */
+export declare function isMineCandidate(rel: string): boolean;
+/** Collect the HEAD-era mining corpus, bounded to MINE_BEAT_LIMITS. */
+export declare function collectMineCorpus(cwd: string, gitImpl?: MineBeatGit): {
+    docs: MineBeatDoc[];
+    commitSubjects: string[];
+};
+/** Injectable marker-store seam (default: a JSON file per repo on disk). */
+export interface MineBeatMarkers {
+    has: (repoFullName: string) => boolean;
+    write: (repoFullName: string, status: "declined" | "seeded") => void;
+}
+/** Filesystem path of one repo's beat marker under the state home. */
+export declare function mineMarkerPath(stateHome: string, repoFullName: string): string;
+export declare function fileMineBeatMarkers(stateHome: string): MineBeatMarkers;
+/** The subset of the session-start ctx the beat needs. */
+export interface MineBeatUi {
+    hasUI: boolean;
+    ui: {
+        confirm?: (title: string, message: string) => Promise<boolean>;
+        notify: (message: string, level: "info" | "error") => void;
+    };
+}
+export interface OfferMiningBeatOptions {
+    repoFullName: string | undefined;
+    /** From `/context?repo=`; the beat fires ONLY on an explicit 0. */
+    repoDecisionCount: number | undefined;
+    cwd: string;
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+    markers: MineBeatMarkers;
+    gitImpl?: MineBeatGit;
+    collect?: typeof collectMineCorpus;
+}
+export interface MiningBeatOutcome {
+    offered: boolean;
+    accepted?: boolean;
+    banked?: number;
+}
+/**
+ * Offer (once per repo) and, on yes, run the seeding pass. Fail-soft
+ * throughout: any error surfaces as a notify at most, never a broken session.
+ */
+export declare function maybeOfferMiningBeat(ctx: MineBeatUi, opts: OfferMiningBeatOptions): Promise<MiningBeatOutcome>;
+//# sourceMappingURL=mineBeat.d.ts.map