@yagni-app/code-staging 1.0.0-staging.1177.1 → 1.0.0-staging.1179.1

package/dist/cli.js

@@ -16,7 +16,7 @@ import { spawn } from "node:child_process";
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { PI_CONFIG_NAME } from "./branding.js";
 import { claudeCompatArgs } from "./claudeCompat.js";
 import { agentDir, credentialsDir, piPackageDir } from "./credentials.js";
@@ -28,14 +28,16 @@ import { logout } from "./logout.js";
 import { tokenCommand } from "./token.js";
 import { buildLaunch } from "./launch.js";
 import { parseOutputFormat, parseJsonEvents, buildResultObject, readGuardianEvents, } from "./outputFormat.js";
+import { feedbackCommand } from "./feedback.js";
 import { runDoctor } from "./doctor.js";
 import { installProcessCrashHandlers } from "./crashReport.js";
 import { currentCliVersion, maybeNudgeAndRefresh, upgradeCommand } from "./upgrade.js";
 import { maybeRefreshAtLaunch } from "./refresh.js";
 import { exitCodeFor, installSignalForwarding } from "./signalForward.js";
 import { PAD_X } from "./padding.js";
+import { parseWorktreeFlag, validateWorktreeLaunchArgs } from "./worktreeArgs.js";
 import { ensureShadowPiPackage } from "./piPackage.js";
-import { resolveExtensionPath, resolvePiCliPath, resolvePiPackageDir } from "./paths.js";
+import { resolveExtensionPath, resolvePiCliPath, resolvePiPackageDir, resolveSessionWorktreePath } from "./paths.js";
 import { credentialsFromProfile, getActiveProfileName, listProfiles, migrateLegacyCredentials, persistProfileTokenRotation, profilePath, readActiveProfile, useProfile, } from "./profiles.js";
 // Present as "yagni" in process listings, not "node".
 process.title = DISTRIBUTION.commandName;
@@ -160,6 +162,14 @@ export function seedHideThinkingBlock(piAgentDir) {
     return seedSetting(piAgentDir, "hideThinkingBlock", true);
 }
 async function runDefault(passthroughArgs) {
+    // `-w / --worktree [name]` is its own launch path: create/resume a worktree
+    // and enter a session there. Gate strictly on `requested` (not `name`) so a
+    // bare `-w` (random slug) is honored too. Returning early keeps the standard
+    // path below physically unreachable by any `-w` bug.
+    const worktree = parseWorktreeFlag(passthroughArgs);
+    if (worktree.requested) {
+        return runWorktreeLaunch(worktree.remainingArgs, worktree.name);
+    }
     // Parse --output-format out of argv before passing to pi (pi doesn't know
     // about it). The format determines how we handle pi's stdout: text = inherit,
     // stream-json = inherit with --mode json, json = pipe + post-process.
@@ -265,10 +275,22 @@ async function runDefault(passthroughArgs) {
         process.stderr.write(`${warning}\n`);
     }
     const { env, argv } = plan;
+    return spawnPiAndAwait({
+        argv,
+        env,
+        remainingArgs,
+        outputFormat,
+    });
+}
+/**
+ * Spawn pi and await its exit, mapping to the launcher's exit code. Extracted
+ * so `runDefault` (cwd = current) and `runWorktreeLaunch` (cwd = worktree) share
+ * the exact same json/stream-json post-processing, signal forwarding, and exit
+ * code mapping — the two paths can never drift on the output contract.
+ */
+async function spawnPiAndAwait(opts) {
+    const { argv, env, remainingArgs, outputFormat, cwd } = opts;
     // For json/stream-json output, inject --mode json so pi emits NDJSON events.
-    // Don't override if the user already chose --mode (mirrors userChoseProvider/
-    // userChoseModel in buildLaunch). Appended at the end — pi's flag parser
-    // handles --mode anywhere in argv.
     const userChoseMode = remainingArgs.some((a) => a === "--mode" || a.startsWith("--mode="));
     const childArgv = outputFormat === "text" || userChoseMode
         ? argv
@@ -284,6 +306,7 @@ async function runDefault(passthroughArgs) {
         const child = spawn(process.execPath, [piCli, ...childArgv], {
             stdio: stdio,
             env,
+            ...(cwd ? { cwd } : {}),
         });
         // Collect pi's stdout when piping for --output-format json.
         let stdoutChunks = "";
@@ -322,6 +345,131 @@ async function runDefault(passthroughArgs) {
         });
     });
 }
+async function defaultLoadSessionWorktree() {
+    const mod = (await import(pathToFileURL(resolveSessionWorktreePath()).href));
+    if (typeof mod?.createOrResume !== "function") {
+        throw new Error("The bundled extension is missing its session-worktree entry point (is the CLI up to date?).");
+    }
+    return mod;
+}
+/**
+ * `yagni -w [name]` — create/resume a worktree and enter a session there.
+ *
+ * Delegates all git behavior to the extension's `sessionWorktree` entry; this
+ * launcher path only resolves credentials, builds the plan, and spawns pi with
+ * `cwd` = the worktree. The worktree is DURABLE — nothing is ever removed.
+ */
+async function runWorktreeLaunch(passthroughArgs, worktreeName, loadSessionWorktree = defaultLoadSessionWorktree) {
+    // Validate the name + argv before any side effect (slug guard + `-c`
+    // disallow). The extension re-validates the mapped slug for PR refs.
+    const launchError = validateWorktreeLaunchArgs(worktreeName, passthroughArgs);
+    if (launchError !== undefined) {
+        process.stderr.write(`${launchError}\n`);
+        return 1;
+    }
+    const { format: outputFormat, remainingArgs } = parseOutputFormat(passthroughArgs);
+    // Load the session-worktree entry first, so a stale bundled extension fails
+    // honestly before we mutate anything.
+    let sessionWorktree;
+    try {
+        sessionWorktree = await loadSessionWorktree();
+    }
+    catch (err) {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    // Create/resume resolves the main repo root + branch + dir, and performs
+    // `git worktree add` / resume. Never throws on a normal path; catch-all maps
+    // to a clean stderr + exit 1.
+    let result;
+    try {
+        result = await sessionWorktree.createOrResume(worktreeName, {
+            repoCwd: process.cwd(),
+        });
+    }
+    catch (err) {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    // Reuse the standard credential + env + plan flow (same token refresh, shadow
+    // package, compat args, preflight). The worktree becomes the project cwd, so
+    // compat assets resolve from there.
+    await maybeNudgeAndRefresh({ current: cliVersion() });
+    const profile = await readActiveProfile();
+    let creds = credentialsFromProfile(profile);
+    if (!creds?.token) {
+        process.stderr.write(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`yagni login\` first.\n`);
+        return 1;
+    }
+    const refresh = await maybeRefreshAtLaunch(creds, {
+        persist: (c) => persistProfileTokenRotation(profile.name, c),
+    });
+    for (const warning of refresh.warnings) {
+        process.stderr.write(`${warning}\n`);
+    }
+    creds = refresh.creds;
+    const piAgentDir = agentDir(profile.name);
+    mkdirSync(piAgentDir, { recursive: true, mode: 0o700 });
+    seedEditorPadding(piAgentDir);
+    seedCollapseChangelog(piAgentDir);
+    seedHideThinkingBlock(piAgentDir);
+    let shadowPiDir;
+    try {
+        shadowPiDir = ensureShadowPiPackage({
+            realPiDir: resolvePiPackageDir(),
+            shadowDir: piPackageDir(),
+            name: PI_CONFIG_NAME,
+        });
+    }
+    catch {
+        shadowPiDir = undefined;
+    }
+    let compat = { argv: [], env: {} };
+    try {
+        compat = await claudeCompatArgs({
+            cwd: result.worktreePath,
+            agentDir: piAgentDir,
+            confirm: confirmOnTty,
+        });
+    }
+    catch {
+        compat = { argv: [], env: {} };
+    }
+    let plan;
+    try {
+        plan = buildLaunch(creds, remainingArgs, {
+            extensionPath: resolveExtensionPath(),
+            agentDir: piAgentDir,
+            piPackageDir: shadowPiDir,
+            extraAgentArgs: compat.argv,
+            extraEnv: compat.env,
+            profilePath: profilePath(profile.name),
+            stateDir: credentialsDir(),
+            cliVersion: cliVersion(),
+            baseEnv: process.env,
+        });
+    }
+    catch (err) {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    for (const warning of plan.warnings) {
+        process.stderr.write(`${warning}\n`);
+    }
+    const exitCode = await spawnPiAndAwait({
+        argv: plan.argv,
+        env: plan.env,
+        remainingArgs,
+        outputFormat,
+        cwd: result.worktreePath,
+    });
+    // Durable by default: nothing is removed. Tell the user where their work
+    // lives (stderr only — never stdout, to keep json clean).
+    process.stderr.write(`[yagni] worktree ${result.existed ? "resumed" : "created"}: ${result.worktreePath}\n` +
+        `[yagni] branch: ${result.branch}\n` +
+        `[yagni] resume: cd ${result.worktreePath} && yagni\n`);
+    return exitCode;
+}
 export const HELP_TEXT = [
     "YAGNI Code — a business-context-grounded terminal coding agent.",
     "",
@@ -329,12 +477,16 @@ export const HELP_TEXT = [
     "  yagni [args…]            Launch the agent in the current repo.",
     "  yagni -c                 Continue the most recent session.",
     "  yagni -r                 Browse and resume a previous session.",
+    "  yagni -w [name]          Create/resume a worktree and enter a session there.",
     '  yagni -p "prompt"        Print one response and exit (reads piped stdin too).',
     '  yagni -p "prompt"        Use --output-format json for a machine-readable',
     '    --output-format json   result object with tools, cost, guardian reviews.',
     "  yagni login              Authorize the active environment (device-code flow).",
     "  yagni logout             Revoke and clear the active environment's token.",
     "  yagni doctor             Check that everything is ready (green/red checklist).",
+    "  yagni feedback [sessionId]  File a bug report from the shell. Lists recent",
+    "                           sessions to pick, or pass a session ID directly.",
+    "                           Attaches transcript + error trail, then submits.",
     "  yagni go --headless      Run the /go pipeline without a session, for scripts",
     "                           and CI: --ticket-file <path> [--plan-file <path>]",
     "                           [--memo-file <path>] [--run-id <id>] [--json].",
@@ -486,6 +638,9 @@ export async function main(argv) {
     if (command === "go") {
         return goCommand(rest, {}, cliVersion());
     }
+    if (command === "feedback") {
+        return feedbackCommand(rest, {}, cliVersion());
+    }
     if (command === "token") {
         return tokenCommand();
     }

package/dist/crashReport.d.ts

@@ -41,6 +41,7 @@ export declare function crashReportsDisabled(env?: NodeJS.ProcessEnv): boolean;
 export declare function runningUnderTest(env?: NodeJS.ProcessEnv): boolean;
 /** Reporting is off when the user disabled it OR this is a test process. */
 export declare function crashReportsSuppressed(env?: NodeJS.ProcessEnv): boolean;
+export declare const SECRET_PATTERNS: Array<[RegExp, string]>;
 export interface SanitizeCrashOptions {
     /** Environment whose values get redacted (defaults to process.env). */
     env?: NodeJS.ProcessEnv;
@@ -57,6 +58,13 @@ export interface SanitizeCrashOptions {
  *      `node_modules/` on, so dependency frames stay diagnosable)
  * Over-redacts rather than under-redacts; pure; never throws.
  */
+/**
+ * Lightweight secret-only scrub — applies SECRET_PATTERNS and nothing else.
+ * Matches the extension's `scrubSecrets` exactly (no path collapse, no env
+ * redaction). Use this for feedback transcripts where file paths and code
+ * context must stay readable; the backend re-normalizes home paths on receipt.
+ */
+export declare function scrubSecrets(text: string): string;
 export declare function sanitizeCrashText(text: string, opts?: SanitizeCrashOptions): string;
 export interface SanitizedCrash {
     errorClass: string;

package/dist/crashReport.js

@@ -62,7 +62,7 @@ export function crashReportsSuppressed(env = process.env) {
 }
 // Mirrors scrubSecrets (backend yagniCode/scrubSecrets.ts and
 // pi-extension-yagni pipeline/scrubSecrets.ts) — keep in sync.
-const SECRET_PATTERNS = [
+export const SECRET_PATTERNS = [
     [/\b([a-z][a-z0-9+.\-]*:\/\/[^\s:@/]+):[^\s:@/]+@/gi, "$1:[REDACTED]@"],
     [/\b(sk-[A-Za-z0-9]{16,}|sk_(?:live|test)_[A-Za-z0-9]{16,}|rk_(?:live|test)_[A-Za-z0-9]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_\-]{20,})\b/g, "[REDACTED]"],
     [/\b([A-Za-z0-9_]*(?:secret|password|passwd|api[_-]?key|token|private[_-]?key|access[_-]?key)[A-Za-z0-9_]*)\b(\s*[:=]\s*)("[^"]+"|'[^']+'|`[^`]+`|[^\s"']+)/gi, "$1$2[REDACTED]"],
@@ -106,6 +106,18 @@ function collapsePathToken(token) {
  *      `node_modules/` on, so dependency frames stay diagnosable)
  * Over-redacts rather than under-redacts; pure; never throws.
  */
+/**
+ * Lightweight secret-only scrub — applies SECRET_PATTERNS and nothing else.
+ * Matches the extension's `scrubSecrets` exactly (no path collapse, no env
+ * redaction). Use this for feedback transcripts where file paths and code
+ * context must stay readable; the backend re-normalizes home paths on receipt.
+ */
+export function scrubSecrets(text) {
+    let out = text;
+    for (const [re, repl] of SECRET_PATTERNS)
+        out = out.replace(re, repl);
+    return out;
+}
 export function sanitizeCrashText(text, opts = {}) {
     let out = text;
     const env = opts.env ?? process.env;

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

package/dist/extension/pipeline/sessionWorktree.js

@@ -0,0 +1,225 @@
+/**
+ * `-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`.
+ */
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { basename, dirname, isAbsolute, join } from "node:path";
+import { bootstrapWorktree } from "./worktree.js";
+/** Cap on the slug half (keeps refs & dirs readable). */
+const SLUG_MAX = 40;
+/** Maximum slug characters, mirrored from Claude's guard. */
+const MAX_SLUG_LENGTH = 64;
+/** Allowlist per `/`-separated segment (mirrors Claude's `validateWorktreeSlug`). */
+const VALID_SLUG_SEGMENT = /^[a-zA-Z0-9._-]+$/;
+/** Env that prevents git/ssh from prompting for credentials (which would hang). */
+const GIT_NO_PROMPT_ENV = {
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_ASKPASS: "",
+};
+/** Turn arbitrary name text into a git-ref-safe slug. Empty input → "worktree". */
+export function slugify(name) {
+    const slug = name
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, SLUG_MAX)
+        .replace(/-+$/, "");
+    return slug || "worktree";
+}
+/**
+ * Validate a worktree slug before any side effect. Mirrors Claude's guard:
+ * length cap, per-segment allowlist, `.`/`..` rejection. Throws synchronously.
+ */
+export function validateWorktreeSlug(slug) {
+    if (slug.length > MAX_SLUG_LENGTH) {
+        throw new Error(`Invalid worktree name: must be ${MAX_SLUG_LENGTH} characters or fewer (got ${slug.length})`);
+    }
+    for (const segment of slug.split("/")) {
+        if (segment === "." || segment === "..") {
+            throw new Error(`Invalid worktree name "${slug}": must not contain "." or ".." path segments`);
+        }
+        if (!VALID_SLUG_SEGMENT.test(segment)) {
+            throw new Error(`Invalid worktree name "${slug}": each "/"-separated segment must be non-empty and contain only letters, digits, dots, underscores, and dashes`);
+        }
+    }
+}
+/**
+ * Parse a PR reference: `#N` or a GitHub-style PR URL. Returns the number or null.
+ */
+export function parsePRReference(input) {
+    const urlMatch = input.match(/^https?:\/\/[^/]+\/[^/]+\/[^/]+\/pull\/(\d+)\/?(?:[?#].*)?$/i);
+    if (urlMatch?.[1])
+        return parseInt(urlMatch[1], 10);
+    const hashMatch = input.match(/^#(\d+)$/);
+    if (hashMatch?.[1])
+        return parseInt(hashMatch[1], 10);
+    return null;
+}
+function randomSlug(random = Math.random) {
+    const adjectives = ["swift", "bright", "calm", "keen", "bold", "quiet", "warm", "true"];
+    const nouns = ["fox", "owl", "elm", "oak", "ray", "fern", "pine", "brook"];
+    const adj = adjectives[Math.floor(random() * adjectives.length)];
+    const noun = nouns[Math.floor(random() * nouns.length)];
+    const suffix = Math.floor(random() * 0x10000).toString(36).padStart(4, "0");
+    return `${adj}-${noun}-${suffix}`;
+}
+function defaultGit(argv, cwd, env) {
+    return new Promise((resolve, reject) => {
+        execFile("git", argv, { cwd, env, maxBuffer: 32 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err) {
+                reject(new Error(stderr.toString().trim() || err.message));
+                return;
+            }
+            resolve(stdout.toString().trim());
+        });
+    });
+}
+/** The main repo root, resolved through an existing linked worktree via commondir. */
+async function resolveMainRepo(gitImpl, repoCwd) {
+    let topLevel;
+    try {
+        topLevel = await gitImpl(["rev-parse", "--show-toplevel"], repoCwd);
+    }
+    catch (err) {
+        throw new Error(`Cannot create a worktree: not inside a git repository. ` +
+            `${err instanceof Error ? err.message : String(err)}`);
+    }
+    const common = await gitImpl(["rev-parse", "--git-common-dir"], repoCwd);
+    const abs = isAbsolute(common) ? common : join(topLevel, common);
+    // A linked worktree's commondir points at the shared `.git`; the main repo root
+    // is its parent. A main checkout resolves to its own toplevel.
+    return basename(abs) === ".git" ? dirname(abs) : topLevel;
+}
+/** Resolve the default branch: origin/HEAD symref, else main, else master. */
+async function resolveDefaultBranch(gitImpl, repoCwd) {
+    try {
+        const symref = await gitImpl(["symbolic-ref", "refs/remotes/origin/HEAD"], repoCwd);
+        const name = symref.replace(/^refs\/remotes\//, "");
+        if (name)
+            return name;
+    }
+    catch {
+        /* no origin/HEAD symref */
+    }
+    for (const candidate of ["main", "master"]) {
+        try {
+            await gitImpl(["show-ref", "--verify", "--quiet", `refs/remotes/origin/${candidate}`], repoCwd);
+            return candidate;
+        }
+        catch {
+            /* keep looking */
+        }
+    }
+    return "main";
+}
+/** True when a local branch `refs/heads/<branch>` exists. */
+async function branchExists(gitImpl, repoCwd, branch) {
+    try {
+        await gitImpl(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], repoCwd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 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 async function createOrResume(name, deps) {
+    const gitImpl = deps.gitImpl ?? defaultGit;
+    const pathExists = deps.pathExists ?? ((p) => existsSync(p));
+    const random = deps.random ?? Math.random;
+    const repoCwd = deps.repoCwd;
+    const prNumber = name !== undefined ? parsePRReference(name) : null;
+    const slug = prNumber !== null
+        ? `pr-${prNumber}`
+        : slugify(name ?? randomSlug(random));
+    validateWorktreeSlug(slug);
+    const repoRoot = await resolveMainRepo(gitImpl, repoCwd);
+    const branch = `agent/${slug}`;
+    const worktreePath = join(repoRoot, ".worktrees", slug);
+    // Get-or-resume: an existing dir is resumed, never recreated/fetched/overwritten.
+    if (pathExists(worktreePath)) {
+        return { worktreePath, branch, existed: true };
+    }
+    // Collision: the branch already exists locally (dirty leftover from a prior
+    // crash) — refuse rather than force-reset.
+    if (await branchExists(gitImpl, repoCwd, branch)) {
+        throw new Error(`Branch ${branch} already exists. Pick a different name with \`-w <other>\`, or clean it up first.`);
+    }
+    mkdirSync(dirname(worktreePath), { recursive: true, mode: 0o700 });
+    // Resolve base. PR path fetches the PR head into FETCH_HEAD; default path uses
+    // the local origin/<default> ref when present, else fetches, else falls back
+    // to HEAD (a repo with no remote or no commits still works).
+    let base;
+    const fetchEnv = { ...process.env, ...GIT_NO_PROMPT_ENV };
+    if (prNumber !== null) {
+        try {
+            await gitImpl(["fetch", "origin", `pull/${prNumber}/head`], repoCwd, fetchEnv);
+        }
+        catch (err) {
+            throw new Error(`Failed to fetch PR #${prNumber}: ${err instanceof Error ? err.message : String(err)}. ` +
+                `The PR may not exist or this repo may not have a remote named "origin".`);
+        }
+        base = "FETCH_HEAD";
+    }
+    else {
+        const defaultBranch = await resolveDefaultBranch(gitImpl, repoCwd);
+        let originRef = null;
+        try {
+            await gitImpl(["show-ref", "--verify", "--quiet", `refs/remotes/origin/${defaultBranch}`], repoCwd);
+            originRef = `origin/${defaultBranch}`;
+        }
+        catch {
+            try {
+                await gitImpl(["fetch", "origin", defaultBranch], repoCwd, fetchEnv);
+                originRef = `origin/${defaultBranch}`;
+            }
+            catch {
+                originRef = "HEAD"; // no remote / no commits: degrade to local HEAD
+            }
+        }
+        base = originRef;
+    }
+    try {
+        await gitImpl(["worktree", "add", "-b", branch, worktreePath, base], repoCwd);
+    }
+    catch (err) {
+        throw new Error(`Failed to create worktree: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Best-effort: install deps + env so a fresh worktree can actually run.
+    try {
+        await bootstrapWorktree(worktreePath);
+    }
+    catch {
+        /* bootstrap is best-effort; a failed install must not fail the launch */
+    }
+    return { worktreePath, branch, existed: false };
+}
+//# sourceMappingURL=sessionWorktree.js.map

package/dist/feedback.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `yagni feedback [sessionId]` — file a bug report from the shell (YAG-592).
+ *
+ * A shortcut to trigger what `/feedback` does inside a session, but from
+ * outside the TUI. Two modes:
+ *
+ *   Case A (no session arg): list the 10 most recent sessions for the current
+ *     cwd, let the user pick, prompt for a description, confirm, submit.
+ *   Case B (session ID provided): skip the list, go straight to description
+ *     prompt → confirm → submit.
+ *
+ * Self-contained: no cross-package imports. The scrub (`scrubSecrets`) and the
+ * error-trail reader (`readSessionTrail`) are local copies of the extension's
+ * logic — keep in sync with `pi-extension-yagni/src/pipeline/scrubSecrets.ts`
+ * and `pi-extension-yagni/src/errorSink.ts`. The backend re-scrubs server-side
+ * (`backend/src/yagniCode/feedback.ts`), so the client-side scrub is the first
+ * line of defense, not the only one.
+ */
+export interface FeedbackDeps {
+    loadCredentials?: () => Promise<{
+        token?: string;
+        baseUrl: string;
+        name: string;
+    }>;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    /** Override the agent dir (sessions live under `<agentDir>/sessions/...`). */
+    agentDirPath?: string;
+    /** Override the state dir (error sink lives under `<stateDir>/logs/...`). */
+    stateDir?: string;
+    writeOut?: (line: string) => void;
+    writeErr?: (line: string) => void;
+    /** Seam for readline — tests inject a fake that returns scripted answers. */
+    readline?: {
+        question: (q: string) => Promise<string>;
+        close: () => void;
+    };
+}
+export interface SessionInfo {
+    id: string;
+    filePath: string;
+    startTime: string;
+    durationMs: number | null;
+    firstMessage: string;
+}
+/**
+ * Encode a cwd into pi's session directory name format:
+ * `/Users/foo/bar` → `--Users-foo-bar--`
+ * Mirrors pi's `migrations.js`: `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`
+ */
+export declare function encodeCwd(cwd: string): string;
+/**
+ * List the most recent sessions for the current cwd.
+ * Scans `<agentDir>/sessions/<encoded-cwd>/*.jsonl`, sorted by start time desc.
+ */
+export declare function listRecentSessions(agentDirPath: string, cwd: string, limit?: number, termCols?: number): SessionInfo[];
+/**
+ * Find a session file by UUID across all project dirs.
+ */
+export declare function findSessionById(agentDirPath: string, sessionId: string): {
+    filePath: string;
+    startTime: string;
+} | null;
+/**
+ * Read the durable transcript, clamped by byte size. Returns empty on any
+ * failure or when too large. Mirrors the extension's `readTranscript`.
+ */
+export declare function readTranscript(sessionFile: string | undefined): string;
+/**
+ * Read the session-scoped error trail from today's error sink file.
+ * Filters by sessionId and excludes debug-level entries. Scrubs each line.
+ * Mirrors the extension's `readSessionTrail` — keep in sync.
+ */
+export declare function readSessionTrail(sessionId: string, stateDir: string, maxBytes?: number): string;
+export declare function feedbackCommand(args: string[], deps?: FeedbackDeps, cliVersion?: string): Promise<number>;
+//# sourceMappingURL=feedback.d.ts.map

package/dist/feedback.js

@@ -0,0 +1,500 @@
+/**
+ * `yagni feedback [sessionId]` — file a bug report from the shell (YAG-592).
+ *
+ * A shortcut to trigger what `/feedback` does inside a session, but from
+ * outside the TUI. Two modes:
+ *
+ *   Case A (no session arg): list the 10 most recent sessions for the current
+ *     cwd, let the user pick, prompt for a description, confirm, submit.
+ *   Case B (session ID provided): skip the list, go straight to description
+ *     prompt → confirm → submit.
+ *
+ * Self-contained: no cross-package imports. The scrub (`scrubSecrets`) and the
+ * error-trail reader (`readSessionTrail`) are local copies of the extension's
+ * logic — keep in sync with `pi-extension-yagni/src/pipeline/scrubSecrets.ts`
+ * and `pi-extension-yagni/src/errorSink.ts`. The backend re-scrubs server-side
+ * (`backend/src/yagniCode/feedback.ts`), so the client-side scrub is the first
+ * line of defense, not the only one.
+ */
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { isatty } from "node:tty";
+import { agentDir, credentialsDir } from "./credentials.js";
+import { scrubSecrets } from "./crashReport.js";
+import { credentialsFromProfile, readActiveProfile } from "./profiles.js";
+const MAX_DESCRIPTION = 512;
+const MAX_TRANSCRIPT_READ_BYTES = 512 * 1024;
+const MAX_TRAIL_BYTES = 64 * 1024;
+const FIRST_MESSAGE_PREVIEW_FALLBACK = 60;
+/** Max chars for the first-message preview, capped by terminal width. */
+function previewMaxWidth(termCols) {
+    const cols = termCols ?? process.stdout.columns;
+    if (!cols || cols < 40)
+        return FIRST_MESSAGE_PREVIEW_FALLBACK;
+    // Account for: "  " + " N. " (5) + time (18) + dur (6) = ~29 chars of prefix
+    const available = cols - 32;
+    return Math.max(available, 20);
+}
+const LIST_LIMIT = 10;
+// --- session discovery ---
+/**
+ * Encode a cwd into pi's session directory name format:
+ * `/Users/foo/bar` → `--Users-foo-bar--`
+ * Mirrors pi's `migrations.js`: `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`
+ */
+export function encodeCwd(cwd) {
+    return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+/**
+ * Parse the first few lines of a session JSONL to extract metadata.
+ * Returns null on any failure (corrupt/empty file).
+ */
+function parseSessionHeader(filePath) {
+    try {
+        const data = readFileSync(filePath, "utf8");
+        const lines = data.split("\n").filter((l) => l.length > 0);
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === "session" && typeof obj.id === "string" && typeof obj.timestamp === "string") {
+                    return { id: obj.id, timestamp: obj.timestamp };
+                }
+            }
+            catch {
+                // skip unparseable lines
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract the first user message text from a session JSONL (skips
+ * `custom_message` entries — only real `type: "message"` with `role: "user"`).
+ */
+function extractFirstUserMessage(filePath, maxChars) {
+    try {
+        const data = readFileSync(filePath, "utf8");
+        const lines = data.split("\n").filter((l) => l.length > 0);
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === "message" &&
+                    obj.message?.role === "user" &&
+                    Array.isArray(obj.message?.content)) {
+                    const textPart = obj.message.content.find((c) => c.type === "text");
+                    if (textPart?.text) {
+                        // Strip skill invocation XML tags (e.g. `<skill name="…" …>`)
+                        // — they're machinery, not the user's message.
+                        let text = textPart.text.trim()
+                            .replace(/<skill\s[^>]*>\s*/g, "")
+                            .replace(/<\/skill>/g, "")
+                            .replace(/\n+/g, " ")
+                            .trim();
+                        const cap = maxChars ?? FIRST_MESSAGE_PREVIEW_FALLBACK;
+                        if (text.length > 0) {
+                            return text.length > cap
+                                ? `${text.slice(0, cap)}…`
+                                : text;
+                        }
+                    }
+                }
+            }
+            catch {
+                // skip unparseable lines
+            }
+        }
+        return "";
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Get the timestamp of the last non-empty line in a session JSONL.
+ * Used to compute session duration.
+ */
+function extractLastTimestamp(filePath) {
+    try {
+        const data = readFileSync(filePath, "utf8");
+        const lines = data.split("\n").filter((l) => l.length > 0);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const obj = JSON.parse(lines[i]);
+                if (typeof obj.timestamp === "string")
+                    return obj.timestamp;
+            }
+            catch {
+                // skip
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List the most recent sessions for the current cwd.
+ * Scans `<agentDir>/sessions/<encoded-cwd>/*.jsonl`, sorted by start time desc.
+ */
+export function listRecentSessions(agentDirPath, cwd, limit = LIST_LIMIT, termCols) {
+    const sessionsDir = join(agentDirPath, "sessions", encodeCwd(cwd));
+    let files;
+    try {
+        files = readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+    }
+    catch {
+        return [];
+    }
+    const sessions = [];
+    for (const file of files) {
+        const filePath = join(sessionsDir, file);
+        const header = parseSessionHeader(filePath);
+        if (!header)
+            continue;
+        const firstMessage = extractFirstUserMessage(filePath, previewMaxWidth(termCols));
+        const lastTs = extractLastTimestamp(filePath);
+        let durationMs = null;
+        if (lastTs) {
+            const start = Date.parse(header.timestamp);
+            const end = Date.parse(lastTs);
+            if (!isNaN(start) && !isNaN(end))
+                durationMs = end - start;
+        }
+        sessions.push({
+            id: header.id,
+            filePath,
+            startTime: header.timestamp,
+            durationMs,
+            firstMessage,
+        });
+    }
+    sessions.sort((a, b) => b.startTime.localeCompare(a.startTime));
+    return sessions.slice(0, limit);
+}
+/**
+ * Find a session file by UUID across all project dirs.
+ */
+export function findSessionById(agentDirPath, sessionId) {
+    const sessionsRoot = join(agentDirPath, "sessions");
+    let projectDirs;
+    try {
+        projectDirs = readdirSync(sessionsRoot, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => join(sessionsRoot, d.name));
+    }
+    catch {
+        return null;
+    }
+    for (const dir of projectDirs) {
+        let files;
+        try {
+            files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            if (file.includes(sessionId)) {
+                const filePath = join(dir, file);
+                const header = parseSessionHeader(filePath);
+                if (header)
+                    return { filePath, startTime: header.timestamp };
+            }
+        }
+    }
+    return null;
+}
+// --- transcript + error trail ---
+/**
+ * Read the durable transcript, clamped by byte size. Returns empty on any
+ * failure or when too large. Mirrors the extension's `readTranscript`.
+ */
+export function readTranscript(sessionFile) {
+    if (!sessionFile)
+        return "";
+    try {
+        const data = readFileSync(sessionFile, "utf8");
+        if (Buffer.byteLength(data, "utf8") > MAX_TRANSCRIPT_READ_BYTES)
+            return "";
+        return data;
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Read the session-scoped error trail from today's error sink file.
+ * Filters by sessionId and excludes debug-level entries. Scrubs each line.
+ * Mirrors the extension's `readSessionTrail` — keep in sync.
+ */
+export function readSessionTrail(sessionId, stateDir, maxBytes = MAX_TRAIL_BYTES) {
+    try {
+        const dayStamp = new Date().toISOString().slice(0, 10);
+        const sinkPath = join(stateDir, "logs", `errors-${dayStamp}.jsonl`);
+        const data = readFileSync(sinkPath, "utf8");
+        const lines = data
+            .split("\n")
+            .filter((l) => l.length > 0)
+            .filter((l) => {
+            try {
+                const obj = JSON.parse(l);
+                return obj.sessionId === sessionId && obj.level !== "debug";
+            }
+            catch {
+                return false;
+            }
+        })
+            .map((l) => scrubSecrets(l))
+            .join("\n");
+        return lines.length > maxBytes ? lines.slice(lines.length - maxBytes) : lines;
+    }
+    catch {
+        return "";
+    }
+}
+function buildFeedbackPayload(opts) {
+    const transcript = readTranscript(opts.sessionFile);
+    const trail = readSessionTrail(opts.sessionId, opts.stateDir);
+    return {
+        client: "cli",
+        clientVersion: opts.env.YAGNI_CODE_VERSION?.trim() || opts.clientVersion || "unknown",
+        platform: `${process.platform} ${process.arch}`,
+        description: scrubSecrets(opts.description).slice(0, MAX_DESCRIPTION),
+        sessionId: opts.sessionId,
+        ...(transcript ? { transcriptJsonl: scrubSecrets(transcript) } : {}),
+        ...(trail ? { errorTrailJsonl: trail } : {}),
+    };
+}
+async function submitFeedback(payload, baseUrl, token, fetchImpl) {
+    try {
+        const res = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/api/yagni-code/feedback`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            return { ok: true, id: body.id };
+        }
+        return { ok: false, error: `Server returned ${res.status}` };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Create a readline-like interface that survives piped stdin (where the
+ * real readline's `question` hangs after EOF). For TTY stdin it delegates to
+ * the real `readline/promises`; for piped stdin it reads all lines upfront
+ * and serves them one-by-one.
+ */
+function makeReadline() {
+    if (isatty(0)) {
+        const rl = createInterface({ input, output });
+        return {
+            question: (q) => rl.question(q),
+            close: () => rl.close(),
+        };
+    }
+    // Piped stdin: read all available data and serve lines FIFO.
+    const lines = [];
+    try {
+        const data = readFileSync(0, "utf8"); // fd 0 = stdin
+        for (const line of data.split("\n")) {
+            if (line.length > 0)
+                lines.push(line);
+        }
+    }
+    catch {
+        // stdin not readable as a file — fall back to empty
+    }
+    let idx = 0;
+    return {
+        question: async (q) => {
+            process.stdout.write(q);
+            const answer = lines[idx++] ?? "";
+            // Echo a newline so subsequent prompts start on a new line (in TTY
+            // mode, readline echoes the user's Enter; piped mode does not).
+            process.stdout.write("\n");
+            return answer;
+        },
+        close: () => { },
+    };
+}
+// --- display ---
+function formatDuration(ms) {
+    if (ms === null)
+        return "";
+    if (ms < 1000)
+        return "<1s";
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    return `${m}m`;
+}
+function formatStartTime(iso) {
+    try {
+        const d = new Date(iso);
+        return d.toLocaleString("en-US", {
+            month: "short",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        });
+    }
+    catch {
+        return iso;
+    }
+}
+// Minimal ANSI escape sequences for the session list.
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const CYAN = "\x1b[36m";
+function renderSessionList(sessions) {
+    const sep = DIM + "  " + "─".repeat(70) + RESET;
+    const lines = [BOLD + "  Recent sessions" + RESET, sep];
+    const countWidth = String(sessions.length).length;
+    for (let i = 0; i < sessions.length; i++) {
+        const s = sessions[i];
+        const num = ` ${i + 1}.`.padEnd(countWidth + 2);
+        const idx = GREEN + num + RESET + " ";
+        const time = DIM + formatStartTime(s.startTime).padEnd(17) + RESET + " ";
+        const dur = DIM + formatDuration(s.durationMs).padEnd(5) + RESET + " ";
+        const msg = s.firstMessage || "(no text)";
+        lines.push(`  ${idx}${time}${dur}${msg}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+// --- orchestration ---
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export async function feedbackCommand(args, deps = {}, cliVersion) {
+    const writeOut = deps.writeOut ?? ((line) => void process.stdout.write(`${line}\n`));
+    const writeErr = deps.writeErr ?? ((line) => void process.stderr.write(`${line}\n`));
+    const cwd = deps.cwd ?? process.cwd();
+    const env = deps.env ?? process.env;
+    // Load credentials (same pattern as goCommand).
+    const profile = await (deps.loadCredentials ?? (async () => {
+        const active = await readActiveProfile(env);
+        const creds = credentialsFromProfile(active);
+        return {
+            name: active.name,
+            baseUrl: active.baseUrl,
+            ...(creds?.token ? { token: creds.token } : {}),
+        };
+    }))();
+    if (!profile.token) {
+        writeErr(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`yagni login\` first.`);
+        return 1;
+    }
+    const agentDirPath = deps.agentDirPath ?? agentDir(profile.name);
+    const stateDir = deps.stateDir ?? credentialsDir();
+    // Parse args: is the first positional a session UUID?
+    const sessionIdArg = args.find((a) => !a.startsWith("-") && UUID_RE.test(a));
+    let sessionFile;
+    let sessionId;
+    // One readline interface for all prompts. For piped stdin, makeReadline
+    // reads all lines upfront to avoid the readline/promises hang on EOF.
+    const rl = deps.readline ?? makeReadline();
+    const closeRl = () => {
+        if (deps.readline)
+            deps.readline.close();
+        else
+            rl.close();
+    };
+    try {
+        if (sessionIdArg) {
+            // Case B: session ID provided directly.
+            const found = findSessionById(agentDirPath, sessionIdArg);
+            if (!found) {
+                writeErr(`Session ${sessionIdArg} not found.`);
+                return 1;
+            }
+            sessionFile = found.filePath;
+            sessionId = sessionIdArg;
+        }
+        else {
+            // Case A: list sessions for the current cwd.
+            const sessions = listRecentSessions(agentDirPath, cwd);
+            if (sessions.length === 0) {
+                writeOut("No recent sessions found for this directory.");
+                return 1;
+            }
+            writeOut(renderSessionList(sessions));
+            const answer = (await rl.question(CYAN + "Select a session (1-" + sessions.length + "): " + RESET)).trim();
+            const idx = parseInt(answer, 10) - 1;
+            if (isNaN(idx) || idx < 0 || idx >= sessions.length) {
+                writeOut("Feedback cancelled.");
+                return 0;
+            }
+            sessionFile = sessions[idx].filePath;
+            sessionId = sessions[idx].id;
+        }
+        // Prompt for description.
+        const descAnswer = await rl.question(DIM + "Describe the issue (one or two lines):" + RESET + "\n> ");
+        const description = descAnswer.trim();
+        if (!description) {
+            writeOut("Feedback cancelled.");
+            return 0;
+        }
+        // Confirm.
+        const transcriptBytes = sessionFile
+            ? Buffer.byteLength(readTranscript(sessionFile), "utf8")
+            : 0;
+        const confirmLines = [
+            DIM + "Sending:" + RESET,
+            `  - Your feedback description`,
+            `  - This session's transcript${transcriptBytes > 0 ? "" : " (could not be read)"}`,
+            `  - Recent error trail for this session`,
+            "",
+            CYAN + "Send this report? [Y/n]" + RESET,
+        ];
+        const confirmed = (await rl.question(confirmLines.join("\n") + "\n")).trim();
+        if (/^n/i.test(confirmed)) {
+            writeOut("Feedback cancelled.");
+            return 0;
+        }
+        // Build payload + submit.
+        const payload = buildFeedbackPayload({
+            sessionId,
+            sessionFile,
+            description,
+            stateDir,
+            env,
+            clientVersion: cliVersion ?? "unknown",
+        });
+        const fetchImpl = deps.fetchImpl ?? fetch;
+        const result = await submitFeedback(payload, profile.baseUrl, profile.token, fetchImpl);
+        if (result.ok) {
+            writeOut(GREEN + "Feedback submitted. Thank you!" + RESET);
+            return 0;
+        }
+        else {
+            writeErr(`Could not submit feedback. ${result.error ?? "Please try again."}`);
+            return 1;
+        }
+    }
+    catch {
+        // readline closed or EOF — treat as cancel.
+        writeOut("Feedback cancelled.");
+        return 0;
+    }
+    finally {
+        closeRl();
+    }
+}
+//# sourceMappingURL=feedback.js.map

package/dist/paths.d.ts

@@ -29,6 +29,16 @@ export declare function resolveExtensionPath(): string;
  * it pulls in the pipeline alone, with none of pi's TUI surface.
  */
 export declare function resolveHeadlessGoPath(): string;
+/**
+ * Absolute path to the extension's session-worktree entry
+ * (`pipeline/sessionWorktree.js`), the module `yagni -w` imports.
+ *
+ * Mirrors `resolveHeadlessGoPath`: derived from the extension entry so the
+ * bundled-vs-workspace fallback is resolved once. Only this one module is
+ * loaded (not the whole extension): it pulls in the worktree plumbing alone,
+ * with none of pi's TUI surface.
+ */
+export declare function resolveSessionWorktreePath(): string;
 /**
  * Absolute path to pi's package root — the dir whose package.json names the
  * package. The shadow package dir is built from this (we read its package.json

package/dist/paths.js

@@ -43,6 +43,19 @@ export function resolveHeadlessGoPath() {
     const entry = resolveExtensionPath();
     return join(dirname(entry), "pipeline", "headlessGo.js");
 }
+/**
+ * Absolute path to the extension's session-worktree entry
+ * (`pipeline/sessionWorktree.js`), the module `yagni -w` imports.
+ *
+ * Mirrors `resolveHeadlessGoPath`: derived from the extension entry so the
+ * bundled-vs-workspace fallback is resolved once. Only this one module is
+ * loaded (not the whole extension): it pulls in the worktree plumbing alone,
+ * with none of pi's TUI surface.
+ */
+export function resolveSessionWorktreePath() {
+    const entry = resolveExtensionPath();
+    return join(dirname(entry), "pipeline", "sessionWorktree.js");
+}
 /**
  * Absolute path to pi's package root — the dir whose package.json names the
  * package. The shadow package dir is built from this (we read its package.json

package/dist/worktreeArgs.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Pure parsing + validation for `-w / --worktree [name]` (YAG-594).
+ *
+ * No side effects, no I/O: `parseWorktreeFlag` extracts the flag and its
+ * optional value from argv (leaving everything else for pi unchanged), and
+ * `validateWorktreeSlug` mirrors Claude's allowlist so a hostile name is
+ * rejected before the launcher touches git in any way.
+ */
+export interface WorktreeFlag {
+    /** Distinguishes "-w with no name" from "-w absent" so bare `-w` is honored. */
+    requested: boolean;
+    /** The name value, when supplied (`-w foo` / `--worktree=foo`). */
+    name?: string;
+    /** Everything that isn't the worktree flag/name, passed through to pi. */
+    remainingArgs: string[];
+}
+/**
+ * Extract `-w`/`--worktree [name]` from argv without disturbing the rest. Runs
+ * BEFORE `parseOutputFormat` so the two argv-mutators never double-handle a
+ * flag: this strips only the worktree flag, and the caller feeds `remainingArgs`
+ * to `parseOutputFormat` next.
+ */
+export declare function parseWorktreeFlag(argv: string[]): WorktreeFlag;
+/**
+ * Parse a PR reference: `#N` or a GitHub-style PR URL, mirroring the extension's
+ * `parsePRReference` (the two packages stay independent; this is the launcher's
+ * copy so `-w` can recognize a PR ref before slug-validating the raw name).
+ */
+export declare function parsePRReference(input: string): number | null;
+/**
+ * Validate a worktree slug before any side effect. Mirrors Claude's guard:
+ * length cap, per-segment allowlist, `.`/`..` rejection. Throws synchronously
+ * with a clear message (surfaced by the caller).
+ */
+export declare function validateWorktreeSlug(slug: string): void;
+/**
+ * Validate the `-w` name + argv before any side effect. Returns a user-facing
+ * error message when the launch should be refused, or `undefined` to proceed.
+ * PR refs (`#N` / URL) skip slug validation here — they map to `pr-<N>` in the
+ * extension, whose own validation covers the mapped slug.
+ */
+export declare function validateWorktreeLaunchArgs(name: string | undefined, argv: string[]): string | undefined;
+//# sourceMappingURL=worktreeArgs.d.ts.map

package/dist/worktreeArgs.js

@@ -0,0 +1,96 @@
+/**
+ * Pure parsing + validation for `-w / --worktree [name]` (YAG-594).
+ *
+ * No side effects, no I/O: `parseWorktreeFlag` extracts the flag and its
+ * optional value from argv (leaving everything else for pi unchanged), and
+ * `validateWorktreeSlug` mirrors Claude's allowlist so a hostile name is
+ * rejected before the launcher touches git in any way.
+ */
+/** Maximum slug characters (mirrors Claude's guard). */
+const MAX_SLUG_LENGTH = 64;
+/** Allowlist per `/`-separated segment. */
+const VALID_SLUG_SEGMENT = /^[a-zA-Z0-9._-]+$/;
+/**
+ * Extract `-w`/`--worktree [name]` from argv without disturbing the rest. Runs
+ * BEFORE `parseOutputFormat` so the two argv-mutators never double-handle a
+ * flag: this strips only the worktree flag, and the caller feeds `remainingArgs`
+ * to `parseOutputFormat` next.
+ */
+export function parseWorktreeFlag(argv) {
+    const remainingArgs = [];
+    let requested = false;
+    let name;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "-w" || arg === "--worktree") {
+            requested = true;
+            // Consume the next token as the name only if it isn't another flag.
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith("-")) {
+                name = next;
+                i++;
+            }
+            continue;
+        }
+        if (arg.startsWith("--worktree=")) {
+            requested = true;
+            name = arg.slice("--worktree=".length);
+            continue;
+        }
+        remainingArgs.push(arg);
+    }
+    return { requested, name, remainingArgs };
+}
+/**
+ * Parse a PR reference: `#N` or a GitHub-style PR URL, mirroring the extension's
+ * `parsePRReference` (the two packages stay independent; this is the launcher's
+ * copy so `-w` can recognize a PR ref before slug-validating the raw name).
+ */
+export function parsePRReference(input) {
+    const urlMatch = input.match(/^https?:\/\/[^/]+\/[^/]+\/[^/]+\/pull\/(\d+)\/?(?:[?#].*)?$/i);
+    if (urlMatch?.[1])
+        return parseInt(urlMatch[1], 10);
+    const hashMatch = input.match(/^#(\d+)$/);
+    if (hashMatch?.[1])
+        return parseInt(hashMatch[1], 10);
+    return null;
+}
+/**
+ * Validate a worktree slug before any side effect. Mirrors Claude's guard:
+ * length cap, per-segment allowlist, `.`/`..` rejection. Throws synchronously
+ * with a clear message (surfaced by the caller).
+ */
+export function validateWorktreeSlug(slug) {
+    if (slug.length > MAX_SLUG_LENGTH) {
+        throw new Error(`Invalid worktree name: must be ${MAX_SLUG_LENGTH} characters or fewer (got ${slug.length})`);
+    }
+    for (const segment of slug.split("/")) {
+        if (segment === "." || segment === "..") {
+            throw new Error(`Invalid worktree name "${slug}": must not contain "." or ".." path segments`);
+        }
+        if (!VALID_SLUG_SEGMENT.test(segment)) {
+            throw new Error(`Invalid worktree name "${slug}": each "/"-separated segment must be non-empty and contain only letters, digits, dots, underscores, and dashes`);
+        }
+    }
+}
+/**
+ * Validate the `-w` name + argv before any side effect. Returns a user-facing
+ * error message when the launch should be refused, or `undefined` to proceed.
+ * PR refs (`#N` / URL) skip slug validation here — they map to `pr-<N>` in the
+ * extension, whose own validation covers the mapped slug.
+ */
+export function validateWorktreeLaunchArgs(name, argv) {
+    if (name !== undefined && parsePRReference(name) === null) {
+        try {
+            validateWorktreeSlug(name);
+        }
+        catch (err) {
+            return err instanceof Error ? err.message : String(err);
+        }
+    }
+    if (argv.includes("-c") || argv.includes("--continue")) {
+        return "`-c`/`--continue` is not supported with `-w` yet. Use `-w <name>` then `--session <id>` (or `-r`) to resume.";
+    }
+    return undefined;
+}
+//# sourceMappingURL=worktreeArgs.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.0.0-staging.1177.1",
+  "version": "1.0.0-staging.1179.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)",
@@ -40,5 +40,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "92209df02c3660ed50b91a72f3197d47c2003e1d"
+  "yagniSourceSha": "0a0e2cda58c070bc25dbc00fe76d89269fb43c6f"
 }