@pugi/cli 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/runtime/commands/model.js

@@ -0,0 +1,237 @@
+/**
+ * `/model` / `pugi model` — Wave 6 BT 8 (Claude Code parity).
+ *
+ * Lists OR selects the active model. The MVP uses a hardcoded
+ * tier-aware registry mirrored from the per-model price ladder in
+ * `core/repl/model-pricing.ts` so the operator sees the same models
+ * the cost meter understands. A future iteration can swap the static
+ * registry for an admin-api `GET /api/pugi/models` round-trip — the
+ * runner contract (`MODEL_REGISTRY` + `runModelCommand`) is the right
+ * shape for that swap because the renderer + writer paths are
+ * decoupled from the source.
+ *
+ * Persistence lands at `<workspaceRoot>/.pugi/settings.json` under a
+ * top-level `model.slug` key. We extend the file directly with a
+ * round-trip read-merge-write so we do not invalidate the existing
+ * Zod schema in `core/settings.ts` — the schema there reads only the
+ * keys it knows about, leaving `model.*` as a forward-compatible
+ * passthrough.
+ *
+ * Tier gating mirrors the four-tier pricing (Free / Founder $20 /
+ * Builder $99 / Team $199). The slugs here are the same ones the
+ * cost meter renders, so the operator can always swap to a cheaper
+ * fallback if they hit a quota wall.
+ */
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+/**
+ * Tier rank for comparing "user tier >= model.minTier". The order is
+ * Free < Founder < Builder < Team. The cabinet's pricing module owns
+ * the canonical pricing copy; the CLI just needs the rank to filter
+ * the menu.
+ */
+export const TIER_RANK = Object.freeze({
+    free: 0,
+    founder: 1,
+    builder: 2,
+    team: 3,
+});
+/**
+ * Static model registry. Sources:
+ *   - Anthropic Claude family (claude-opus, claude-sonnet, claude-haiku):
+ *     2026-05-26 list prices.
+ *   - OpenAI (gpt-4o, gpt-4o-mini, o3, o3-mini): 2026-05-26 list prices.
+ *   - Mistral (mistral-large, mistral-small): 2026-05-26 list prices.
+ *
+ * Family fallbacks (`claude-opus-4-7` falling back onto the
+ * `claude-opus-` family entry in `model-pricing.ts`) live in the price
+ * ladder, not here — the registry is the canonical selectable surface.
+ */
+export const MODEL_REGISTRY = Object.freeze([
+    // Free tier — cheap defaults so the meter never blanks on a fresh signup.
+    {
+        slug: 'claude-haiku-4-5',
+        label: 'Claude Haiku 4.5',
+        minTier: 'free',
+        inputUsdPerM: 0.8,
+        outputUsdPerM: 4.0,
+        summary: 'Fast + cheap. Default for quick dispatches and the free tier.',
+    },
+    {
+        slug: 'gpt-4o-mini',
+        label: 'GPT-4o mini',
+        minTier: 'free',
+        inputUsdPerM: 0.15,
+        outputUsdPerM: 0.6,
+        summary: 'Cheapest mainstream model. Good for short turns.',
+    },
+    // Founder ($20) — mid-tier mainstream models.
+    {
+        slug: 'claude-sonnet-4-6',
+        label: 'Claude Sonnet 4.6',
+        minTier: 'founder',
+        inputUsdPerM: 3.0,
+        outputUsdPerM: 15.0,
+        summary: 'Balanced for code dispatch. Strong tool use.',
+    },
+    {
+        slug: 'gpt-4o',
+        label: 'GPT-4o',
+        minTier: 'founder',
+        inputUsdPerM: 2.5,
+        outputUsdPerM: 10.0,
+        summary: 'Multimodal-capable. Good general-purpose flagship.',
+    },
+    // Builder ($99) — mid-strong reasoning + Mistral options.
+    {
+        slug: 'o3-mini',
+        label: 'OpenAI o3-mini',
+        minTier: 'builder',
+        inputUsdPerM: 1.1,
+        outputUsdPerM: 4.4,
+        summary: 'Cheaper reasoning. Good for plan/review turns.',
+    },
+    {
+        slug: 'mistral-large',
+        label: 'Mistral Large',
+        minTier: 'builder',
+        inputUsdPerM: 2.0,
+        outputUsdPerM: 6.0,
+        summary: 'Strong open-weight reasoning. EU-hosted option.',
+    },
+    // Team ($199) — top-tier reasoning.
+    {
+        slug: 'claude-opus-4-7',
+        label: 'Claude Opus 4.7',
+        minTier: 'team',
+        inputUsdPerM: 15.0,
+        outputUsdPerM: 75.0,
+        summary: 'Flagship reasoning. Best for hard refactors + multi-file edits.',
+    },
+    {
+        slug: 'o3',
+        label: 'OpenAI o3',
+        minTier: 'team',
+        inputUsdPerM: 10.0,
+        outputUsdPerM: 40.0,
+        summary: 'Strong reasoning + deliberation. Good for plan/critique loops.',
+    },
+]);
+/** Returns the registry filtered to models the operator's tier can use. */
+export function modelsForTier(tier) {
+    const rank = TIER_RANK[tier];
+    return MODEL_REGISTRY.filter((m) => TIER_RANK[m.minTier] <= rank);
+}
+/** Looks up a descriptor by slug. */
+export function lookupModel(slug) {
+    return MODEL_REGISTRY.find((m) => m.slug === slug);
+}
+/**
+ * Entry point for the slash + the top-level CLI. Side effects:
+ *   - command.slug undefined: prints the tier-gated menu + current row.
+ *   - command.slug set + unknown: prints a one-line error.
+ *   - command.slug set + above tier: prints a tier-lock message.
+ *   - command.slug set + valid + reachable: merges `model.slug` into
+ *     <workspaceRoot>/.pugi/settings.json and prints a confirmation.
+ *
+ * The function never throws on a missing settings file — it creates
+ * `.pugi/` + writes a fresh object. Read failures (malformed JSON) are
+ * surfaced as a system line + the runner refuses to write so the
+ * operator can recover by hand.
+ */
+export async function runModelCommand(command, ctx) {
+    const tier = ctx.tier ?? 'team';
+    const fs = ctx.fs ?? defaultFs(ctx.workspaceRoot);
+    if (command.slug === undefined) {
+        return renderMenu(ctx, fs, tier);
+    }
+    const descriptor = lookupModel(command.slug);
+    if (!descriptor) {
+        ctx.writeOutput(`/model: unknown slug '${command.slug}'. Run /model to see the menu.`);
+        return { command: 'model', status: 'unknown_slug', reason: command.slug };
+    }
+    if (TIER_RANK[descriptor.minTier] > TIER_RANK[tier]) {
+        ctx.writeOutput(`/model: '${descriptor.slug}' requires the ${descriptor.minTier} tier. `
+            + `You are on '${tier}'. Run /model to see available options.`);
+        return { command: 'model', status: 'tier_locked', slug: descriptor.slug };
+    }
+    // Merge + persist. Any IO error becomes a one-line warning; the
+    // session continues without crashing.
+    try {
+        const current = fs.readSettings() ?? {};
+        const nextSettings = {
+            ...current,
+            model: {
+                ...(typeof current.model === 'object' && current.model !== null
+                    ? current.model
+                    : {}),
+                slug: descriptor.slug,
+            },
+        };
+        fs.writeSettings(nextSettings);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.writeOutput(`/model: persist failed — ${message}. Selection is session-only.`);
+    }
+    ctx.writeOutput(`Model set to '${descriptor.label}' (${descriptor.slug}). ` +
+        `Cost: $${descriptor.inputUsdPerM.toFixed(2)}/M in, $${descriptor.outputUsdPerM.toFixed(2)}/M out.`);
+    return { command: 'model', status: 'selected', slug: descriptor.slug };
+}
+function renderMenu(ctx, fs, tier) {
+    const current = readCurrentSlug(fs);
+    const visible = modelsForTier(tier);
+    ctx.writeOutput(`Current model: ${current ?? '(unset, default)'}.  Your tier: ${tier}.`);
+    ctx.writeOutput('');
+    ctx.writeOutput('Available models:');
+    for (const m of visible) {
+        const mark = current === m.slug ? '*' : ' ';
+        const price = `$${m.inputUsdPerM.toFixed(2)}/M in, $${m.outputUsdPerM.toFixed(2)}/M out`;
+        ctx.writeOutput(`  ${mark} ${m.slug.padEnd(22)}  ${m.label.padEnd(22)}  ${price}`);
+        ctx.writeOutput(`    ${m.summary}`);
+    }
+    const locked = MODEL_REGISTRY.filter((m) => TIER_RANK[m.minTier] > TIER_RANK[tier]);
+    if (locked.length > 0) {
+        ctx.writeOutput('');
+        ctx.writeOutput(`Higher-tier models (upgrade required):`);
+        for (const m of locked) {
+            ctx.writeOutput(`  - ${m.slug} (${m.minTier})`);
+        }
+    }
+    ctx.writeOutput('');
+    ctx.writeOutput('Switch with `/model <slug>`. The choice persists to .pugi/settings.json.');
+    return { command: 'model', status: 'listed', slug: current ?? undefined };
+}
+function readCurrentSlug(fs) {
+    try {
+        const data = fs.readSettings();
+        if (!data || typeof data !== 'object')
+            return null;
+        const model = data.model;
+        if (!model || typeof model !== 'object')
+            return null;
+        const slug = model.slug;
+        return typeof slug === 'string' && slug.length > 0 ? slug : null;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultFs(workspaceRoot) {
+    const path = resolve(workspaceRoot, '.pugi/settings.json');
+    return {
+        readSettings: () => {
+            if (!existsSync(path))
+                return null;
+            const raw = readFileSync(path, 'utf8');
+            if (raw.trim().length === 0)
+                return null;
+            return JSON.parse(raw);
+        },
+        writeSettings: (next) => {
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, JSON.stringify(next, null, 2) + '\n', 'utf8');
+        },
+    };
+}
+//# sourceMappingURL=model.js.map

package/dist/runtime/commands/onboarding.js

@@ -0,0 +1,275 @@
+/**
+ * Leak L25 (2026-05-27) — `pugi onboarding` first-run wizard runner.
+ *
+ * Six-step interactive walk that lands a new operator on a configured
+ * Pugi:
+ *
+ *   1. Welcome + auth status     — suggests `pugi login` when no creds
+ *   2. Default permission mode   — plan / ask / allow / bypass (L6)
+ *   3. Output style              — default / terse / explanatory /
+ *                                  russian-formal / casual (L18)
+ *   4. MCP server pointer        — link to `pugi mcp add` (L13)
+ *   5. Telemetry consent         — off / anonymous / community
+ *   6. Recap card + marker touch — `pugi doctor` next-step hint
+ *
+ * Two execution modes:
+ *
+ *   - **Interactive (TTY + no `--non-interactive` flag)** — mount the
+ *     Ink wizard (`tui/onboarding-wizard.tsx`) and await the
+ *     operator's verdict step by step. The wizard returns a structured
+ *     `OnboardingVerdict` describing each chosen value (or "skip"
+ *     when the operator pressed Enter on the current-value row).
+ *
+ *   - **Non-interactive (CI, pipes, `--non-interactive`, `--json`)** —
+ *     skip the Ink mount. Print the current values + the wizard tip
+ *     so a scripted caller sees the structured envelope without an
+ *     unresponsive raw-mode prompt.
+ *
+ * Idempotency:
+ *
+ *   - Re-running the wizard reads the CURRENT persisted values (L6
+ *     `getGlobalDefaultMode`, L18 `resolveOutputStyle`, this module's
+ *     telemetry-state) and surfaces them as the highlighted row, so
+ *     pressing Enter on each step is a no-op.
+ *
+ *   - The marker file (`~/.pugi/.onboarded`) is touched on every
+ *     successful completion. The marker existence is what suppresses
+ *     the first-run hint on bare `pugi`; resetting it via
+ *     `pugi onboarding --reset` re-arms the hint without nuking
+ *     persisted values.
+ *
+ * Exit codes:
+ *   0 — wizard completed (interactive OR non-interactive path)
+ *   0 — `--reset` cleared the marker
+ *   2 — conflicting flags (e.g. `--reset` + a verdict flag)
+ *
+ * Exit code 0 for non-interactive is intentional: a CI caller running
+ * `pugi onboarding --non-interactive` to dump the current state should
+ * not see a non-zero rc; failures (fs EIO, unknown flag) raise to the
+ * caller via thrown errors which `runtime/cli.ts` catches.
+ */
+import { DEFAULT_PERMISSION_MODE, PERMISSION_MODES, PERMISSION_MODE_GLOSS, getGlobalDefaultMode, setGlobalDefaultMode, } from '../../core/permissions/index.js';
+import { OUTPUT_STYLES, OUTPUT_STYLE_SLUGS, } from '../../core/output-style/presets.js';
+import { resolveOutputStyle, setUserOutputStyle, } from '../../core/output-style/state.js';
+import { clearOnboarded, isOnboarded, markOnboarded, } from '../../core/onboarding/marker.js';
+import { TELEMETRY_CHOICES, readTelemetryChoice, writeTelemetryChoice, } from '../../core/onboarding/telemetry-state.js';
+/**
+ * Entry point. Parses argv, resolves the snapshot, optionally drives
+ * the wizard, writes verdicts to the L6 / L18 / telemetry tiers,
+ * touches the marker, and emits a single structured payload via
+ * `writeOutput`.
+ */
+export async function runOnboardingCommand(args, ctx) {
+    const flags = parseFlags(args);
+    if (flags === null) {
+        const snapshot = readSnapshot(ctx);
+        ctx.writeOutput(buildPayload({
+            status: 'invalid_flags',
+            before: snapshot,
+            after: snapshot,
+            hints: [],
+            message: invalidFlagsMessage(args),
+        }), invalidFlagsMessage(args));
+        return 2;
+    }
+    if (flags.reset) {
+        const before = readSnapshot(ctx);
+        clearOnboarded(ctx.env ?? process.env);
+        const after = readSnapshot(ctx);
+        const message = 'Onboarding marker cleared. Run `pugi onboarding` to walk the wizard again.';
+        ctx.writeOutput(buildPayload({
+            status: 'reset',
+            before,
+            after,
+            hints: [],
+            message,
+        }), `${message}\n`);
+        return 0;
+    }
+    const before = readSnapshot(ctx);
+    if (!ctx.interactive || flags.nonInteractive) {
+        const text = renderSnapshotCard(before, {
+            heading: 'Pugi onboarding — current configuration',
+            footer: 'Re-run `pugi onboarding` from a real terminal to walk the wizard interactively.',
+        });
+        ctx.writeOutput(buildPayload({
+            status: 'non_interactive',
+            before,
+            after: before,
+            hints: buildHints(before),
+            message: text,
+        }), `${text}\n`);
+        return 0;
+    }
+    const verdict = await invokeWizard(ctx, before);
+    if (verdict.cancelled) {
+        const text = 'Onboarding cancelled. No changes written.';
+        ctx.writeOutput(buildPayload({
+            status: 'cancelled',
+            before,
+            after: before,
+            hints: buildHints(before),
+            message: text,
+        }), `${text}\n`);
+        return 0;
+    }
+    applyVerdict(verdict, ctx);
+    markOnboarded(ctx.env ?? process.env);
+    const after = readSnapshot(ctx);
+    const text = renderSnapshotCard(after, {
+        heading: 'Setup complete.',
+        footer: 'Run `pugi doctor` to verify your environment.',
+    });
+    ctx.writeOutput(buildPayload({
+        status: 'completed',
+        before,
+        after,
+        hints: buildHints(after),
+        message: text,
+    }), `${text}\n`);
+    return 0;
+}
+/**
+ * Pure snapshot reader. Called twice per invocation (before + after)
+ * so the payload can surface the diff a scripted caller would see.
+ */
+export function readSnapshot(ctx) {
+    const permissionMode = getGlobalDefaultMode(ctx.homeDir) ?? DEFAULT_PERMISSION_MODE;
+    const styleResolution = resolveOutputStyle({
+        workspaceRoot: ctx.workspaceRoot,
+        env: ctx.env ?? process.env,
+    });
+    const telemetry = readTelemetryChoice({ env: ctx.env ?? process.env });
+    const previouslyOnboarded = isOnboarded(ctx.env ?? process.env);
+    return {
+        authPresent: ctx.authPresent,
+        permissionMode,
+        outputStyle: styleResolution.slug,
+        outputStyleSource: styleResolution.source,
+        telemetry,
+        previouslyOnboarded,
+    };
+}
+/**
+ * Apply the wizard's verdict. Each step is independent — operator can
+ * skip individual steps (verdict.X === null) and only the non-null
+ * values write through to disk.
+ */
+function applyVerdict(verdict, ctx) {
+    if (verdict.permissionMode !== null) {
+        setGlobalDefaultMode(verdict.permissionMode, ctx.homeDir);
+    }
+    if (verdict.outputStyle !== null) {
+        setUserOutputStyle(verdict.outputStyle, {
+            workspaceRoot: ctx.workspaceRoot,
+            env: ctx.env ?? process.env,
+        });
+    }
+    if (verdict.telemetry !== null) {
+        writeTelemetryChoice(verdict.telemetry, { env: ctx.env ?? process.env });
+    }
+}
+/**
+ * Render the recap card surfaced both as the Step 6 exit screen and
+ * as the non-interactive snapshot dump.
+ */
+export function renderSnapshotCard(snapshot, opts) {
+    const styleGloss = OUTPUT_STYLES[snapshot.outputStyle].gloss;
+    const modeGloss = PERMISSION_MODE_GLOSS[snapshot.permissionMode];
+    const telemetryGloss = TELEMETRY_GLOSS[snapshot.telemetry];
+    const authLine = snapshot.authPresent
+        ? 'Signed in (run `pugi whoami` for details).'
+        : 'Not signed in. Run `pugi login` to authenticate.';
+    const lines = [
+        opts.heading,
+        '',
+        `  Auth:            ${authLine}`,
+        `  Permission mode: ${snapshot.permissionMode}  —  ${modeGloss}`,
+        `  Output style:    ${snapshot.outputStyle} (${snapshot.outputStyleSource})  —  ${styleGloss}`,
+        `  Telemetry:       ${snapshot.telemetry}  —  ${telemetryGloss}`,
+        `  MCP servers:     add via \`pugi mcp add <name> <command>\``,
+        '',
+        opts.footer,
+    ];
+    return lines.join('\n');
+}
+/**
+ * Build the hint list — auth pointer + re-onboarding tip. Hints are
+ * structured (in the payload) so a JSON caller can dispatch on them.
+ */
+function buildHints(snapshot) {
+    const hints = [];
+    if (!snapshot.authPresent) {
+        hints.push('Run `pugi login` to sign in. Pugi works offline-first but auth unlocks the engine + sync.');
+    }
+    if (snapshot.previouslyOnboarded) {
+        hints.push('You have onboarded before — re-running the wizard is safe; Enter on any step keeps the current value.');
+    }
+    hints.push('Run `pugi doctor` to verify your environment.');
+    hints.push('Add MCP servers with `pugi mcp add` or list them via `pugi mcp list`.');
+    return Object.freeze(hints);
+}
+/**
+ * Drive the wizard. Production callers leave `ctx.promptWizard`
+ * undefined, in which case we dynamic-import the Ink wizard so the
+ * command module stays free of the React/Ink module graph on the
+ * non-interactive path. Specs inject a stub.
+ */
+async function invokeWizard(ctx, snapshot) {
+    if (ctx.promptWizard) {
+        return ctx.promptWizard(snapshot);
+    }
+    const { renderOnboardingWizard } = await import('../../tui/onboarding-wizard.js');
+    return renderOnboardingWizard({ snapshot });
+}
+/**
+ * Flag parser. Returns `null` on conflicting flags so the runner can
+ * emit `invalid_flags` + rc=2 without a thrown error.
+ */
+function parseFlags(args) {
+    let reset = false;
+    let nonInteractive = false;
+    for (const arg of args) {
+        if (arg === '--reset') {
+            reset = true;
+        }
+        else if (arg === '--non-interactive' || arg === '--no-tty') {
+            nonInteractive = true;
+        }
+        else {
+            return null;
+        }
+    }
+    // `--reset` + `--non-interactive` is redundant but not conflicting — reset wins.
+    // No other combinations are illegal at the moment.
+    return { reset, nonInteractive };
+}
+function invalidFlagsMessage(args) {
+    return [
+        `pugi onboarding: unknown flag in \`${args.join(' ')}\`.`,
+        'Usage: pugi onboarding [--reset] [--non-interactive]',
+    ].join('\n');
+}
+/**
+ * One-line gloss per telemetry choice — surfaced in the recap card.
+ * Mirrors the brand voice (no hedging, operator-grade).
+ */
+const TELEMETRY_GLOSS = Object.freeze({
+    off: 'No telemetry of any kind.',
+    anonymous: 'Counts + error categories only; no payloads.',
+    community: 'Anonymous + opt-in usage panels.',
+});
+function buildPayload(input) {
+    return {
+        command: 'onboarding',
+        status: input.status,
+        snapshotBefore: input.before,
+        snapshotAfter: input.after,
+        permissionModes: PERMISSION_MODES,
+        outputStyles: OUTPUT_STYLE_SLUGS,
+        telemetryChoices: TELEMETRY_CHOICES,
+        hints: input.hints,
+        message: input.message,
+    };
+}
+//# sourceMappingURL=onboarding.js.map

package/dist/runtime/commands/patch.js

@@ -36,12 +36,20 @@ const SECURITY_REASONS = new Set(['path_outside_workspace', 'protected_file', 's
 export async function runPatchCommand(args, opts) {
     const positional = [];
     const applyOpts = {};
+    // Seed from caller-supplied options first; arg-flag parsing below
+    // overrides when present.
+    if (opts.dryRun)
+        applyOpts.dryRun = true;
+    if (opts.baseSha)
+        applyOpts.baseSha = opts.baseSha;
+    let threeWaySeen = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i] ?? '';
         if (arg === '--dry-run')
             applyOpts.dryRun = true;
         else if (arg === '--3way') {
             // honored only when --base is also supplied
+            threeWaySeen = true;
         }
         else if (arg === '--base') {
             const next = args[i + 1];
@@ -59,6 +67,15 @@ export async function runPatchCommand(args, opts) {
             positional.push(arg);
         }
     }
+    // R1 fix (2026-05-26, PR #413 r1, P2 #14): `--3way` without `--base`
+    // is meaningless because `git apply --3way` falls back to the index,
+    // which a CLI-side `pugi patch` invocation does not have populated
+    // with the patch's pre-image. Warn the operator instead of dropping
+    // the flag silently.
+    if (threeWaySeen && !applyOpts.baseSha) {
+        const warn = opts.warn ?? ((m) => console.warn(m));
+        warn('warning: --3way ignored without --base=<sha>; pass --base or drop --3way');
+    }
     let patch;
     try {
         patch = await readPatchSource(positional[0], opts);

package/dist/runtime/commands/permissions.js

@@ -0,0 +1,87 @@
+/**
+ * `pugi permissions` / `/permissions` — Leak L6 4-mode gate control.
+ *
+ * Two entry points share one runtime helper:
+ *   1. `/permissions` in the REPL — forwarded by `core/repl/session.ts`.
+ *   2. `pugi permissions ...` top-level CLI command (handler in
+ *      `runtime/cli.ts`).
+ *
+ * Both pass a `PermissionsCommand` payload describing the operator
+ * intent (show / flip / persist) and a `writeOutput` callback that
+ * lets the caller route the rendered lines into the right surface
+ * (REPL transcript vs. stdout). The helper is intentionally I/O-free
+ * itself — it produces lines and lets the caller stream them.
+ */
+import { DEFAULT_PERMISSION_MODE, PERMISSION_MODES, PERMISSION_MODE_GLOSS, getCurrentMode, getGlobalDefaultMode, setCurrentMode, setGlobalDefaultMode, } from '../../core/permissions/index.js';
+/**
+ * Run the `/permissions` or `pugi permissions` flow. Side effects:
+ *   - When `command.mode` is undefined: prints the current mode + the
+ *     4-mode table (no writes).
+ *   - When `command.mode === 'bypass'` without `confirmBypass`: prints
+ *     a refusal + the safety copy, no writes.
+ *   - When `command.mode` is set + valid: writes workspace session
+ *     state; optionally writes global default when `persist` is true.
+ *   - Always prints the new effective mode + a one-line confirmation.
+ */
+export async function runPermissionsCommand(command, ctx) {
+    if (!command.mode) {
+        renderCurrentMode(ctx);
+        renderModeTable(ctx);
+        return;
+    }
+    if (command.mode === 'bypass' && !command.confirmBypass) {
+        ctx.writeOutput('Bypass mode disables policy hooks (skill steering, denial tracking).');
+        ctx.writeOutput('Run `/permissions bypass --confirm` to acknowledge before flipping.');
+        return;
+    }
+    setCurrentMode(ctx.workspaceRoot, command.mode);
+    if (command.persist) {
+        setGlobalDefaultMode(command.mode, ctx.homeDir);
+    }
+    const persistedHint = command.persist
+        ? ' Persisted to ~/.pugi/config.json for future sessions.'
+        : '';
+    ctx.writeOutput(`Permission mode set to '${command.mode}'.${persistedHint} ${PERMISSION_MODE_GLOSS[command.mode]}`);
+    if (command.mode === 'bypass') {
+        ctx.writeOutput('BYPASS MODE — all tools execute without prompts AND policy hooks disabled. Switch back with /permissions allow.');
+    }
+}
+/**
+ * Print the resolved current mode + the layered source. The merge
+ * order mirrors `resolveMode()`: workspace > global > default.
+ */
+function renderCurrentMode(ctx) {
+    const workspace = getCurrentMode(ctx.workspaceRoot);
+    const global = getGlobalDefaultMode(ctx.homeDir);
+    const effective = workspace ?? global ?? DEFAULT_PERMISSION_MODE;
+    const source = workspace
+        ? 'workspace session.json'
+        : global
+            ? 'global ~/.pugi/config.json'
+            : 'default (no override)';
+    ctx.writeOutput(`Current permission mode: ${effective} (source: ${source})`);
+}
+/**
+ * Print the 4-mode reference table. Keeps the gloss + the side-effect
+ * matrix in one place so the operator can see the contract while they
+ * decide which mode to switch to.
+ */
+function renderModeTable(ctx) {
+    ctx.writeOutput('');
+    ctx.writeOutput('Permission modes:');
+    for (const mode of PERMISSION_MODES) {
+        ctx.writeOutput(`  ${mode.padEnd(7)}  ${PERMISSION_MODE_GLOSS[mode]}`);
+    }
+    ctx.writeOutput('');
+    ctx.writeOutput('Switch with `/permissions <mode> [--persist]`. Bypass requires `--confirm`.');
+}
+/**
+ * Render the one-shot banner shown on session boot when the effective
+ * mode is `bypass`. The caller (engine adapter / REPL bootstrap) calls
+ * this once per session — repeated invocations are idempotent in copy
+ * but the caller is responsible for the once-only semantics.
+ */
+export function renderBypassBanner(writeOutput) {
+    writeOutput('BYPASS MODE — all tools execute without prompts AND policy hooks disabled. Switch back with /permissions allow.');
+}
+//# sourceMappingURL=permissions.js.map