@yagni-app/code-staging 0.3.0-staging.1077.1 → 0.3.0-staging.1079.1

package/dist/cli.d.ts

@@ -28,6 +28,20 @@ export declare function seedEditorPadding(piAgentDir: string): void;
  * settings file or a write failure must never block the launch.
  */
 export declare function seedCollapseChangelog(piAgentDir: string): void;
+/**
+ * Seed `hideThinkingBlock` into the per-profile pi `settings.json` so the
+ * model's raw chain-of-thought collapses to a single labeled line instead of
+ * streaming its entire reasoning to the terminal. Fills the key in only when
+ * absent — an explicit user choice (including false, e.g. via Ctrl+T) is never
+ * overwritten. Best-effort: a missing/corrupt settings file or a write failure
+ * must never block the launch.
+ *
+ * Returns true only when this call actually collapsed reasoning for the first
+ * time (the key was absent and the write succeeded), so the caller can pass a
+ * one-time hint to the extension. Ctrl+T still reveals the full trace and
+ * persists the user's choice, so this default is always reversible.
+ */
+export declare function seedHideThinkingBlock(piAgentDir: string): boolean;
 export declare const HELP_TEXT: string;
 /** Parse `use <name> [--base-url <url>]` argv into its parts. */
 export declare function parseUseArgs(args: string[]): {

package/dist/cli.js

@@ -64,6 +64,11 @@ async function confirmOnTty(question) {
  *  - writes ATOMICALLY (temp file + rename) and preserves the existing file's
  *    permissions, so a crash mid-write can never truncate the user's settings.
  * Any failure is swallowed: seeding must never block or break a launch.
+ *
+ * Returns true only when this call actually wrote the key (the key was absent
+ * and the write succeeded), letting callers distinguish a first-seed from a
+ * no-op so they can surface a one-time hint. Returns false on any existing
+ * value (explicit or previously seeded), a back-off case, or a write failure.
  */
 function seedSetting(piAgentDir, key, value) {
     try {
@@ -74,22 +79,22 @@ function seedSetting(piAgentDir, key, value) {
             // Refuse to follow a symlink: we must only ever write a regular, real
             // settings file the user (or pi) owns.
             if (lstatSync(settingsPath).isSymbolicLink())
-                return;
+                return false;
             let parsed;
             try {
                 parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
             }
             catch {
-                return; // corrupt file: back off rather than clobber the user's settings
+                return false; // corrupt file: back off rather than clobber the user's settings
             }
             if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-                return; // non-object settings: leave it alone
+                return false; // non-object settings: leave it alone
             }
             settings = parsed;
             existingMode = lstatSync(settingsPath).mode & 0o777;
         }
         if (settings[key] !== undefined)
-            return; // user already chose
+            return false; // user (or a prior seed) already set it
         settings[key] = value;
         // Atomic write: serialize to a temp file in the same directory, then
         // rename over the target. A crash leaves either the old file or the temp
@@ -106,9 +111,11 @@ function seedSetting(piAgentDir, key, value) {
         // replaces the inode, which would otherwise reset to 0600).
         if (existingMode !== undefined)
             chmodSync(settingsPath, existingMode);
+        return true;
     }
     catch {
         // never block launch on a settings-seed failure
+        return false;
     }
 }
 /**
@@ -131,6 +138,22 @@ export function seedEditorPadding(piAgentDir) {
 export function seedCollapseChangelog(piAgentDir) {
     seedSetting(piAgentDir, "collapseChangelog", true);
 }
+/**
+ * Seed `hideThinkingBlock` into the per-profile pi `settings.json` so the
+ * model's raw chain-of-thought collapses to a single labeled line instead of
+ * streaming its entire reasoning to the terminal. Fills the key in only when
+ * absent — an explicit user choice (including false, e.g. via Ctrl+T) is never
+ * overwritten. Best-effort: a missing/corrupt settings file or a write failure
+ * must never block the launch.
+ *
+ * Returns true only when this call actually collapsed reasoning for the first
+ * time (the key was absent and the write succeeded), so the caller can pass a
+ * one-time hint to the extension. Ctrl+T still reveals the full trace and
+ * persists the user's choice, so this default is always reversible.
+ */
+export function seedHideThinkingBlock(piAgentDir) {
+    return seedSetting(piAgentDir, "hideThinkingBlock", true);
+}
 async function runDefault(passthroughArgs) {
     // Cache-backed update nudge (never a network wait), then a background cache
     // refresh that completes while the session runs. Both fail soft.
@@ -168,6 +191,12 @@ async function runDefault(passthroughArgs) {
     // unreadable settings.json must never block the launch.
     seedEditorPadding(piAgentDir);
     seedCollapseChangelog(piAgentDir);
+    // Collapse raw chain-of-thought to one line on first launch. Seeded here
+    // (before the extension boots) so `setHiddenThinkingLabel`/any Ctrl+T toggle
+    // in this session sees the collapsed default. `seededHideThinking` is true
+    // only THIS launch — a downstream one-time hint must not re-nag on the next
+    // real run once the key already exists.
+    const seededHideThinking = seedHideThinkingBlock(piAgentDir);
     // Generate the shadow pi package so the terminal title/process name read
     // "YAGNI Code" instead of "pi"/"π". Best-effort: if it can't be built we
     // still launch (un-rebranded but hermetic), never blocking the agent.
@@ -216,6 +245,7 @@ async function runDefault(passthroughArgs) {
             stateDir: credentialsDir(),
             cliVersion: cliVersion(),
             baseEnv: process.env,
+            ...(seededHideThinking ? { hideThinkingSeeded: true } : {}),
         });
     }
     catch (err) {

package/dist/extension/index.js

@@ -615,6 +615,28 @@ export async function registerYagni(pi, deps = {}) {
             // 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)(tui, theme, footerData));
+            // 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

package/dist/extension/permission.js

@@ -370,12 +370,13 @@ export function registerPermissionGate(pi, deps = {}) {
                     };
                 }
             }
-            // Guardian disabled + prompt band: auto mode blocks, review falls through to confirm.
+            // Guardian disabled (kill switch / env var) or not wired: pre-Guardian
+            // behavior. Auto mode allows prompt-band commands — the kill switch must
+            // never leave sessions stricter than before Guardian existed. The
+            // forbidden band still blocks above (decideGate), and review mode still
+            // falls through to the user confirm below.
             if (decision.classify === "prompt" && (!guardianState || guardianDisabled) && mode === "auto") {
-                return {
-                    block: true,
-                    reason: "Ambiguous command blocked (Guardian disabled). Switch to /mode review to approve manually.",
-                };
+                return {};
             }
             if (decision.confirm) {
                 // Review mode needs a confirmation. With no dialog-capable UI (headless),

package/dist/launch.d.ts

@@ -71,6 +71,13 @@ export interface BuildLaunchOptions {
     cliVersion?: string;
     /** Base environment to extend (defaults to process.env at call sites). */
     baseEnv?: NodeJS.ProcessEnv;
+    /**
+     * Whether this launch freshly collapsed reasoning (seeded `hideThinkingBlock`
+     * for the first time). Forwarded as `YAGNI_HIDE_THINKING_SEEDED=1` so the
+     * extension can surface a single one-time "reasoning is collapsed" hint.
+     * Omitted/false on repeat launches: the hint must not re-nag.
+     */
+    hideThinkingSeeded?: boolean;
     /** Clock seam for the token-expiry preflight (defaults to Date.now). */
     now?: () => number;
     /**

package/dist/launch.js

@@ -97,6 +97,10 @@ export function buildLaunch(creds, passthroughArgs, opts) {
         // Match the e2b harness defaults: skip pi's update check + telemetry.
         PI_SKIP_VERSION_CHECK: "1",
         PI_TELEMETRY: "0",
+        // One-time marker for the "reasoning is collapsed" hint: only set on the
+        // launch that actually seeded the collapse default. Absent on every later
+        // launch so the hint never re-nags. (See hideThinkingSeeded in the docs.)
+        ...(opts.hideThinkingSeeded ? { YAGNI_HIDE_THINKING_SEEDED: "1" } : {}),
         // Forward the chosen horizontal pad so the extension's footer aligns with
         // the editor (which the launcher pads by seeding editorPaddingX). The
         // footer can't read pi's settings, so the value crosses over env.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "0.3.0-staging.1077.1",
+  "version": "0.3.0-staging.1079.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)",
@@ -38,5 +38,5 @@
     "@earendil-works/pi-tui": "0.84.1",
     "typebox": "^1.3.11"
   },
-  "yagniSourceSha": "38b2372ff55b9374b52e94a3836be6e8c942b8df"
+  "yagniSourceSha": "a542e64e336db6c91e55455e9eb5d4cb584e012b"
 }