@yagni-app/code-staging 0.2.1-staging.1033.1 → 0.2.1-staging.1038.1

package/dist/extension/cmux/dispatcher.d.ts

@@ -0,0 +1,25 @@
+import type { PiExtensionContextSnapshot } from "./state.js";
+export interface CommandResult {
+    ok: boolean;
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: unknown;
+    surfaceUnavailable?: boolean;
+}
+export declare function normalizedLaunchArgv(): string[];
+export declare function shouldPreserveEnvKey(key: string): boolean;
+export declare function hookEnvironment(cwd: string, includeSocketPassword?: boolean): NodeJS.ProcessEnv;
+export declare class CmuxDispatcher {
+    private static readonly surfaceUnavailableExitCode;
+    private controlQueues;
+    private unavailableSessions;
+    canDispatch(sessionId: string | null): boolean;
+    releaseSession(sessionId: string): void;
+    run(args: string[], cwd: string, input: string | undefined, context: PiExtensionContextSnapshot): Promise<CommandResult>;
+    private execute;
+    private spawnCmux;
+    private isSurfaceResolutionFailure;
+    private surfaceUnavailableResult;
+}
+//# sourceMappingURL=dispatcher.d.ts.map

package/dist/extension/cmux/dispatcher.js

@@ -0,0 +1,266 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+function resolveExecutable(name) {
+    const pathEnv = process.env.PATH || "";
+    for (const dir of pathEnv.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = path.join(dir, name);
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            if (fs.statSync(candidate).isFile())
+                return candidate;
+        }
+        catch { }
+    }
+    return name;
+}
+function looksLikePiExecutable(value) {
+    const base = path.basename(value).toLowerCase();
+    return base === "pi" || base === "pi-coding-agent";
+}
+function looksLikePiScript(value) {
+    const normalized = value.replaceAll("\\", "/").toLowerCase();
+    const base = path.basename(normalized);
+    return (normalized.includes("/@earendil-works/pi-coding-agent/") ||
+        normalized.includes("/@mariozechner/pi-coding-agent/") ||
+        normalized.includes("/packages/coding-agent/") ||
+        ((base === "cli.js" || base === "cli.ts") &&
+            (normalized.includes("pi-coding-agent") || normalized.includes("coding-agent"))));
+}
+export function normalizedLaunchArgv() {
+    const raw = Array.isArray(process.argv) ? process.argv.map((value) => String(value)) : [];
+    if (raw.length === 0)
+        return [resolveExecutable("pi")];
+    if (looksLikePiExecutable(raw[0]))
+        return raw;
+    if (raw.length > 1 && looksLikePiScript(raw[1])) {
+        return [resolveExecutable("pi"), ...raw.slice(2)];
+    }
+    return [resolveExecutable("pi"), ...raw.slice(1)];
+}
+function base64NulSeparated(values) {
+    const bytes = [];
+    for (const value of values) {
+        bytes.push(Buffer.from(String(value), "utf8"));
+        bytes.push(Buffer.from([0]));
+    }
+    return Buffer.concat(bytes).toString("base64");
+}
+function secretLikeEnvKey(key) {
+    return /(TOKEN|SECRET|PASSWORD|PASSWD|API[_-]?KEY|ACCESS[_-]?KEY|PRIVATE[_-]?KEY|CREDENTIAL|AUTHORIZATION|COOKIE)/i.test(key);
+}
+function safePiEnvKey(key) {
+    return (key === "PI_CODING_AGENT_DIR" ||
+        key === "PI_CONFIG_DIR" ||
+        key === "PI_CODING_AGENT_SESSION_DIR" ||
+        (key.startsWith("PI_CODING_AGENT_") && !secretLikeEnvKey(key)));
+}
+function safeNodeEnvKey(key) {
+    return (key === "NODE_ENV" ||
+        key === "NODE_OPTIONS" ||
+        key === "NODE_PATH" ||
+        key === "NODE_NO_WARNINGS" ||
+        key === "NODE_EXTRA_CA_CERTS");
+}
+function safeCmuxEnvKey(key) {
+    if (key.startsWith("CMUX_TEST_PI_"))
+        return !secretLikeEnvKey(key);
+    if (key.startsWith("CMUX_AGENT_LAUNCH_"))
+        return !secretLikeEnvKey(key);
+    if (key === "CMUX_AGENT_HOOK_STATE_DIR")
+        return true;
+    if (key === "CMUX_PI_CMUX_BIN" || key === "CMUX_PI_HOOKS_DISABLED")
+        return true;
+    if (key === "CMUX_SURFACE_ID" || key === "CMUX_WORKSPACE_ID" || key === "CMUX_WINDOW_ID")
+        return true;
+    if (key === "CMUX_PANE_ID" || key === "CMUX_TAB_ID" || key === "CMUX_PANEL_ID")
+        return true;
+    if (key === "CMUX_SOCKET" || key === "CMUX_SOCKET_PATH")
+        return true;
+    if (key === "CMUX_BUNDLE_ID" || key === "CMUX_BUNDLED_CLI_PATH")
+        return true;
+    if (key === "CMUX_CLI_SENTRY_DISABLED" || key === "CMUX_DEBUG_LOG")
+        return true;
+    return false;
+}
+export function shouldPreserveEnvKey(key) {
+    if (safeCmuxEnvKey(key))
+        return true;
+    if (safePiEnvKey(key))
+        return true;
+    if (safeNodeEnvKey(key))
+        return true;
+    if (key === "PATH" || key === "HOME" || key === "PWD" || key === "SHELL")
+        return true;
+    if (key === "USER" || key === "LOGNAME" || key === "TMPDIR" || key === "TZ")
+        return true;
+    if (key === "LANG" || key.startsWith("LC_"))
+        return true;
+    if (key === "TERM" || key === "TERM_PROGRAM" || key === "TERM_PROGRAM_VERSION" || key === "COLORTERM")
+        return true;
+    if (key === "SSH_AUTH_SOCK")
+        return true;
+    if (key.startsWith("PI_") || key.startsWith("NODE_"))
+        return !secretLikeEnvKey(key);
+    return false;
+}
+export function hookEnvironment(cwd, includeSocketPassword = false) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value === undefined)
+            continue;
+        if (shouldPreserveEnvKey(key))
+            env[key] = value;
+    }
+    if (includeSocketPassword) {
+        const socketPassword = process.env.CMUX_SOCKET_PASSWORD;
+        if (socketPassword)
+            env.CMUX_SOCKET_PASSWORD = socketPassword;
+    }
+    if (!env.CMUX_AGENT_LAUNCH_ARGV_B64) {
+        const argv = normalizedLaunchArgv();
+        env.CMUX_AGENT_LAUNCH_KIND = "pi";
+        env.CMUX_AGENT_LAUNCH_EXECUTABLE = argv[0] || resolveExecutable("pi");
+        env.CMUX_AGENT_LAUNCH_ARGV_B64 = base64NulSeparated(argv);
+        env.CMUX_AGENT_LAUNCH_CWD = cwd || process.cwd();
+    }
+    return env;
+}
+function cmuxExecutable() {
+    return process.env.CMUX_PI_CMUX_BIN || "cmux";
+}
+export class CmuxDispatcher {
+    static surfaceUnavailableExitCode = 69;
+    controlQueues = new Map();
+    unavailableSessions = new Set();
+    canDispatch(sessionId) {
+        return !sessionId || !this.unavailableSessions.has(sessionId);
+    }
+    releaseSession(sessionId) {
+        this.unavailableSessions.delete(sessionId);
+    }
+    run(args, cwd, input, context) {
+        const sessionId = context.sessionId;
+        const previous = this.controlQueues.get(sessionId) || Promise.resolve();
+        const scheduled = previous.then(() => this.execute(args, cwd, input, context));
+        let tail;
+        tail = scheduled
+            .then(() => undefined, () => undefined)
+            .finally(() => {
+            if (this.controlQueues.get(sessionId) === tail)
+                this.controlQueues.delete(sessionId);
+        });
+        this.controlQueues.set(sessionId, tail);
+        return scheduled;
+    }
+    async execute(args, cwd, input, context) {
+        const sessionId = context.sessionId;
+        if (!this.canDispatch(sessionId)) {
+            return this.surfaceUnavailableResult();
+        }
+        const result = await this.spawnCmux(args, cwd, input);
+        if (this.isSurfaceResolutionFailure(result)) {
+            if (sessionId)
+                this.unavailableSessions.add(sessionId);
+            return { ...result, surfaceUnavailable: true };
+        }
+        return result;
+    }
+    spawnCmux(args, cwd, input) {
+        return new Promise((resolve) => {
+            let settled = false;
+            let stdout = "";
+            let stderr = "";
+            let inputError;
+            let timeout = null;
+            let terminateGrace = null;
+            let forceSettleTimeout = null;
+            let terminationError;
+            const appendOutput = (current, chunk) => {
+                const limit = 1024 * 1024;
+                if (current.length >= limit)
+                    return current;
+                return current + String(chunk).slice(0, limit - current.length);
+            };
+            const settle = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                if (terminateGrace)
+                    clearTimeout(terminateGrace);
+                if (forceSettleTimeout)
+                    clearTimeout(forceSettleTimeout);
+                resolve(result);
+            };
+            const terminatedResult = () => ({
+                ok: false,
+                status: null,
+                stdout,
+                stderr,
+                error: terminationError,
+            });
+            try {
+                const child = spawn(cmuxExecutable(), args, {
+                    env: hookEnvironment(cwd, true),
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                child.stdout.setEncoding("utf8");
+                child.stderr.setEncoding("utf8");
+                child.stdout.on("data", (chunk) => { stdout = appendOutput(stdout, chunk); });
+                child.stderr.on("data", (chunk) => { stderr = appendOutput(stderr, chunk); });
+                child.stdin.on("error", (error) => { inputError = error; });
+                const beginTermination = (error) => {
+                    if (terminationError)
+                        return;
+                    terminationError = error;
+                    child.stdin.destroy();
+                    try {
+                        child.kill("SIGTERM");
+                    }
+                    catch { }
+                    terminateGrace = setTimeout(() => {
+                        try {
+                            child.kill("SIGKILL");
+                        }
+                        catch { }
+                        forceSettleTimeout = setTimeout(() => {
+                            child.stdout.destroy();
+                            child.stderr.destroy();
+                            child.unref();
+                            settle(terminatedResult());
+                        }, 250);
+                    }, 250);
+                };
+                child.on("error", (error) => {
+                    settle(terminationError ? terminatedResult() : { ok: false, status: null, stdout, stderr, error });
+                });
+                child.on("close", (code) => {
+                    if (terminationError) {
+                        settle(terminatedResult());
+                        return;
+                    }
+                    const status = typeof code === "number" ? code : null;
+                    settle({ ok: status === 0 && inputError === undefined, status, stdout, stderr, error: inputError });
+                });
+                timeout = setTimeout(() => {
+                    beginTermination(new Error("cmux command timed out after 5000ms"));
+                }, 5000);
+                child.stdin.end(input);
+            }
+            catch (error) {
+                settle({ ok: false, status: null, stdout, stderr, error });
+            }
+        });
+    }
+    isSurfaceResolutionFailure(result) {
+        return !result.ok && result.status === CmuxDispatcher.surfaceUnavailableExitCode;
+    }
+    surfaceUnavailableResult() {
+        return { ok: false, status: null, stdout: "", stderr: "", surfaceUnavailable: true };
+    }
+}
+//# sourceMappingURL=dispatcher.js.map

package/dist/extension/cmux/hooks.d.ts

@@ -0,0 +1,12 @@
+import type { CmuxDispatcher, CommandResult } from "./dispatcher.js";
+import type { PiExtensionContextSnapshot } from "./state.js";
+type HookExtra = Record<string, unknown>;
+export declare function eventName(subcommand: string): string;
+export declare function surfaceTargetArgs(dispatcher: CmuxDispatcher, sessionId: string): string[] | null;
+export declare function rememberSurfaceTarget(dispatcher: CmuxDispatcher, sessionId: string, result: CommandResult): void;
+export declare function releaseSessionRuntime(dispatcher: CmuxDispatcher, sessionStates: Map<string, unknown>, sessionId: string): void;
+export declare function sendHook(dispatcher: CmuxDispatcher, subcommand: string, context: PiExtensionContextSnapshot, extra?: HookExtra): Promise<boolean>;
+export declare function ensureResumeBinding(dispatcher: CmuxDispatcher, context: PiExtensionContextSnapshot, sessionId: string): Promise<void>;
+export declare function clearResumeBinding(dispatcher: CmuxDispatcher, context: PiExtensionContextSnapshot, sessionId: string): Promise<void>;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/extension/cmux/hooks.js

@@ -0,0 +1,192 @@
+import { normalizedLaunchArgv } from "./dispatcher.js";
+import { firstString, warn } from "./state.js";
+export function eventName(subcommand) {
+    switch (subcommand) {
+        case "session-start": return "SessionStart";
+        case "prompt-submit": return "UserPromptSubmit";
+        case "stop": return "Stop";
+        case "notification": return "Notification";
+        default: return subcommand;
+    }
+}
+const resolvedSurfaceTargets = new WeakMap();
+function surfaceTargetsFor(dispatcher) {
+    let targets = resolvedSurfaceTargets.get(dispatcher);
+    if (!targets) {
+        targets = new Map();
+        resolvedSurfaceTargets.set(dispatcher, targets);
+    }
+    return targets;
+}
+export function surfaceTargetArgs(dispatcher, sessionId) {
+    const resolved = surfaceTargetsFor(dispatcher).get(sessionId);
+    if (resolved)
+        return [...resolved];
+    const surfaceId = firstString(process.env.CMUX_SURFACE_ID);
+    if (!surfaceId)
+        return null;
+    const args = [];
+    const workspaceId = firstString(process.env.CMUX_WORKSPACE_ID);
+    if (workspaceId)
+        args.push("--workspace", workspaceId);
+    args.push("--surface", surfaceId);
+    return args;
+}
+export function rememberSurfaceTarget(dispatcher, sessionId, result) {
+    const payload = parseJSONOutput(result);
+    const workspaceId = firstString(payload?.workspace_id);
+    const surfaceId = firstString(payload?.surface_id);
+    if (!workspaceId || !surfaceId)
+        return;
+    surfaceTargetsFor(dispatcher).set(sessionId, ["--workspace", workspaceId, "--surface", surfaceId]);
+}
+export function releaseSessionRuntime(dispatcher, sessionStates, sessionId) {
+    dispatcher.releaseSession(sessionId);
+    sessionStates.delete(sessionId);
+    surfaceTargetsFor(dispatcher).delete(sessionId);
+}
+function parseJSONOutput(result) {
+    if (!result.ok)
+        return null;
+    try {
+        const parsed = JSON.parse(result.stdout);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function sendHook(dispatcher, subcommand, context, extra = {}) {
+    if (process.env.CMUX_PI_HOOKS_DISABLED === "1")
+        return true;
+    const sessionId = context.sessionId;
+    if (!sessionId)
+        return true;
+    const target = surfaceTargetArgs(dispatcher, sessionId);
+    if (!target)
+        return !firstString(process.env.CMUX_PANEL_ID);
+    const cwd = context.cwd;
+    const payload = {
+        session_id: sessionId,
+        cwd,
+        hook_event_name: eventName(subcommand),
+        event: eventName(subcommand),
+        ...extra,
+    };
+    const result = await dispatcher.run(["hooks", "pi", subcommand, ...target], cwd, JSON.stringify(payload), context);
+    if (result.ok)
+        rememberSurfaceTarget(dispatcher, sessionId, result);
+    if (!result.ok && !result.surfaceUnavailable) {
+        warn(context, "cmux hook command failed", {
+            subcommand,
+            status: result.status,
+            stderr_available: result.stderr.trim().length > 0,
+            error_available: result.error !== undefined,
+        });
+    }
+    return result.ok;
+}
+// --- Resume bindings ---
+const piOptionsWithValue = new Set([
+    "--model", "-m", "--thinking", "--provider", "--extension", "-e",
+    "--skill", "--mcp-config", "--permission-mode", "--session-dir",
+    "--config", "--profile", "--system-prompt", "--append-system-prompt",
+    "--cwd", "--dir", "--trust", "--sandbox",
+]);
+const piOptionsWithoutValue = new Set([
+    "--no-color", "--dangerously-skip-permissions", "--yolo",
+]);
+const piSelectorsToDrop = new Set([
+    "--session", "-s", "--resume", "--fork", "--api-key", "--prompt", "--print",
+]);
+function sanitizedResumeArgv(sessionId) {
+    const raw = normalizedLaunchArgv();
+    const executable = raw[0] || "pi";
+    const out = [executable, "--session", sessionId];
+    for (let index = 1; index < raw.length; index += 1) {
+        const arg = raw[index];
+        if (!arg)
+            continue;
+        if (piSelectorsToDrop.has(arg)) {
+            if (index + 1 < raw.length && !raw[index + 1].startsWith("-"))
+                index += 1;
+            continue;
+        }
+        if (arg.startsWith("--session=") || arg.startsWith("--resume=") ||
+            arg.startsWith("--fork=") || arg.startsWith("--api-key=") ||
+            arg.startsWith("--prompt=")) {
+            continue;
+        }
+        if (piOptionsWithValue.has(arg)) {
+            out.push(arg);
+            if (index + 1 < raw.length) {
+                out.push(raw[index + 1]);
+                index += 1;
+            }
+            continue;
+        }
+        if ([...piOptionsWithValue].some((option) => arg.startsWith(`${option}=`)) || piOptionsWithoutValue.has(arg)) {
+            out.push(arg);
+        }
+    }
+    return out;
+}
+function resumeBindingMatches(payload, sessionId) {
+    const binding = payload?.resume_binding;
+    if (!binding || typeof binding !== "object")
+        return false;
+    const typed = binding;
+    return firstString(typed.kind) === "pi" &&
+        firstString(typed.checkpoint_id, typed.checkpointId) === sessionId;
+}
+export async function ensureResumeBinding(dispatcher, context, sessionId) {
+    if (process.env.CMUX_PI_HOOKS_DISABLED === "1")
+        return;
+    const target = surfaceTargetArgs(dispatcher, sessionId);
+    if (!target)
+        return;
+    const cwd = context.cwd;
+    const resumeArgv = sanitizedResumeArgv(sessionId);
+    const set = await dispatcher.run([
+        "--json", "surface", "resume", "set", ...target,
+        "--name", "Pi", "--kind", "pi", "--checkpoint-id", sessionId,
+        "--source", "agent-hook", "--cwd", cwd, "--", ...resumeArgv,
+    ], cwd, undefined, context);
+    if (!set.ok && !set.surfaceUnavailable) {
+        warn(context, "failed to set Pi resume binding", {
+            status: set.status,
+            stderr_available: set.stderr.trim().length > 0,
+        });
+        return;
+    }
+    if (set.surfaceUnavailable)
+        return;
+    const verification = await dispatcher.run(["--json", "surface", "resume", "get", ...target], cwd, undefined, context);
+    if (verification.surfaceUnavailable)
+        return;
+    const verified = parseJSONOutput(verification);
+    if (!resumeBindingMatches(verified, sessionId)) {
+        warn(context, "Pi resume binding did not verify after write", { session_id: sessionId });
+    }
+}
+export async function clearResumeBinding(dispatcher, context, sessionId) {
+    if (process.env.CMUX_PI_HOOKS_DISABLED === "1")
+        return;
+    const target = surfaceTargetArgs(dispatcher, sessionId);
+    if (!target)
+        return;
+    const cwd = context.cwd;
+    const result = await dispatcher.run([
+        "--json", "surface", "resume", "clear", ...target,
+        "--checkpoint-id", sessionId, "--source", "agent-hook",
+    ], cwd, undefined, context);
+    if (result.surfaceUnavailable)
+        return;
+    if (!result.ok) {
+        warn(context, "failed to clear Pi resume binding", {
+            status: result.status,
+            stderr_available: result.stderr.trim().length > 0,
+        });
+    }
+}
+//# sourceMappingURL=hooks.js.map

package/dist/extension/cmux/index.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export declare function registerCmuxBridge(pi: ExtensionAPI): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/extension/cmux/index.js

@@ -0,0 +1,155 @@
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { CmuxDispatcher } from "./dispatcher.js";
+import { stateFor, snapshotContext, beginTurn, currentTurnId, finishTurn, settleTurn, lastAssistantMessage, firstString, objectValue, warn, } from "./state.js";
+import { sendHook, ensureResumeBinding, clearResumeBinding, releaseSessionRuntime, } from "./hooks.js";
+import { renameWorkspaceFromPrompt } from "./naming.js";
+/** Remove a stale cmux-installed extension so hooks don't double-fire. */
+function removeStaleManagedExtension() {
+    const agentDir = process.env.PI_CODING_AGENT_DIR || process.env.YAGNI_CODING_AGENT_DIR;
+    if (!agentDir)
+        return;
+    const managed = join(agentDir, "extensions", "cmux-session.ts");
+    try {
+        if (!existsSync(managed))
+            return;
+        const head = readFileSync(managed, "utf8").slice(0, 200);
+        if (head.includes("cmux-pi-session-extension-marker")) {
+            unlinkSync(managed);
+            try {
+                unlinkSync(join(agentDir, "extensions", ".cmux-session.lock"));
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+export function registerCmuxBridge(pi) {
+    if (!process.env.CMUX_SURFACE_ID)
+        return;
+    if (process.env.CMUX_PI_HOOKS_DISABLED === "1")
+        return;
+    const dispatcher = new CmuxDispatcher();
+    const sessionStates = new Map();
+    const lifecycleTails = new Map();
+    const enqueueLifecycleTask = (sessionId, context, operation) => {
+        const previous = lifecycleTails.get(sessionId) || Promise.resolve();
+        let tracked;
+        tracked = previous
+            .then(operation)
+            .then(() => undefined)
+            .catch((error) => {
+            const msg = error instanceof Error ? error.message : undefined;
+            warn(context, "cmux lifecycle task failed", { error_message: msg?.slice(0, 512) }, true);
+        })
+            .finally(() => {
+            if (lifecycleTails.get(sessionId) === tracked)
+                lifecycleTails.delete(sessionId);
+        });
+        lifecycleTails.set(sessionId, tracked);
+        return tracked;
+    };
+    pi.on("session_start", (_event, ctx) => {
+        removeStaleManagedExtension();
+        const context = snapshotContext(ctx);
+        const sessionId = context.sessionId;
+        if (!sessionId)
+            return;
+        const state = stateFor(sessionStates, sessionId);
+        state.pendingCompletion = undefined;
+        state.stopped = false;
+        enqueueLifecycleTask(sessionId, context, async () => {
+            const ok = await sendHook(dispatcher, "session-start", context);
+            if (ok)
+                await ensureResumeBinding(dispatcher, context, sessionId);
+        });
+    });
+    pi.on("before_agent_start", (event, ctx) => {
+        const context = snapshotContext(ctx);
+        const sessionId = context.sessionId;
+        if (!sessionId)
+            return;
+        const turnId = beginTurn(sessionStates, sessionId, event);
+        const st = stateFor(sessionStates, sessionId);
+        if (typeof event.prompt === "string" && event.prompt.trim()) {
+            st.lastPrompt = event.prompt.trim();
+        }
+        enqueueLifecycleTask(sessionId, context, () => sendHook(dispatcher, "prompt-submit", context, { prompt: event.prompt, turn_id: turnId }));
+    });
+    pi.on("agent_end", (event, ctx) => {
+        const context = snapshotContext(ctx);
+        const sessionId = context.sessionId;
+        if (!sessionId)
+            return;
+        const state = stateFor(sessionStates, sessionId);
+        const message = lastAssistantMessage(event);
+        state.pendingCompletion = {
+            lastAssistantMessage: message || state.pendingCompletion?.lastAssistantMessage,
+            notificationType: firstString(objectValue(event, ["stopReason", "reason", "terminationReason"])) || "completed",
+            turnId: currentTurnId(sessionStates, sessionId, event),
+        };
+        // Pi >= 0.80.5 always emits agent_settled, so we wait for it there.
+    });
+    pi.on("agent_settled", (_event, ctx) => {
+        const context = snapshotContext(ctx);
+        try {
+            if (!ctx.isIdle())
+                return;
+        }
+        catch {
+            return;
+        }
+        const sessionId = context.sessionId;
+        if (!sessionId)
+            return;
+        const completion = settleTurn(sessionStates, sessionId);
+        if (completion) {
+            enqueueLifecycleTask(sessionId, context, () => publishCompletion(dispatcher, sessionStates, context, sessionId, completion));
+        }
+    });
+    pi.on("session_shutdown", async (event, ctx) => {
+        const context = snapshotContext(ctx);
+        const sessionId = context.sessionId;
+        if (!sessionId)
+            return;
+        const state = stateFor(sessionStates, sessionId);
+        let stopPayload;
+        if (!state.stopped) {
+            const turnId = finishTurn(sessionStates, sessionId, event);
+            stopPayload = {
+                turn_id: turnId,
+                terminationReason: firstString(objectValue(event, ["reason"])) || "session_shutdown",
+            };
+        }
+        await enqueueLifecycleTask(sessionId, context, async () => {
+            if (stopPayload)
+                await sendHook(dispatcher, "stop", context, stopPayload);
+            try {
+                await clearResumeBinding(dispatcher, context, sessionId);
+            }
+            finally {
+                releaseSessionRuntime(dispatcher, sessionStates, sessionId);
+            }
+        });
+    });
+}
+async function publishCompletion(dispatcher, sessionStates, context, sessionId, completion) {
+    const stopPayload = {
+        last_assistant_message: completion.lastAssistantMessage,
+        turn_id: completion.turnId,
+    };
+    const notificationRouted = await sendHook(dispatcher, "notification", context, {
+        message: completion.lastAssistantMessage || "Task completed",
+        turn_id: completion.turnId,
+        notification: { type: completion.notificationType },
+    });
+    if (notificationRouted)
+        stopPayload.cmux_notification_routed = true;
+    await sendHook(dispatcher, "stop", context, stopPayload);
+    const state = stateFor(sessionStates, sessionId);
+    if (!state.hasNamed) {
+        renameWorkspaceFromPrompt(dispatcher, sessionStates, context, sessionId);
+        state.hasNamed = true;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/extension/cmux/naming.d.ts

@@ -0,0 +1,5 @@
+import type { CmuxDispatcher } from "./dispatcher.js";
+import { type PiExtensionContextSnapshot, type SessionState } from "./state.js";
+export declare function titleFromPrompt(prompt: string): string | undefined;
+export declare function renameWorkspaceFromPrompt(dispatcher: CmuxDispatcher, sessionStates: Map<string, SessionState>, context: PiExtensionContextSnapshot, sessionId: string): void;
+//# sourceMappingURL=naming.d.ts.map

package/dist/extension/cmux/naming.js

@@ -0,0 +1,23 @@
+import { firstString } from "./state.js";
+export function titleFromPrompt(prompt) {
+    const words = prompt.trim().split(/\s+/).filter(Boolean);
+    if (words.length === 0)
+        return undefined;
+    return words.slice(0, 8).join(" ").slice(0, 60) || undefined;
+}
+export function renameWorkspaceFromPrompt(dispatcher, sessionStates, context, sessionId) {
+    const prompt = sessionStates.get(sessionId)?.lastPrompt;
+    if (!prompt)
+        return;
+    const title = titleFromPrompt(prompt);
+    if (!title)
+        return;
+    // Use the workspace-scoped rename form: cmux workspace rename <ws> --title <title>
+    // (NOT rename-workspace --workspace ... --surface ... which misinterprets --surface
+    // as part of the title).
+    const workspaceId = firstString(process.env.CMUX_WORKSPACE_ID);
+    if (!workspaceId)
+        return;
+    void dispatcher.run(["workspace", "rename", workspaceId, "--title", title], context.cwd, undefined, context);
+}
+//# sourceMappingURL=naming.js.map

package/dist/extension/cmux/state.d.ts

@@ -0,0 +1,33 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+export interface PendingCompletion {
+    lastAssistantMessage?: string;
+    notificationType: string;
+    turnId: string;
+}
+export interface SessionState {
+    nextTurn: number;
+    activeTurnId?: string;
+    pendingCompletion?: PendingCompletion;
+    stopped: boolean;
+    lastPrompt?: string;
+    hasNamed?: boolean;
+}
+export interface PiExtensionContextSnapshot {
+    readonly sessionId: string | null;
+    readonly cwd: string;
+    readonly notifyWarning?: () => void;
+}
+export declare function firstString(...values: unknown[]): string | null;
+export declare function objectValue(value: unknown, keys: string[]): unknown;
+export declare function textFromContent(content: unknown): string | null;
+export declare function lastAssistantMessage(event: unknown): string | undefined;
+export declare function sessionIdFrom(ctx: ExtensionContext): string | null;
+export declare function cwdFrom(ctx: ExtensionContext): string;
+export declare function snapshotContext(ctx: ExtensionContext): PiExtensionContextSnapshot;
+export declare function stateFor(sessionStates: Map<string, SessionState>, sessionId: string): SessionState;
+export declare function beginTurn(sessionStates: Map<string, SessionState>, sessionId: string, event: unknown): string;
+export declare function currentTurnId(sessionStates: Map<string, SessionState>, sessionId: string, event: unknown): string;
+export declare function finishTurn(sessionStates: Map<string, SessionState>, sessionId: string, event: unknown): string;
+export declare function settleTurn(sessionStates: Map<string, SessionState>, sessionId: string): PendingCompletion | undefined;
+export declare function warn(ctx: PiExtensionContextSnapshot | null, message: string, details?: Record<string, unknown>, notifyUser?: boolean): void;
+//# sourceMappingURL=state.d.ts.map

package/dist/extension/cmux/state.js

@@ -0,0 +1,142 @@
+export function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0)
+            return value.trim();
+    }
+    return null;
+}
+export function objectValue(value, keys) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const typed = value;
+    for (const key of keys) {
+        if (typed[key] !== undefined && typed[key] !== null)
+            return typed[key];
+    }
+    return undefined;
+}
+export function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        const typed = block;
+        if (typed.type === "text" && typeof typed.text === "string")
+            parts.push(typed.text);
+    }
+    return parts.join("\n") || null;
+}
+export function lastAssistantMessage(event) {
+    const messagesValue = objectValue(event, ["messages"]);
+    const messages = Array.isArray(messagesValue) ? messagesValue : [];
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (!message || typeof message !== "object")
+            continue;
+        const typed = message;
+        if (typed.role !== "assistant")
+            continue;
+        const text = firstString(textFromContent(typed.content));
+        if (text)
+            return text;
+    }
+    return undefined;
+}
+export function sessionIdFrom(ctx) {
+    try {
+        return firstString(ctx.sessionManager?.getSessionId?.());
+    }
+    catch {
+        return null;
+    }
+}
+export function cwdFrom(ctx) {
+    try {
+        return firstString(ctx.cwd, process.cwd()) || process.cwd();
+    }
+    catch {
+        return process.cwd();
+    }
+}
+export function snapshotContext(ctx) {
+    if (!ctx || typeof ctx !== "object") {
+        return { sessionId: null, cwd: process.cwd() };
+    }
+    let notifyWarning;
+    try {
+        const ui = ctx.ui;
+        if (typeof ui?.notify === "function") {
+            notifyWarning = () => ui.notify?.("cmux integration warning — check the terminal for details", "warning");
+        }
+    }
+    catch { }
+    return { sessionId: sessionIdFrom(ctx), cwd: cwdFrom(ctx), notifyWarning };
+}
+export function stateFor(sessionStates, sessionId) {
+    let state = sessionStates.get(sessionId);
+    if (!state) {
+        state = { nextTurn: 0, stopped: false };
+        sessionStates.set(sessionId, state);
+    }
+    return state;
+}
+function eventTurnId(event) {
+    return firstString(objectValue(event, ["turn_id", "turnId", "turnID"]));
+}
+export function beginTurn(sessionStates, sessionId, event) {
+    const state = stateFor(sessionStates, sessionId);
+    const turnId = eventTurnId(event) || `${sessionId}:turn-${state.nextTurn + 1}`;
+    if (!eventTurnId(event))
+        state.nextTurn += 1;
+    state.activeTurnId = turnId;
+    state.pendingCompletion = undefined;
+    state.stopped = false;
+    return turnId;
+}
+export function currentTurnId(sessionStates, sessionId, event) {
+    const state = stateFor(sessionStates, sessionId);
+    const turnId = eventTurnId(event) || state.activeTurnId || `${sessionId}:turn-${state.nextTurn + 1}`;
+    if (!eventTurnId(event) && !state.activeTurnId)
+        state.nextTurn += 1;
+    return turnId;
+}
+export function finishTurn(sessionStates, sessionId, event) {
+    const state = stateFor(sessionStates, sessionId);
+    const turnId = eventTurnId(event) || state.activeTurnId || `${sessionId}:turn-${state.nextTurn + 1}`;
+    if (!eventTurnId(event) && !state.activeTurnId)
+        state.nextTurn += 1;
+    state.activeTurnId = undefined;
+    state.pendingCompletion = undefined;
+    state.stopped = true;
+    return turnId;
+}
+export function settleTurn(sessionStates, sessionId) {
+    const state = sessionStates.get(sessionId);
+    const completion = state?.pendingCompletion;
+    if (!state || !completion || state.stopped)
+        return undefined;
+    state.activeTurnId = undefined;
+    state.pendingCompletion = undefined;
+    state.stopped = true;
+    return completion;
+}
+export function warn(ctx, message, details = {}, notifyUser = false) {
+    const payload = { source: "yagni-cmux-bridge", level: "warning", message, ...details };
+    try {
+        console.warn(JSON.stringify(payload));
+    }
+    catch {
+        console.warn(`[yagni-cmux-bridge] ${message}`);
+    }
+    if (notifyUser) {
+        try {
+            ctx?.notifyWarning?.();
+        }
+        catch { }
+    }
+}
+//# sourceMappingURL=state.js.map

package/dist/extension/index.d.ts

@@ -97,6 +97,7 @@ export declare function parseSpendResponse(data: unknown): SpendResponse | null;
 export declare function registerYagni(pi: ExtensionAPI, deps?: RegisterYagniDeps): Promise<void>;
 export default function (pi: ExtensionAPI): Promise<void>;
 export { makeAskYagniTool } from "./askYagniTool.js";
+export { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
 export { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
 export { ADVISOR_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatAdvisorSubtotal, makeAdvisorState, } from "./advisor.js";
 export type { Citation, MakeAskYagniToolOptions } from "./askYagniTool.js";

package/dist/extension/index.js

@@ -4,7 +4,9 @@ import { Text } from "@earendil-works/pi-tui";
 import { DEFAULT_ADVISOR_LIMITS, formatAdvisorSubtotal, makeAdvisorState } from "./advisor.js";
 import { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
 import { makeAskYagniTool } from "./askYagniTool.js";
+import { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
 import { makeReviewBusinessMatchTool } from "./reviewTool.js";
+import { registerCmuxBridge } from "./cmux/index.js";
 import { makeRecordEngineeringContextTool } from "./recordContextTool.js";
 import { makeRecordDecisionTool } from "./recordDecisionTool.js";
 import { makeSuggestNextWorkTool } from "./nextWorkTool.js";
@@ -125,6 +127,12 @@ export async function registerYagni(pi, deps = {}) {
     pi.registerProvider("yagni", buildYagniProvider(catalog, baseUrl, attributionHeaders(deps.env)));
     const toolOpts = { baseUrl, getToken: getTokenFn, fetchImpl: authedFetch };
     pi.registerTool(makeAskYagniTool(toolOpts));
+    // Ticket write-back (spec 2026-08-09): explicit user-intent writes to the
+    // workspace tracker, attributed to the developer via per-user credentials.
+    if (!evalMode) {
+        pi.registerTool(makeFileTicketTool(toolOpts));
+        pi.registerTool(makeUpdateTicketStatusTool(toolOpts));
+    }
     // The peak-tier escalation for Advanced sessions (YAG-380). Registered
     // UNCONDITIONALLY and gated at execute time on the live session model: pi's
     // picker can switch the model after activation, so a registration-time tier
@@ -224,6 +232,7 @@ export async function registerYagni(pi, deps = {}) {
                         ...DEFAULT_PERMISSION_POLICY.reviewConfirmTools,
                         ...mcpMutatingTools,
                     ],
+                    alwaysConfirmTools: DEFAULT_PERMISSION_POLICY.alwaysConfirmTools,
                 },
             }
             : {}),
@@ -547,8 +556,15 @@ export async function registerYagni(pi, deps = {}) {
 }
 export default async function (pi) {
     await registerYagni(pi);
+    // cmux session bridge: report lifecycle state (running/idle), workspace
+    // naming, and resume bindings to cmux when running inside it. Complete
+    // no-op outside cmux — guarded by CMUX_SURFACE_ID. Registered in the
+    // default export (not registerYagni) so tests that call registerYagni
+    // directly don't get the bridge's handlers.
+    registerCmuxBridge(pi);
 }
 export { makeAskYagniTool } from "./askYagniTool.js";
+export { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
 export { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
 export { ADVISOR_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatAdvisorSubtotal, makeAdvisorState, } from "./advisor.js";
 export { makeReviewBusinessMatchTool } from "./reviewTool.js";

package/dist/extension/permission.d.ts

@@ -4,7 +4,8 @@
  * YAGNI Code registers no tool_call handler today, so the interactive session has
  * no plan/approval surface. P3 adds one on pi's documented `tool_call` block seam
  * plus a `/mode` command:
- *   - auto   (default): never blocks. Byte-identical to today, so this is additive.
+ *   - auto   (default): ordinary coding tools run directly; external tracker
+ *              changes still require fresh human confirmation.
  *   - plan   : blocks write/edit/bash so the agent can explore + propose without
  *              touching the tree.
  *   - review : surfaces a three-way ctx.ui.select before a write/edit/bash; a
@@ -14,7 +15,7 @@
  *              adds a session-scoped bless rule AND drafts a decision capture.
  *
  * `decideGate` is PURE; the live wiring holds the mode in a small closure (no
- * module-global state). The default auto mode remains fail-open, but stricter
+ * module-global state). The default auto mode remains direct for coding tools, but stricter
  * modes fail closed for side-effect tools if the gate itself errors. Bless rules
  * are session-scoped, path-prefix-bound, never persisted, and never consulted in
  * plan mode (plan blocks outright before isBlessed is reached).
@@ -34,6 +35,8 @@ export interface PermissionPolicy {
     planBlockTools: string[];
     /** Tools that prompt for confirmation in review mode. */
     reviewConfirmTools: string[];
+    /** Consequential external writes that require fresh consent in every mode. */
+    alwaysConfirmTools?: string[];
     /**
      * Optional: a recorded decision already blesses this action, so it auto-runs in
      * review mode instead of prompting. The hook for tying the gate to captured
@@ -50,8 +53,8 @@ export interface GateDecision {
     confirm?: boolean;
 }
 /**
- * Pure permission decision for one tool call under a mode + policy. auto always
- * allows; plan blocks the write/exec set; review marks writes for confirmation
+ * Pure permission decision for one tool call under a mode + policy. Auto allows
+ * ordinary tools; plan blocks the write/exec set; review marks writes for confirmation
  * unless a recorded decision blesses them.
  */
 export declare function decideGate(toolName: string, params: Record<string, unknown>, mode: PermissionMode, policy: PermissionPolicy): GateDecision;

package/dist/extension/permission.js

@@ -4,7 +4,8 @@
  * YAGNI Code registers no tool_call handler today, so the interactive session has
  * no plan/approval surface. P3 adds one on pi's documented `tool_call` block seam
  * plus a `/mode` command:
- *   - auto   (default): never blocks. Byte-identical to today, so this is additive.
+ *   - auto   (default): ordinary coding tools run directly; external tracker
+ *              changes still require fresh human confirmation.
  *   - plan   : blocks write/edit/bash so the agent can explore + propose without
  *              touching the tree.
  *   - review : surfaces a three-way ctx.ui.select before a write/edit/bash; a
@@ -14,7 +15,7 @@
  *              adds a session-scoped bless rule AND drafts a decision capture.
  *
  * `decideGate` is PURE; the live wiring holds the mode in a small closure (no
- * module-global state). The default auto mode remains fail-open, but stricter
+ * module-global state). The default auto mode remains direct for coding tools, but stricter
  * modes fail closed for side-effect tools if the gate itself errors. Bless rules
  * are session-scoped, path-prefix-bound, never persisted, and never consulted in
  * plan mode (plan blocks outright before isBlessed is reached).
@@ -27,17 +28,16 @@
  */
 import { makeBlessStore as defaultMakeBlessStore } from "./bless.js";
 export const DEFAULT_PERMISSION_POLICY = {
-    planBlockTools: ["write", "edit", "bash"],
-    reviewConfirmTools: ["write", "edit", "bash"],
+    planBlockTools: ["write", "edit", "bash", "file_ticket", "update_ticket_status"],
+    reviewConfirmTools: ["write", "edit", "bash", "file_ticket", "update_ticket_status"],
+    alwaysConfirmTools: ["file_ticket", "update_ticket_status"],
 };
 /**
- * Pure permission decision for one tool call under a mode + policy. auto always
- * allows; plan blocks the write/exec set; review marks writes for confirmation
+ * Pure permission decision for one tool call under a mode + policy. Auto allows
+ * ordinary tools; plan blocks the write/exec set; review marks writes for confirmation
  * unless a recorded decision blesses them.
  */
 export function decideGate(toolName, params, mode, policy) {
-    if (mode === "auto")
-        return { block: false };
     if (mode === "plan") {
         if (policy.planBlockTools.includes(toolName)) {
             return {
@@ -47,6 +47,11 @@ export function decideGate(toolName, params, mode, policy) {
         }
         return { block: false };
     }
+    if (policy.alwaysConfirmTools?.includes(toolName)) {
+        return { block: false, confirm: true };
+    }
+    if (mode === "auto")
+        return { block: false };
     // review
     if (policy.reviewConfirmTools.includes(toolName)) {
         if (policy.isBlessed?.(toolName, params))
@@ -96,7 +101,7 @@ const MODE_STATUS = {
     review: "✓ review",
 };
 const MODE_COPY = {
-    auto: "auto: changes apply without prompting (default).",
+    auto: "auto: coding changes apply directly; external tracker changes ask first (default).",
     plan: "plan: write, edit, and bash are held so the agent can explore and propose only.",
     review: "review: you confirm each write, edit, or bash command before it applies.",
 };
@@ -104,7 +109,32 @@ function isMode(value) {
     return value === "auto" || value === "plan" || value === "review";
 }
 function sideEffectTools(policy) {
-    return new Set([...policy.planBlockTools, ...policy.reviewConfirmTools]);
+    return new Set([
+        ...policy.planBlockTools,
+        ...policy.reviewConfirmTools,
+        ...(policy.alwaysConfirmTools ?? []),
+    ]);
+}
+function boundedPromptValue(value, fallback) {
+    if (typeof value !== "string")
+        return fallback;
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (normalized.length === 0)
+        return fallback;
+    return normalized.length <= 80 ? normalized : `${normalized.slice(0, 77)}…`;
+}
+function externalTrackerPrompt(toolName, input) {
+    if (toolName === "file_ticket") {
+        const title = boundedPromptValue(input.title, "Untitled ticket");
+        const target = boundedPromptValue(input.target_key, "default project/team");
+        return `File “${title}” in ${target}?`;
+    }
+    if (toolName === "update_ticket_status") {
+        const ref = boundedPromptValue(input.ref, "ticket");
+        const status = boundedPromptValue(input.status, "requested status");
+        return `Move ${ref} to ${status}?`;
+    }
+    return "Confirm external tracker change";
 }
 /**
  * Wire the tool_call gate + the /mode command onto a shared mode holder. Default
@@ -121,6 +151,7 @@ export function registerPermissionGate(pi, deps = {}) {
     const effectivePolicy = {
         planBlockTools: basePolicy.planBlockTools,
         reviewConfirmTools: basePolicy.reviewConfirmTools,
+        alwaysConfirmTools: basePolicy.alwaysConfirmTools,
         isBlessed: basePolicy.isBlessed ?? ((tool, params) => blessStore?.isBlessed(tool, params) ?? false),
     };
     const sideEffects = sideEffectTools(effectivePolicy);
@@ -136,7 +167,7 @@ export function registerPermissionGate(pi, deps = {}) {
                 // cannot get consent for is held rather than silently auto-applied (this
                 // mirrors plan mode, which blocks regardless of UI).
                 if (!ctx?.hasUI) {
-                    return { block: true, reason: `review mode: ${event.toolName} held (no UI to confirm). Switch to /mode auto to apply.` };
+                    return { block: true, reason: `${event.toolName} held (no UI to confirm this action).` };
                 }
                 // Lazily bind the bless store to this session's cwd.
                 if (!blessStore)
@@ -144,14 +175,16 @@ export function registerPermissionGate(pi, deps = {}) {
                 // Three-way prompt (pi's confirm is boolean-only, so use select): Yes,
                 // Yes-and-remember (only when a path-prefix bless is meaningful), or No.
                 const dir = blessStore.describeDir(input);
-                const blessable = dir !== null;
+                const blessable = dir !== null && !effectivePolicy.alwaysConfirmTools?.includes(event.toolName);
                 const yes = "Yes";
                 const no = "No";
                 const remember = blessable
                     ? `Yes, and don't ask again for ${event.toolName} in ${dir}`
                     : undefined;
                 const options = blessable ? [yes, remember, no] : [yes, no];
-                const choice = await ctx.ui.select("YAGNI Code review mode", options);
+                const choice = await ctx.ui.select(effectivePolicy.alwaysConfirmTools?.includes(event.toolName)
+                    ? externalTrackerPrompt(event.toolName, input)
+                    : "YAGNI Code review mode", options);
                 if (choice === yes)
                     return {};
                 if (blessable && choice === remember) {

package/dist/extension/ticketTools.d.ts

@@ -0,0 +1,37 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+/**
+ * Ticket write-back tools (spec 2026-08-09): file a ticket, move a ticket.
+ *
+ * Both are EXPLICIT user-intent actions — the guidelines pin the agent to
+ * calling them only when the developer asked. Writes execute server-side as
+ * the developer's own tracker account (per-user write identity); when no
+ * personal connection exists the backend answers 412 `connect_required` and
+ * the tool renders the one-time connect prompt instead of failing opaquely.
+ */
+export interface MakeTicketToolOptions {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+}
+declare const fileTicketParams: Type.TObject<{
+    title: Type.TString;
+    description: Type.TOptional<Type.TString>;
+    tracker: Type.TOptional<Type.TUnion<[Type.TLiteral<"jira">, Type.TLiteral<"linear">]>>;
+    target_key: Type.TOptional<Type.TString>;
+}>;
+export declare function makeFileTicketTool(opts: MakeTicketToolOptions): ToolDefinition<typeof fileTicketParams, {
+    identifier?: string;
+    url?: string | null;
+}>;
+declare const updateTicketStatusParams: Type.TObject<{
+    ref: Type.TString;
+    status: Type.TString;
+    tracker: Type.TOptional<Type.TUnion<[Type.TLiteral<"jira">, Type.TLiteral<"linear">]>>;
+}>;
+export declare function makeUpdateTicketStatusTool(opts: MakeTicketToolOptions): ToolDefinition<typeof updateTicketStatusParams, {
+    identifier?: string;
+    state?: string;
+}>;
+export {};
+//# sourceMappingURL=ticketTools.d.ts.map

package/dist/extension/ticketTools.js

@@ -0,0 +1,117 @@
+import { Type } from "typebox";
+import { friendlyFetchError, METERED_POST_FETCH_POLICY, resilientFetch, } from "./resilientFetch.js";
+/** Render backend problem responses (412/404/422) as agent-relayable text. */
+async function renderProblem(toolName, res) {
+    let body = null;
+    try {
+        body = (await res.clone().json());
+    }
+    catch {
+        body = null;
+    }
+    if (res.status === 412 && body?.error === "connect_required") {
+        return [
+            `A personal ${body.service ?? "tracker"} connection is needed to write as you.`,
+            `Connect here (one time): ${body.connect_url ?? "(ask your admin for the connect link)"}`,
+            "Then ask me again and I'll retry.",
+        ].join("\n");
+    }
+    if ((res.status === 404 || res.status === 422) && body?.error) {
+        const options = body.options?.length
+            ? `\nAvailable options: ${body.options.join(", ")}`
+            : "";
+        return `${body.message ?? body.error}${options}`;
+    }
+    throw new Error(await friendlyFetchError(toolName, res));
+}
+const fileTicketParams = Type.Object({
+    title: Type.String(),
+    description: Type.Optional(Type.String()),
+    tracker: Type.Optional(Type.Union([Type.Literal("jira"), Type.Literal("linear")])),
+    target_key: Type.Optional(Type.String()),
+});
+export function makeFileTicketTool(opts) {
+    return {
+        name: "file_ticket",
+        label: "File Ticket",
+        description: "File a ticket in the workspace's tracker (Jira or Linear), attributed to the developer's " +
+            "own account. ONLY call when the user explicitly asks to file/create a ticket — never " +
+            "speculatively, never as a side effect of other work. Pass target_key (Jira project key or " +
+            "Linear team key) when the workspace has more than one.",
+        promptSnippet: "file_ticket: file a ticket in the workspace tracker as the developer (explicit request only).",
+        promptGuidelines: [
+            "Call file_ticket ONLY when the user explicitly asks to file, create, or capture a ticket.",
+            "If the tool reports a connect prompt or asks for a target/tracker, relay it verbatim and wait for the user.",
+        ],
+        parameters: fileTicketParams,
+        async execute(toolCallId, params, signal) {
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/tickets`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${opts.getToken() ?? ""}`,
+                },
+                body: JSON.stringify({ ...params, idempotencyKey: toolCallId }),
+            }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+            if (!res.ok) {
+                const text = await renderProblem("file_ticket", res);
+                return { content: [{ type: "text", text }], details: {} };
+            }
+            const data = (await res.json());
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Filed ${data.identifier}${data.url ? `: ${data.url}` : ""}`,
+                    },
+                ],
+                details: { identifier: data.identifier, url: data.url },
+            };
+        },
+    };
+}
+const updateTicketStatusParams = Type.Object({
+    ref: Type.String(),
+    status: Type.String(),
+    tracker: Type.Optional(Type.Union([Type.Literal("jira"), Type.Literal("linear")])),
+});
+export function makeUpdateTicketStatusTool(opts) {
+    return {
+        name: "update_ticket_status",
+        label: "Update Ticket Status",
+        description: "Move a ticket to a new status by name (e.g. mark YAG-123 In Progress), attributed to the " +
+            "developer's own tracker account. ONLY call on the user's explicit request — never as an " +
+            "automatic side effect of starting or finishing work.",
+        promptSnippet: "update_ticket_status: move a tracker ticket to a named status as the developer (explicit request only).",
+        promptGuidelines: [
+            "Call update_ticket_status ONLY when the user explicitly asks to move/mark a ticket's status.",
+            "If the requested status is not available, relay the offered options and let the user pick.",
+        ],
+        parameters: updateTicketStatusParams,
+        async execute(toolCallId, params, signal) {
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/tickets/transition`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${opts.getToken() ?? ""}`,
+                },
+                body: JSON.stringify({ ...params, idempotencyKey: toolCallId }),
+            }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+            if (!res.ok) {
+                const text = await renderProblem("update_ticket_status", res);
+                return { content: [{ type: "text", text }], details: {} };
+            }
+            const data = (await res.json());
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${data.identifier} → ${data.state ?? params.status}`,
+                    },
+                ],
+                details: { identifier: data.identifier, state: data.state },
+            };
+        },
+    };
+}
+//# sourceMappingURL=ticketTools.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "0.2.1-staging.1033.1",
+  "version": "0.2.1-staging.1038.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.83.0",
     "typebox": "^1.1.38"
   },
-  "yagniSourceSha": "42e45669472777af680dce047ce01490793d6712"
+  "yagniSourceSha": "4493e421b21ba86ed37645beecef7c9a74799f4b"
 }