@yagni-app/code 1.0.0 → 1.0.1

package/dist/extension/footer.js

@@ -42,6 +42,7 @@ import { spawnSync } from "node:child_process";
 import { statSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { createDiffStatCache, formatDiffStat } from "./diffStat.js";
 export const BRANCH_MAX_WIDTH = 60;
 const WORKTREE_MAX_WIDTH = 30;
 /** Section separator: single space + middle dot + single space. */
@@ -229,13 +230,18 @@ export function renderFooterLines(input, theme, width, padX = 0) {
     // terminal edge. Truncation runs against the reduced content width.
     const pad = " ".repeat(Math.max(0, Math.min(3, Math.floor(padX))));
     const contentWidth = Math.max(1, width - pad.length);
-    // Line 1: folder · [worktree] · branch
+    // Line 1: folder · [worktree] · branch [+N -M]
     const line1Parts = [theme.fg("accent", input.git.folder)];
     if (input.git.inRepo) {
         if (input.git.worktree)
             line1Parts.push(theme.fg("warning", `[${input.git.worktree}]`));
-        if (input.git.branch)
-            line1Parts.push(theme.fg("border", truncateEnd(input.git.branch, BRANCH_MAX_WIDTH, dim("…"))));
+        if (input.git.branch) {
+            const branchSpan = theme.fg("border", truncateEnd(input.git.branch, BRANCH_MAX_WIDTH, dim("…")));
+            // Diff badge rides the branch segment (Kimi's `branch [ +N -M ]` shape),
+            // colored dim — the same grey as the cost stats on line 2.
+            const diffSpan = input.diff ? ` ${dim(`[${input.diff}]`)}` : "";
+            line1Parts.push(branchSpan + diffSpan);
+        }
     }
     const line1 = pad + truncateToWidth(line1Parts.join(sep), contentWidth, dim("…"));
     // Line 2: [mode ·] model · ↑in ↓out $cost · ctx%
@@ -269,17 +275,23 @@ export function renderFooterLines(input, theme, width, padX = 0) {
 export function createYagniFooterFactory(ctx, modeHolder, invalidateHandle) {
     return (_tui, theme, footerData) => {
         let gitCache;
-        const unsubscribeBranch = footerData.onBranchChange?.(() => {
+        let diffStatCache;
+        const clearCaches = () => {
             gitCache = undefined;
-        });
+            diffStatCache = undefined;
+        };
+        const unsubscribeBranch = footerData.onBranchChange?.(clearCaches);
         const gitInfo = () => {
             if (!gitCache) {
-                gitCache = detectGitInfo(ctx.sessionManager.getCwd(), process.env.HOME || process.env.USERPROFILE);
+                // Read cwd once; both the git info and the diff cache key off it.
+                const dir = ctx.sessionManager.getCwd();
+                gitCache = detectGitInfo(dir, process.env.HOME || process.env.USERPROFILE);
+                diffStatCache = createDiffStatCache(dir);
             }
             return gitCache;
         };
         if (invalidateHandle) {
-            invalidateHandle.invalidateGit = () => { gitCache = undefined; };
+            invalidateHandle.invalidateGit = clearCaches;
             invalidateHandle.requestRender = () => { _tui?.requestRender?.(); };
         }
         return {
@@ -291,13 +303,14 @@ export function createYagniFooterFactory(ctx, modeHolder, invalidateHandle) {
                     git: gitInfo(),
                     model: ctx.model?.id ?? "no-model",
                     mode: modeHolder?.get() ?? null,
+                    diff: formatDiffStat(diffStatCache?.get() ?? null),
                     usage: collectUsage(ctx.sessionManager),
                     contextPercent: ctx.getContextUsage()?.percent ?? null,
                     statuses,
                 }, theme, width, resolveFooterPadX());
             },
             invalidate() {
-                gitCache = undefined;
+                clearCaches();
             },
             dispose() {
                 unsubscribeBranch?.();

package/dist/extension/index.d.ts

@@ -186,6 +186,12 @@ export { makeTokenProvider, makeAuthedFetch, persistRotationToProfile, PROACTIVE
 export type { TokenProvider, TokenProviderDeps, ScheduleFn } from "./tokenProvider.js";
 export { appendToSpool, loadSpool, flushSpool, sendOrSpool, spoolFile, MAX_SPOOL_AGE_MS, _setSpoolHomeForTest, } from "./spool.js";
 export type { SpoolEntry, SpoolClientOpts, FlushOutcome, JudgmentWriteOutcome } from "./spool.js";
+export { registerCondensedTools, displayPath, isScratchpadPath, primaryArg, formatRowTitle, formatWriteBody, formatEditBody, formatBashErrorBody, formatBashPartialBody, formatExpandedOutput, splitBashError, countPatchAdditions, WRITE_PREVIEW_LINES, DIFF_PREVIEW_LINES, } from "./condensedTools.js";
+export type { RegisterCondensedToolsDeps, RowStatus } from "./condensedTools.js";
+export { ToolRunTracker, summarizeRun, isQuiet, kindForTool } from "./toolRuns.js";
+export type { RowKind, ToolRow, ToolRowPatch } from "./toolRuns.js";
+export { registerWorkingLine, composeWorkingMessage, NULL_WORKING_LINE, WORKING_INDICATOR_FRAMES, WORKING_VERBS, } from "./workingLine.js";
+export type { WorkingLineHandle, RegisterWorkingLineDeps } from "./workingLine.js";
 export { crashReportsDisabled, installUncaughtExceptionMonitor, makeCrashReporter, reportFatalCrash, sanitizeCrashError, sanitizeCrashText, } from "./crashReport.js";
 export type { CrashReporter, CrashReporterOpts, FatalCrashOpts, SanitizedCrash } from "./crashReport.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/extension/index.js

@@ -16,6 +16,7 @@ import { makeRecordDecisionTool } from "./recordDecisionTool.js";
 import { makeSuggestNextWorkTool } from "./nextWorkTool.js";
 import { BRAND_NAME, brandSystemPrompt, brandingDisabled, buildMastheadString, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY_ULTRA } from "./branding.js";
 import { claudeRulesSection } from "./claudeRules.js";
+import { ensureScratchpadDir, SCRATCHPAD_TMPDIR_ENV, scratchpadDir as scratchpadDirFor, scratchpadSection } from "./scratchpad.js";
 import { registerCostCommand } from "./costHud.js";
 import { isDebug } from "./diagnostics.js";
 import { logEvent } from "./errorSink.js";
@@ -48,6 +49,9 @@ import { registerChipEditor } from "./chipEditor.js";
 import { defaultMineBeatGit, fileMineBeatMarkers, maybeOfferMiningBeat as defaultMaybeOfferMiningBeat, } from "./mineBeat.js";
 import { makeFlywheelState } from "./flywheel.js";
 import { registerSilentTurnReminder } from "./silentTurnReminder.js";
+import { registerCondensedTools } from "./condensedTools.js";
+import { isDesktopSurface } from "./surface.js";
+import { registerWorkingLine, WORKING_INDICATOR_FRAMES } from "./workingLine.js";
 function isEvalMode(env = process.env) {
     return env.YAGNI_CODE_EVAL_MODE === "1";
 }
@@ -160,6 +164,11 @@ export async function registerYagni(pi, deps = {}) {
     // no-position record suggestions reach the model) and record_decision
     // (flywheel-attributed records send dedupe: true). Run 7.
     const flywheelState = makeFlywheelState();
+    // The composed streaming status line ("Shaping… (12m 54s · ↓ 47.5k tokens)").
+    // Registered before the subagent/advisor tools: they publish their live
+    // progress through this handle so the elapsed/token suffix survives their
+    // overrides. TUI-gated internally (agent_start checks ctx.mode).
+    const workingLine = registerWorkingLine(pi);
     pi.registerTool(makeAskYagniTool({ ...toolOpts, flywheel: flywheelState, getRepo: () => sessionRepo }));
     // WebFetch (YAG-578): read an arbitrary URL as clean markdown + a
     // standard-tier extraction, replacing the bash + curl + python dance.
@@ -177,7 +186,7 @@ export async function registerYagni(pi, deps = {}) {
     // 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 });
+    const askAdvisorTool = makeAskAdvisorTool({ state: advisorState, workingLine });
     pi.registerTool(askAdvisorTool);
     // /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.
@@ -217,7 +226,7 @@ export async function registerYagni(pi, deps = {}) {
     // 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() });
+    registerSubagents(pi, { isUltra: () => ultraHolder.get(), workingLine });
     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):
@@ -593,6 +602,51 @@ export async function registerYagni(pi, deps = {}) {
     // pointers. Computed once per activation (rules are launch-time state, like
     // pi's own skill discovery); fail-soft to null.
     const rulesSection = claudeRulesSection(deps.env ?? process.env);
+    // YAG-575: session scratchpad — a permission-free dir the agent writes its
+    // working state to. Computed + ensured once at activation (like rulesSection,
+    // which must exist before the first before_agent_start), not on session_start,
+    // so the very first turn already carries the section. Fails closed: no
+    // sessionId (a bare pi run) or a failed mkdir means no section, and the mkdir
+    // failure is logged so a missing scratchpad is not silent.
+    const scratchpadDirPath = scratchpadDirFor({
+        sessionId: env.YAGNI_SESSION_ID ?? undefined,
+        cwd: process.cwd(),
+        tmp: env[SCRATCHPAD_TMPDIR_ENV] || undefined,
+    });
+    let scratchpadSectionText;
+    if (scratchpadDirPath) {
+        const ensured = ensureScratchpadDir(scratchpadDirPath);
+        if (ensured) {
+            scratchpadSectionText = scratchpadSection(ensured);
+        }
+        else {
+            logEvent({
+                source: "scratchpad",
+                level: "error",
+                event: "scratchpad_mkdir_failed",
+                sessionId: env.YAGNI_SESSION_ID ?? undefined,
+            });
+        }
+    }
+    // The condensed Claude Code-style transcript: the seven built-ins re-render
+    // as flat "● Tool(arg)" rows, quiet runs collapse into one "Read 2 files,
+    // ran 2 shell commands" summary line, and project writes/edits keep visible
+    // previews. Execution delegates to the same factory-made built-ins pi would
+    // have used (settings-honoring), so ONLY presentation changes — which is why
+    // eval mode keeps pi's stock registration (measured behavior stays
+    // byte-identical) and the desktop surface keeps the structured pipeline.
+    // YAGNI_CLASSIC_TOOL_ROWS=1 is the debugging escape hatch back to pi's
+    // boxed renderers.
+    if (!evalMode && !isDesktopSurface() && env.YAGNI_CLASSIC_TOOL_ROWS !== "1") {
+        try {
+            registerCondensedTools(pi, {
+                ...(scratchpadDirPath ? { scratchpadDir: scratchpadDirPath } : {}),
+            });
+        }
+        catch {
+            // Rendering must never break activation; pi's built-ins remain.
+        }
+    }
     // Own the identity + inject live company context (and repo rules) on every
     // turn. The extension loads identically in every pi process this app spawns —
     // the interactive driver AND every `/go` stage child, subagent, and advisor
@@ -617,6 +671,7 @@ export async function registerYagni(pi, deps = {}) {
                         : YAGNI_IDENTITY_DRIVER
                     : undefined,
                 rulesSection,
+                scratchpadSection: scratchpadSectionText,
             }),
         });
     // Turn-lifecycle WAL: a `turn_start` with no matching `turn_end` is the
@@ -819,6 +874,14 @@ export async function registerYagni(pi, deps = {}) {
             catch {
                 // A label must never disrupt session start.
             }
+            // The pulsing star indicator that pairs with the composed working line.
+            // Fails closed to pi's default spinner.
+            try {
+                ctx.ui?.setWorkingIndicator?.({ frames: [...WORKING_INDICATOR_FRAMES], intervalMs: 140 });
+            }
+            catch {
+                // An indicator 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
@@ -1015,5 +1078,10 @@ export { makeTokenProvider, makeAuthedFetch, persistRotationToProfile, PROACTIVE
 // W4 trust plumbing: the durable write-spool for the judgment-capture tools
 // (idempotencyKey-replayed; server-side dedup makes flush safe).
 export { appendToSpool, loadSpool, flushSpool, sendOrSpool, spoolFile, MAX_SPOOL_AGE_MS, _setSpoolHomeForTest, } from "./spool.js";
+// The condensed Claude Code-style transcript: flat tool rows, run summaries,
+// and the composed streaming status line.
+export { registerCondensedTools, displayPath, isScratchpadPath, primaryArg, formatRowTitle, formatWriteBody, formatEditBody, formatBashErrorBody, formatBashPartialBody, formatExpandedOutput, splitBashError, countPatchAdditions, WRITE_PREVIEW_LINES, DIFF_PREVIEW_LINES, } from "./condensedTools.js";
+export { ToolRunTracker, summarizeRun, isQuiet, kindForTool } from "./toolRuns.js";
+export { registerWorkingLine, composeWorkingMessage, NULL_WORKING_LINE, WORKING_INDICATOR_FRAMES, WORKING_VERBS, } from "./workingLine.js";
 export { crashReportsDisabled, installUncaughtExceptionMonitor, makeCrashReporter, reportFatalCrash, sanitizeCrashError, sanitizeCrashText, } from "./crashReport.js";
 //# sourceMappingURL=index.js.map

package/dist/extension/permission/execPolicy.js

@@ -727,12 +727,59 @@ function isPipeToShell(command) {
  * backticks, including inside double quotes). Matches FORBIDDEN rules only —
  * can upgrade the classification, never relax it.
  */
+const QUOTED_HEREDOC_OPEN = /^cat[ \t]+<<[ \t]*(?:'([^']+)'|"([^"]+)"|\\([A-Za-z_][A-Za-z0-9_]*))[ \t]*\r?\n/;
+/**
+ * Recognize the `cat <<'QUOTED' … QUOTED` idiom inside a command substitution.
+ *
+ * This is the one way to pass multi-line body content to `gh`/`git` as a
+ * literal string: the quoted delimiter (`<<'EOF'`, `<<"EOF"`, or `<<\EOF`)
+ * makes the heredoc body literal — no `$`/backtick expansion — and `cat` merely
+ * prints it. A body like `rm -rf /tmp/test-db` inside such a heredoc is PROSE,
+ * not a command; sweeping it for forbidden rules is a false positive.
+ *
+ * Returns true ONLY for the exact safe shape: the whole substitution is `cat`
+ * with no arguments, followed by a heredoc whose delimiter is quoted and whose
+ * terminator is the delimiter on its own final line. Any deviation (unquoted
+ * delimiter, extra args to `cat`, a second command after the terminator)
+ * returns false and falls through to the ordinary danger scan. Safety does not
+ * hinge on this exemption: the outer command (the `gh pr create`, the `rm`) is
+ * still classified on its own merits, heredoc or not.
+ */
+function isLiteralQuotedCatHeredoc(inner) {
+    const text = inner.trim();
+    const m = QUOTED_HEREDOC_OPEN.exec(text);
+    if (!m)
+        return false;
+    const delim = m[1] ?? m[2] ?? m[3];
+    const bodyStart = m[0].length;
+    const lines = text.slice(bodyStart).split(/\r?\n/);
+    if (lines.length === 0)
+        return false;
+    // The final line must be the bare delimiter (the closing `)` is already
+    // stripped by extractSubstitutions).
+    if (lines[lines.length - 1].trim() !== delim)
+        return false;
+    // No line BEFORE the terminator may equal the delimiter: in real bash, a
+    // delimiter line terminates the heredoc there, turning everything after it
+    // into an executed command (e.g. a body with a bare `EOF` line followed by
+    // `rm -rf /x` would run the `rm`). Reject that shape and fall to the scan.
+    for (const line of lines.slice(0, -1)) {
+        if (line.trim() === delim)
+            return false;
+    }
+    return true;
+}
 function dangerScanSubstitutions(command, policy, depth) {
     if (depth > MAX_SCAN_DEPTH)
         return null;
     for (const inner of extractSubstitutions(command)) {
         if (inner.trim().length === 0)
             continue;
+        // Quoted-heredoc cat: the body is literal data, not an executable
+        // command — skipping it avoids false "forbidden" hits on prose that happens
+        // to contain a forbidden-looking token. The outer command still classifies.
+        if (isLiteralQuotedCatHeredoc(inner))
+            continue;
         if (isPipeToShell(inner)) {
             return {
                 decision: "forbidden",

package/dist/extension/pipeline/invocation.d.ts

@@ -65,9 +65,16 @@ export declare function buildStageInvocation(stage: PipelineStage, ctx: {
  * `yagni` provider) before a stage passthrough. Mirrors buildLaunch's
  * `userChoseProvider` guard so a passthrough that already chose a provider is
  * left untouched.
+ *
+ * `otelExtensionPath` (absent on a non-exporting launch) additionally loads
+ * pi-otel so child LLM spend is traced too — stage children are the bulk of a
+ * /go run's cost, and an OTel export that misses them undercounts. The path
+ * arrives via `YAGNI_OTEL_EXTENSION_PATH` from the launcher's gate (see the
+ * CLI's otel.ts); the capture-mode and endpoint env rides the inherited env.
  */
 export declare function groundedChildArgv(stageArgv: string[], opts: {
     piCli: string;
     extensionPath: string;
+    otelExtensionPath?: string;
 }): string[];
 //# sourceMappingURL=invocation.d.ts.map

package/dist/extension/pipeline/invocation.js

@@ -84,6 +84,12 @@ export function buildStageInvocation(stage, ctx) {
  * `yagni` provider) before a stage passthrough. Mirrors buildLaunch's
  * `userChoseProvider` guard so a passthrough that already chose a provider is
  * left untouched.
+ *
+ * `otelExtensionPath` (absent on a non-exporting launch) additionally loads
+ * pi-otel so child LLM spend is traced too — stage children are the bulk of a
+ * /go run's cost, and an OTel export that misses them undercounts. The path
+ * arrives via `YAGNI_OTEL_EXTENSION_PATH` from the launcher's gate (see the
+ * CLI's otel.ts); the capture-mode and endpoint env rides the inherited env.
  */
 export function groundedChildArgv(stageArgv, opts) {
     const userChoseProvider = stageArgv.includes("--provider");
@@ -91,6 +97,7 @@ export function groundedChildArgv(stageArgv, opts) {
         opts.piCli,
         "-e",
         opts.extensionPath,
+        ...(opts.otelExtensionPath ? ["-e", opts.otelExtensionPath] : []),
         ...(userChoseProvider ? [] : ["--provider", "yagni"]),
         ...stageArgv,
     ];

package/dist/extension/pipeline/personas.js

@@ -56,7 +56,7 @@ Numbered, small, actionable steps — each names the file/function to touch.
 ## Risks
 What to watch for, including any decision the worker will be forced to make.
 
-Finish the job in ONE turn: do not end your turn on an interstitial like "now let me check X". Your FINAL message MUST be the complete plan in the format above (## Goal / ## Plan / ## Files to modify or create / ## Risks). Keep exploring with your tools until you can write the whole plan, then write it as your last message.
+Complete the task fully — do not gold-plate, but do not leave it half-done. Finish the job in ONE turn: do not end your turn on an interstitial like "now let me check X". Your FINAL message MUST be the complete plan in the format above (## Goal / ## Plan / ## Files to modify or create / ## Risks). Keep exploring with your tools until you can write the whole plan, then write it as your last message.
 
 Budget discipline: you have a hard output budget, and a plan that gets cut off mid-thought is worth less than a short plan that ships. Explore only until you can name the files and the steps — do not read broadly for completeness, and do not re-verify what you have already established. Aim for 5-10 short steps; the worker fills small gaps from the ticket. When in doubt, write the plan NOW.
 
@@ -65,7 +65,7 @@ const WORKER_BODY = `You are a worker with full capabilities, operating in an is
 
 You are grounded. Call ask_yagni before guessing about anything organization- or codebase-specific. Treat a confirmed answer as settled; when an answer is an unverified assumption or an inference and your change leans on it, say so in your Notes so the reviewer knows what to check. Critically: for ANY product-intent call you are forced to make that the plan did not settle — a behavior choice, a tradeoff, an interpretation of intent — call record_decision so the company's decision corpus captures it and the next agent inherits the call instead of re-litigating it. When ask_yagni reports no recorded position, follow its instruction and record the assumption you proceed on.
 
-You MUST make the change. If the plan is missing, partial, or appears cut off, do not stop at exploring: implement the ticket directly from the ticket text and the code, calling record_decision for any intent you infer. Ending your turn with no write/edit is a failure.
+Complete the task fully — do not gold-plate, but do not leave it half-done. You MUST make the change. If the plan is missing, partial, or appears cut off, do not stop at exploring: implement the ticket directly from the ticket text and the code, calling record_decision for any intent you infer. Ending your turn with no write/edit is a failure.
 
 Output:
 ## Completed
@@ -242,14 +242,14 @@ Numbered, small, actionable steps — each names the file/function to touch.
 ## Risks
 What to watch for, including any decision the worker will be forced to make.
 
-Finish the job in ONE turn: do not end your turn on an interstitial like "now let me check X". Your FINAL message MUST be the complete plan in the format above (## Goal / ## Plan / ## Files to modify or create / ## Risks). Keep exploring with your tools until you can write the whole plan, then write it as your last message.
+Complete the task fully — do not gold-plate, but do not leave it half-done. Finish the job in ONE turn: do not end your turn on an interstitial like "now let me check X". Your FINAL message MUST be the complete plan in the format above (## Goal / ## Plan / ## Files to modify or create / ## Risks). Keep exploring with your tools until you can write the whole plan, then write it as your last message.
 
 Budget discipline: you have a hard output budget, and a plan that gets cut off mid-thought is worth less than a short plan that ships. Explore only until you can name the files and the steps — do not read broadly for completeness, and do not re-verify what you have already established. Aim for 5-10 short steps; the worker fills small gaps from the ticket. When in doubt, write the plan NOW.
 
 Keep it concrete; the worker executes it verbatim.`;
 const WORKER_BLIND = `You are a worker with full capabilities, operating in an isolated context to implement a plan. Work autonomously and use the tools as needed.
 
-You MUST make the change. If the plan is missing, partial, or appears cut off, do not stop at exploring: implement the ticket directly from the ticket text and the code. Ending your turn with no write/edit is a failure.
+Complete the task fully — do not gold-plate, but do not leave it half-done. You MUST make the change. If the plan is missing, partial, or appears cut off, do not stop at exploring: implement the ticket directly from the ticket text and the code. Ending your turn with no write/edit is a failure.
 
 Output:
 ## Completed

package/dist/extension/pipeline/runner.d.ts

@@ -32,6 +32,7 @@ export interface RunStageDeps {
     resolveChild?: () => {
         piCli: string;
         extensionPath: string;
+        otelExtensionPath?: string;
     };
     /** Optional environment for spawned child stages. Defaults to Node's inherited env. */
     env?: NodeJS.ProcessEnv;

package/dist/extension/pipeline/runner.js

@@ -61,11 +61,19 @@ async function defaultWritePrompt(body) {
 /**
  * Default child resolution: the parent process IS pi (so `process.argv[1]` is
  * pi's cli), and our compiled extension entry sits one dir up from this module.
+ *
+ * `otelExtensionPath` comes from `YAGNI_OTEL_EXTENSION_PATH`, set by the
+ * launcher only when an OTLP endpoint is configured (see the CLI's otel.ts) —
+ * children then load pi-otel so their LLM spend is traced. Guarded with
+ * existsSync so a stale env value degrades to an untraced child, never a
+ * child that fails to boot.
  */
 function defaultResolveChild() {
     const piCli = process.argv[1] ?? "pi";
     const extensionPath = fileURLToPath(new URL("../index.js", import.meta.url));
-    return { piCli, extensionPath };
+    const otelPath = process.env.YAGNI_OTEL_EXTENSION_PATH;
+    const otelExtensionPath = otelPath && fs.existsSync(otelPath) ? otelPath : undefined;
+    return { piCli, extensionPath, ...(otelExtensionPath ? { otelExtensionPath } : {}) };
 }
 const EMPTY_USAGE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
 /** Truncate to PER_TASK_OUTPUT_CAP bytes, never exceeding the cap. */
@@ -116,8 +124,12 @@ export async function runStage(stage, ctx, deps) {
             lens: ctx.lens,
             ...(tierCap ? { tierCap } : {}),
         });
-        const { piCli, extensionPath } = resolveChild();
-        const argv = groundedChildArgv(passthrough, { piCli, extensionPath });
+        const { piCli, extensionPath, otelExtensionPath } = resolveChild();
+        const argv = groundedChildArgv(passthrough, {
+            piCli,
+            extensionPath,
+            ...(otelExtensionPath ? { otelExtensionPath } : {}),
+        });
         // Fold events into a fixed-size accumulator as they stream — never retain
         // the full array (that OOMs on a verbose stage; YAG-317 follow-up).
         const acc = newEventAccumulator();

package/dist/extension/pipeline/sessionWorktree.d.ts

@@ -0,0 +1,64 @@
+/**
+ * `-w / --worktree` session-worktree plumbing.
+ *
+ * The launcher (`yagni-code-cli`) reaches this module by file path (the same
+ * seam as `headlessGo.ts` → `runHeadlessGo`) so it can create/resume a named
+ * YAGNI worktree BEFORE spawning pi into it. The launcher owns the process
+ * lifecycle (spawn + `cwd` + exit summary); this module owns the git behavior.
+ *
+ * Design invariants (see the YAG-594 plan):
+ *  - **Add-only creation.** Every git op is `worktree add`, `fetch`, `show-ref`,
+ *    `symbolic-ref`, or `rev-parse`. Nothing deletes, force-resets, or
+ *    `branch -D`s — the worktree is DURABLE by default and never auto-removed.
+ *  - **Get-or-resume.** An existing worktree dir is resumed, never recreated.
+ *  - **Lazy fetch.** Base `origin/<default>` is read from the local ref when
+ *    present; `git fetch` only runs when that ref is absent, and always with
+ *    credential prompts disabled.
+ *  - **Validate before any side effect.** The slug is checked (again, defense
+ *    in depth against the launcher) before the first git subprocess.
+ *  - **Canonical root.** `-w` invoked from inside an existing worktree lands in
+ *    the main repo, never nested.
+ *
+ * Convention reused from `/wt-new`: branch `agent/<slug>`, dir `.worktrees/<slug>`
+ * (both gitignored in-repo). PR refs (`#N`, GitHub PR URLs) map to `pr-<N>` and
+ * base on `FETCH_HEAD`.
+ */
+export interface SessionWorktreeResult {
+    /** Absolute destination (under `<mainRepo>/.worktrees/<slug>`). */
+    worktreePath: string;
+    /** The `agent/<slug>` branch. */
+    branch: string;
+    /** True when the worktree already existed (resumed, not created). */
+    existed: boolean;
+}
+export type SessionGit = (argv: string[], cwd: string, env?: NodeJS.ProcessEnv) => Promise<string>;
+export interface CreateOrResumeDeps {
+    /** Repo the user ran `yagni -w` from (any path inside it works for git). */
+    repoCwd: string;
+    /** Injectable git seam (defaults to a real `git` exec). */
+    gitImpl?: SessionGit;
+    /** Injectable fs seam for existence checks (defaults to node:fs). */
+    pathExists?: (p: string) => boolean;
+    /** Injectable randomness (defaults to Math.random). */
+    random?: () => number;
+}
+/** Turn arbitrary name text into a git-ref-safe slug. Empty input → "worktree". */
+export declare function slugify(name: string): string;
+/**
+ * Validate a worktree slug before any side effect. Mirrors Claude's guard:
+ * length cap, per-segment allowlist, `.`/`..` rejection. Throws synchronously.
+ */
+export declare function validateWorktreeSlug(slug: string): void;
+/**
+ * Parse a PR reference: `#N` or a GitHub-style PR URL. Returns the number or null.
+ */
+export declare function parsePRReference(input: string): number | null;
+/**
+ * Create or resume the session worktree for `name`.
+ *
+ * Throws with a user-surfaced message on any failure; the caller (launcher)
+ * catches and prints it to stderr + the diagnostic sink. Never leaves a partial
+ * branch/worktree: validation happens first, and `git worktree add` is atomic.
+ */
+export declare function createOrResume(name: string | undefined, deps: CreateOrResumeDeps): Promise<SessionWorktreeResult>;
+//# sourceMappingURL=sessionWorktree.d.ts.map