@yagni-app/code-staging 0.2.1-staging.1034.1 → 0.2.1-staging.1039.1

package/dist/cli.d.ts

@@ -12,6 +12,27 @@
  * plus a configured pi spawn. Everything that makes this "YAGNI Code" lives in
  * pi-extension-yagni and the YAGNI backend.
  */
+/**
+ * Seed `editorPaddingX` into the per-profile pi `settings.json` so the prompt
+ * input is padded to match the chat/output area (`outputPad`) and the status
+ * bar. Fills the key in only when absent — an explicit user choice (including
+ * 0) is never overwritten. Best-effort: a missing/corrupt settings file or a
+ * write failure must never block the launch.
+ */
+/**
+ * Seed `editorPaddingX` into the per-profile pi `settings.json` so the prompt
+ * input aligns with the chat/output area (`outputPad`) and the status bar.
+ *
+ * This writes to a user-owned file, so it is deliberately conservative:
+ *  - fills the key in ONLY when absent — an explicit user choice (including 0)
+ *    is never overwritten;
+ *  - backs off on a missing-dir, corrupt, non-object, or symlinked settings
+ *    file rather than risk clobbering anything;
+ *  - writes ATOMICALLY (temp file + rename) and preserves the existing file's
+ *    permissions, so a crash mid-write can never truncate the user's settings.
+ * Any failure is swallowed: seeding must never block or break a launch.
+ */
+export declare function seedEditorPadding(piAgentDir: string): void;
 export declare const HELP_TEXT: string;
 /** Parse `use <name> [--base-url <url>]` argv into its parts. */
 export declare function parseUseArgs(args: string[]): {

package/dist/cli.js

@@ -13,7 +13,8 @@
  * pi-extension-yagni and the YAGNI backend.
  */
 import { spawn } from "node:child_process";
-import { mkdirSync, realpathSync } from "node:fs";
+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 { PI_CONFIG_NAME } from "./branding.js";
@@ -27,6 +28,7 @@ import { runDoctor } from "./doctor.js";
 import { installProcessCrashHandlers } from "./crashReport.js";
 import { currentCliVersion, maybeNudgeAndRefresh, upgradeCommand } from "./upgrade.js";
 import { maybeRefreshAtLaunch } from "./refresh.js";
+import { PAD_X } from "./padding.js";
 import { ensureShadowPiPackage } from "./piPackage.js";
 import { resolveExtensionPath, resolvePiCliPath, resolvePiPackageDir } from "./paths.js";
 import { credentialsFromProfile, getActiveProfileName, listProfiles, migrateLegacyCredentials, persistProfileTokenRotation, profilePath, readActiveProfile, useProfile, } from "./profiles.js";
@@ -43,6 +45,72 @@ async function confirmOnTty(question) {
         rl.close();
     }
 }
+/**
+ * Seed `editorPaddingX` into the per-profile pi `settings.json` so the prompt
+ * input is padded to match the chat/output area (`outputPad`) and the status
+ * bar. Fills the key in only when absent — an explicit user choice (including
+ * 0) is never overwritten. Best-effort: a missing/corrupt settings file or a
+ * write failure must never block the launch.
+ */
+/**
+ * Seed `editorPaddingX` into the per-profile pi `settings.json` so the prompt
+ * input aligns with the chat/output area (`outputPad`) and the status bar.
+ *
+ * This writes to a user-owned file, so it is deliberately conservative:
+ *  - fills the key in ONLY when absent — an explicit user choice (including 0)
+ *    is never overwritten;
+ *  - backs off on a missing-dir, corrupt, non-object, or symlinked settings
+ *    file rather than risk clobbering anything;
+ *  - writes ATOMICALLY (temp file + rename) and preserves the existing file's
+ *    permissions, so a crash mid-write can never truncate the user's settings.
+ * Any failure is swallowed: seeding must never block or break a launch.
+ */
+export function seedEditorPadding(piAgentDir) {
+    try {
+        const settingsPath = join(piAgentDir, "settings.json");
+        let settings = {};
+        let existingMode;
+        if (existsSync(settingsPath)) {
+            // Refuse to follow a symlink: we must only ever write a regular, real
+            // settings file the user (or pi) owns.
+            if (lstatSync(settingsPath).isSymbolicLink())
+                return;
+            let parsed;
+            try {
+                parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+            }
+            catch {
+                return; // corrupt file: back off rather than clobber the user's settings
+            }
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                return; // non-object settings: leave it alone
+            }
+            settings = parsed;
+            existingMode = lstatSync(settingsPath).mode & 0o777;
+        }
+        if (settings.editorPaddingX !== undefined)
+            return; // user already chose
+        settings.editorPaddingX = PAD_X;
+        // Atomic write: serialize to a temp file in the same directory, then
+        // rename over the target. A crash leaves either the old file or the temp
+        // file, never a half-written settings.json.
+        const tmpPath = join(piAgentDir, `.settings.json.yagni-${process.pid}-${Date.now()}.tmp`);
+        try {
+            writeFileSync(tmpPath, `${JSON.stringify(settings, null, 2)}\n`, { mode: 0o600 });
+            renameSync(tmpPath, settingsPath);
+        }
+        finally {
+            rmSync(tmpPath, { force: true }); // no-op once the rename succeeded
+        }
+        // Restore the original permissions if the file already had them (rename
+        // replaces the inode, which would otherwise reset to 0600).
+        if (existingMode !== undefined)
+            chmodSync(settingsPath, existingMode);
+    }
+    catch {
+        // never block launch on a settings-seed failure
+    }
+}
 async function runDefault(passthroughArgs) {
     // Cache-backed update nudge (never a network wait), then a background cache
     // refresh that completes while the session runs. Both fail soft.
@@ -72,6 +140,11 @@ async function runDefault(passthroughArgs) {
     // instead of ~/.pi/agent, and prod state never bleeds into staging.
     const piAgentDir = agentDir(profile.name);
     mkdirSync(piAgentDir, { recursive: true, mode: 0o700 });
+    // Seed the editor's horizontal padding so the prompt input aligns with the
+    // chat/output area and the status bar. Only fills in when the user has not
+    // set it themselves — an explicit choice is never clobbered. Best-effort: a
+    // corrupt or unreadable settings.json must never block the launch.
+    seedEditorPadding(piAgentDir);
     // Generate the shadow pi package so the terminal title/process name read
     // "YAGNI Code" instead of "pi"/"π". Best-effort: if it can't be built we
     // still launch (un-rebranded but hermetic), never blocking the agent.

package/dist/extension/footer.d.ts

@@ -40,6 +40,14 @@
  */
 import type { ExtensionContext, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
 export declare const BRANCH_MAX_WIDTH = 60;
+/**
+ * Resolve the status bar's left pad from the launcher's `YAGNI_PAD_X` env so it
+ * aligns with the editor input and the chat/output area on one shared column.
+ * The launcher seeds the same value as pi's `editorPaddingX`; this footer can't
+ * read pi settings, so the value crosses over env. Falls back to the output
+ * area's default (1) when unset/invalid. Clamped to pi's 0–3 editor range.
+ */
+export declare function resolveFooterPadX(raw?: string | undefined): number;
 /** Format token counts for compact footer display (mirrors pi's formatTokens). */
 export declare function formatTokens(count: number): string;
 /** Shorten cwd relative to home, like pi's built-in footer. */
@@ -85,7 +93,7 @@ export declare function renderFooterLines(input: {
     usage: UsageTotals;
     contextPercent: number | null;
     statuses: string[];
-}, theme: Pick<Theme, "fg">, width: number): string[];
+}, theme: Pick<Theme, "fg">, width: number, padX?: number): string[];
 /**
  * Create a footer factory that captures the session `ctx` (for session data)
  * and returns the component `setFooter` expects. Called from the

package/dist/extension/footer.js

@@ -46,6 +46,19 @@ export const BRANCH_MAX_WIDTH = 60;
 const WORKTREE_MAX_WIDTH = 30;
 /** Section separator: single space + middle dot + single space. */
 const SEP = " · ";
+/** Default horizontal pad when the launcher didn't forward one (matches outputPad=1). */
+const DEFAULT_PAD_X = 1;
+/**
+ * Resolve the status bar's left pad from the launcher's `YAGNI_PAD_X` env so it
+ * aligns with the editor input and the chat/output area on one shared column.
+ * The launcher seeds the same value as pi's `editorPaddingX`; this footer can't
+ * read pi settings, so the value crosses over env. Falls back to the output
+ * area's default (1) when unset/invalid. Clamped to pi's 0–3 editor range.
+ */
+export function resolveFooterPadX(raw = process.env.YAGNI_PAD_X) {
+    const n = raw === undefined ? NaN : Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n >= 0 && n <= 3 ? n : DEFAULT_PAD_X;
+}
 /** Format token counts for compact footer display (mirrors pi's formatTokens). */
 export function formatTokens(count) {
     if (count < 1000)
@@ -191,9 +204,14 @@ function contextColor(percent) {
     return "dim";
 }
 /** Pure line-builder, exported for tests. All data injected; colors via theme. */
-export function renderFooterLines(input, theme, width) {
+export function renderFooterLines(input, theme, width, padX = 0) {
     const dim = (s) => theme.fg("dim", s);
     const sep = dim(SEP);
+    // Reserve the left pad so the status bar's text starts on the same column as
+    // the (padded) editor input and the chat/output area, instead of hugging the
+    // terminal edge. Truncation runs against the reduced content width.
+    const pad = " ".repeat(Math.max(0, Math.min(3, Math.floor(padX))));
+    const contentWidth = Math.max(1, width - pad.length);
     // Line 1: folder · [worktree] · branch
     const line1Parts = [theme.fg("accent", input.git.folder)];
     if (input.git.inRepo) {
@@ -202,7 +220,7 @@ export function renderFooterLines(input, theme, width) {
         if (input.git.branch)
             line1Parts.push(theme.fg("border", truncateEnd(input.git.branch, BRANCH_MAX_WIDTH)));
     }
-    const line1 = truncateToWidth(line1Parts.join(sep), width, dim("…"));
+    const line1 = pad + truncateToWidth(line1Parts.join(sep), contentWidth, dim("…"));
     // Line 2: model · ↑in ↓out $cost · ctx%
     const statParts = [];
     if (input.usage.input)
@@ -217,12 +235,12 @@ export function renderFooterLines(input, theme, width) {
     if (stats)
         line2Parts.push(dim(stats));
     line2Parts.push(theme.fg(contextColor(input.contextPercent), percentText));
-    const line2 = truncateToWidth(line2Parts.join(sep), width, dim("…"));
+    const line2 = pad + truncateToWidth(line2Parts.join(sep), contentWidth, dim("…"));
     // Line 3: extension statuses (branding, todo counter, mode), joined by " · ".
     const statuses = input.statuses.map((s) => s.replace(/[\r\n\t]/g, " ").trim()).filter(Boolean);
     const lines = [line1, line2];
     if (statuses.length > 0) {
-        lines.push(truncateToWidth(dim(statuses.join(SEP)), width, dim("…")));
+        lines.push(pad + truncateToWidth(dim(statuses.join(SEP)), contentWidth, dim("…")));
     }
     return lines;
 }
@@ -258,7 +276,7 @@ export function createYagniFooterFactory(ctx) {
                     usage: collectUsage(ctx.sessionManager),
                     contextPercent: ctx.getContextUsage()?.percent ?? null,
                     statuses,
-                }, theme, width);
+                }, theme, width, resolveFooterPadX());
             },
             invalidate() {
                 gitCache = undefined;

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,6 +4,7 @@ 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";
@@ -126,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
@@ -225,6 +232,7 @@ export async function registerYagni(pi, deps = {}) {
                         ...DEFAULT_PERMISSION_POLICY.reviewConfirmTools,
                         ...mcpMutatingTools,
                     ],
+                    alwaysConfirmTools: DEFAULT_PERMISSION_POLICY.alwaysConfirmTools,
                 },
             }
             : {}),
@@ -556,6 +564,7 @@ export default async function (pi) {
     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/dist/launch.js

@@ -7,6 +7,7 @@
  */
 import { randomUUID } from "node:crypto";
 import { agentDirEnvVar } from "./branding.js";
+import { PAD_X_ENV, resolvePadX } from "./padding.js";
 /**
  * How close to expiry the token can be before launch warns. A coding session
  * easily outlives a token, so warn early enough that re-logging in before a long
@@ -95,6 +96,10 @@ export function buildLaunch(creds, passthroughArgs, opts) {
         // Match the e2b harness defaults: skip pi's update check + telemetry.
         PI_SKIP_VERSION_CHECK: "1",
         PI_TELEMETRY: "0",
+        // Forward the chosen horizontal pad so the extension's footer aligns with
+        // the editor (which the launcher pads by seeding editorPaddingX). The
+        // footer can't read pi's settings, so the value crosses over env.
+        [PAD_X_ENV]: String(resolvePadX()),
     };
     // Always load our extension. Default the provider to `yagni` unless the user
     // explicitly chose one (so power users can still point pi elsewhere).

package/dist/padding.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Single source of truth for the CLI's horizontal padding, shared by the
+ * launcher (which seeds the editor setting) and — via the `YAGNI_PAD_X` env the
+ * launcher forwards — pi-extension-yagni's footer.
+ *
+ * The value must match pi's `outputPad` (the chat/output area's left+right
+ * padding, which defaults to 1) so the input editor, the output stream, and
+ * the status bar all align on the same column. Keeping it in one module makes
+ * the coherence structural rather than eyeballed: change this one number and
+ * the editor, footer, and seeded default move together.
+ *
+ * Separators (the ─ rules above/below the input) intentionally stay full-bleed
+ * and are NOT padded — matching Claude Code's frame.
+ */
+export declare const PAD_X = 1;
+/** Left (and right) padding string applied to the editor and footer. */
+export declare const PAD_STR: string;
+/** Env var the launcher sets so the extension's footer can match the editor pad. */
+export declare const PAD_X_ENV = "YAGNI_PAD_X";
+/** Parse a pad width from the env override, falling back to {@link PAD_X}. */
+export declare function resolvePadX(raw?: string | undefined): number;
+//# sourceMappingURL=padding.d.ts.map

package/dist/padding.js

@@ -0,0 +1,25 @@
+/**
+ * Single source of truth for the CLI's horizontal padding, shared by the
+ * launcher (which seeds the editor setting) and — via the `YAGNI_PAD_X` env the
+ * launcher forwards — pi-extension-yagni's footer.
+ *
+ * The value must match pi's `outputPad` (the chat/output area's left+right
+ * padding, which defaults to 1) so the input editor, the output stream, and
+ * the status bar all align on the same column. Keeping it in one module makes
+ * the coherence structural rather than eyeballed: change this one number and
+ * the editor, footer, and seeded default move together.
+ *
+ * Separators (the ─ rules above/below the input) intentionally stay full-bleed
+ * and are NOT padded — matching Claude Code's frame.
+ */
+export const PAD_X = 1;
+/** Left (and right) padding string applied to the editor and footer. */
+export const PAD_STR = " ".repeat(PAD_X);
+/** Env var the launcher sets so the extension's footer can match the editor pad. */
+export const PAD_X_ENV = "YAGNI_PAD_X";
+/** Parse a pad width from the env override, falling back to {@link PAD_X}. */
+export function resolvePadX(raw = process.env[PAD_X_ENV]) {
+    const n = raw === undefined ? NaN : Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n >= 0 && n <= 3 ? n : PAD_X;
+}
+//# sourceMappingURL=padding.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "0.2.1-staging.1034.1",
+  "version": "0.2.1-staging.1039.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": "18b902bf72fff144de95d7949d32025875798a1e"
+  "yagniSourceSha": "82c8e819af017a1a2c5c93aea5b4f96690f267d3"
 }