wotann 0.5.74 → 0.5.80

package/dist/affordances/checks.js

@@ -0,0 +1,93 @@
+import { findDesktopPaletteAffordanceDrift, findDesktopShortcutAffordanceDrift, findDesktopTrayAffordanceDrift, findRpcAffordanceDrift, findSlashAffordanceDrift, findToolAffordanceDrift, listAgentToolNames, listAppV3SlashCommandIds, listDesktopPaletteCommandIds, listDesktopShortcutIds, listDesktopTrayActionIds, } from "./registry.js";
+import { buildKairosRpcAffordances, listKairosRpcMethods } from "./runtime-rpc.js";
+export function runAffordanceChecks(options = {}) {
+    const slashCommands = options.actualSlashCommands ?? listAppV3SlashCommandIds();
+    const toolNames = options.actualToolNames ?? listAgentToolNames();
+    const desktopPaletteCommandIds = options.actualDesktopPaletteCommandIds ?? listDesktopPaletteCommandIds();
+    const desktopShortcutIds = options.actualDesktopShortcutIds ?? listDesktopShortcutIds();
+    const desktopTrayActionIds = options.actualDesktopTrayActionIds ?? listDesktopTrayActionIds();
+    const rpcMethods = options.actualRpcMethods ?? listKairosRpcMethods();
+    const slashDrift = findSlashAffordanceDrift(slashCommands);
+    const toolDrift = findToolAffordanceDrift(toolNames);
+    const desktopPaletteDrift = findDesktopPaletteAffordanceDrift(desktopPaletteCommandIds);
+    const desktopShortcutDrift = findDesktopShortcutAffordanceDrift(desktopShortcutIds);
+    const desktopTrayDrift = findDesktopTrayAffordanceDrift(desktopTrayActionIds);
+    const rpcDrift = findRpcAffordanceDrift(rpcMethods, buildKairosRpcAffordances(rpcMethods));
+    const checks = [
+        slashRouterCoverageCheck(slashDrift),
+        agentToolCoverageCheck(toolDrift),
+        desktopPaletteCoverageCheck(desktopPaletteDrift),
+        desktopShortcutCoverageCheck(desktopShortcutDrift),
+        desktopTrayCoverageCheck(desktopTrayDrift),
+        daemonRpcCoverageCheck(rpcDrift),
+    ];
+    return {
+        passed: checks.every((check) => check.passed),
+        checks,
+    };
+}
+export function renderAffordanceCheckSummary(summary) {
+    const lines = [];
+    for (const check of summary.checks) {
+        lines.push(`${check.passed ? "PASS" : "FAIL"}  ${check.id}  ${check.title}`);
+        for (const failure of check.failures)
+            lines.push(`  missing: ${failure}`);
+        for (const warning of check.warnings)
+            lines.push(`  warning: ${warning}`);
+    }
+    return lines.join("\n");
+}
+function slashRouterCoverageCheck(drift) {
+    return {
+        id: "tui.slash.router-coverage",
+        title: "Every AppV3 slash-router command has a registered slash affordance",
+        passed: drift.missing.length === 0,
+        failures: drift.missing,
+        warnings: drift.orphaned,
+    };
+}
+function agentToolCoverageCheck(drift) {
+    return {
+        id: "agent.tools.registry-coverage",
+        title: "Every agent-loop tool definition has registered tool affordances",
+        passed: drift.missing.length === 0,
+        failures: drift.missing,
+        warnings: drift.orphaned,
+    };
+}
+function desktopPaletteCoverageCheck(drift) {
+    return {
+        id: "desktop.palette.registry-coverage",
+        title: "Every default desktop command-palette command has a registered palette affordance",
+        passed: drift.missing.length === 0,
+        failures: drift.missing,
+        warnings: drift.orphaned,
+    };
+}
+function desktopShortcutCoverageCheck(drift) {
+    return {
+        id: "desktop.shortcuts.registry-coverage",
+        title: "Every default desktop keyboard shortcut has a registered shortcut affordance",
+        passed: drift.missing.length === 0,
+        failures: drift.missing,
+        warnings: drift.orphaned,
+    };
+}
+function desktopTrayCoverageCheck(drift) {
+    return {
+        id: "desktop.tray.registry-coverage",
+        title: "Every default desktop tray quick action has a registered tray affordance",
+        passed: drift.missing.length === 0,
+        failures: drift.missing,
+        warnings: drift.orphaned,
+    };
+}
+function daemonRpcCoverageCheck(drift) {
+    return {
+        id: "daemon.rpc.registry-coverage",
+        title: "Every live KAIROS RPC handler is generated into the daemon RPC affordance list",
+        passed: drift.missing.length === 0,
+        failures: drift.missing,
+        warnings: drift.orphaned,
+    };
+}

package/dist/affordances/registry.d.ts

@@ -0,0 +1,46 @@
+export type AffordanceSurface = "cli" | "tui" | "desktop" | "ios" | "android" | "mcp" | "daemon";
+export type AffordanceKind = "command" | "slash" | "palette" | "menu" | "shortcut" | "tray" | "rpc" | "tool";
+export interface AffordanceRoute {
+    readonly surface: AffordanceSurface;
+    readonly kind: AffordanceKind;
+    readonly command?: string;
+    readonly path?: string;
+    readonly os?: readonly ("macos" | "linux" | "windows" | "ios" | "android")[];
+}
+export interface AffordanceEntry {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string;
+    readonly category: string;
+    readonly routes: readonly AffordanceRoute[];
+    readonly internalOnly?: boolean;
+}
+export interface AffordanceFilter {
+    readonly surface?: AffordanceSurface;
+    readonly kind?: AffordanceKind;
+    readonly includeInternal?: boolean;
+}
+export interface AffordanceDrift {
+    readonly missing: readonly string[];
+    readonly orphaned: readonly string[];
+}
+export interface SlashPromptSuggestion {
+    readonly cmd: string;
+    readonly desc: string;
+}
+export declare const AFFORDANCE_REGISTRY: readonly AffordanceEntry[];
+export declare function listAffordances(filter?: AffordanceFilter): readonly AffordanceEntry[];
+export declare function buildSlashPromptSuggestions(): readonly SlashPromptSuggestion[];
+export declare function listAppV3SlashCommandIds(): readonly string[];
+export declare function listAgentToolNames(): readonly string[];
+export declare function listDesktopPaletteCommandIds(): readonly string[];
+export declare function listDesktopShortcutIds(): readonly string[];
+export declare function listDesktopTrayActionIds(): readonly string[];
+export declare function normalizeSlashUsage(usage: string): string;
+export declare function renderAffordanceList(entries: readonly AffordanceEntry[]): string;
+export declare function findSlashAffordanceDrift(actualSlashCommandIds: readonly string[], registryEntries?: readonly AffordanceEntry[]): AffordanceDrift;
+export declare function findToolAffordanceDrift(actualToolNames: readonly string[], registryEntries?: readonly AffordanceEntry[]): AffordanceDrift;
+export declare function findDesktopPaletteAffordanceDrift(actualPaletteCommandIds: readonly string[], registryEntries?: readonly AffordanceEntry[]): AffordanceDrift;
+export declare function findDesktopShortcutAffordanceDrift(actualShortcutIds: readonly string[], registryEntries?: readonly AffordanceEntry[]): AffordanceDrift;
+export declare function findDesktopTrayAffordanceDrift(actualTrayActionIds: readonly string[], registryEntries?: readonly AffordanceEntry[]): AffordanceDrift;
+export declare function findRpcAffordanceDrift(actualRpcMethods: readonly string[], registryEntries: readonly AffordanceEntry[]): AffordanceDrift;

package/dist/affordances/registry.js

@@ -0,0 +1,283 @@
+import { CODEX_PARITY_COMMANDS } from "../ui/slash-commands/handlers/codex-parity.js";
+import { CROSS_SURFACE_COMMANDS } from "../ui/slash-commands/handlers/cross-surface.js";
+import { TERMINAL_COMMANDS } from "../ui/slash-commands/handlers/terminal.js";
+import { buildV3IntrinsicCommands } from "../ui/slash-commands/handlers/v3-intrinsics.js";
+import { createSlashRouter } from "../ui/slash-commands/index.js";
+import { AGENT_TOOL_DEFINITIONS } from "../tools/agent-tools.js";
+import { createDefaultPaletteCommands } from "../desktop/command-palette.js";
+import { DEFAULT_SHORTCUTS } from "../desktop/keyboard-shortcuts.js";
+import { DEFAULT_TRAY_ACTIONS } from "../desktop/types.js";
+const CLI_AFFORDANCES = Object.freeze([
+    cli("cli.start", "start", "Start interactive TUI", "Session"),
+    cli("cli.init", "init", "Initialize .wotann/ workspace", "Session"),
+    cli("cli.auth", "auth", "Provider authentication commands", "Config"),
+    cli("cli.providers", "providers", "List providers with auth status", "Config"),
+    cli("cli.models", "models", "List provider-default model tiers and auth status", "Config"),
+    cli("cli.upgrade", "upgrade", "Detect install mode and upgrade WOTANN", "Config"),
+    cli("cli.attach", "attach", "Attach the thin TUI to a running daemon session", "Session"),
+    cli("cli.doctor", "doctor", "Health check", "Diagnostics"),
+    cli("cli.run", "run", "Non-interactive mode with full harness intelligence", "Execution"),
+    cli("cli.mcp", "mcp", "MCP server management", "Tools"),
+    cli("cli.mcp.serve", "mcp serve", "Run WOTANN as a stdio MCP server", "Tools"),
+    cli("cli.memory", "memory", "Memory operations", "Intelligence"),
+    cli("cli.skills", "skills", "Skill management", "Intelligence"),
+    cli("cli.daemon", "daemon", "KAIROS daemon management", "Execution"),
+    cli("cli.engine", "engine", "Background runtime engine", "Execution"),
+    cli("cli.affordances.list", "affordances list", "List registered user-facing affordances", "Diagnostics"),
+]);
+const TUI_SLASH_AFFORDANCES = Object.freeze(buildAppV3SlashAffordances());
+const AGENT_TOOL_AFFORDANCES = Object.freeze(buildAgentToolAffordances());
+const DESKTOP_PALETTE_AFFORDANCES = Object.freeze(buildDesktopPaletteAffordances());
+const DESKTOP_SHORTCUT_AFFORDANCES = Object.freeze(buildDesktopShortcutAffordances());
+const DESKTOP_TRAY_AFFORDANCES = Object.freeze(buildDesktopTrayAffordances());
+export const AFFORDANCE_REGISTRY = Object.freeze([
+    ...CLI_AFFORDANCES,
+    ...TUI_SLASH_AFFORDANCES,
+    ...AGENT_TOOL_AFFORDANCES,
+    ...DESKTOP_PALETTE_AFFORDANCES,
+    ...DESKTOP_SHORTCUT_AFFORDANCES,
+    ...DESKTOP_TRAY_AFFORDANCES,
+]);
+export function listAffordances(filter = {}) {
+    const includeInternal = filter.includeInternal === true;
+    return AFFORDANCE_REGISTRY.filter((entry) => {
+        if (!includeInternal && entry.internalOnly === true)
+            return false;
+        if (filter.surface !== undefined && !entry.routes.some((route) => route.surface === filter.surface)) {
+            return false;
+        }
+        if (filter.kind !== undefined && !entry.routes.some((route) => route.kind === filter.kind)) {
+            return false;
+        }
+        return true;
+    });
+}
+export function buildSlashPromptSuggestions() {
+    return listAffordances({ surface: "tui", kind: "slash" })
+        .map((entry) => {
+        const slashRoute = entry.routes.find((route) => route.surface === "tui" && route.kind === "slash");
+        return {
+            cmd: slashRoute?.command ?? `/${entry.id.replace(/^tui\.slash\./, "")}`,
+            desc: entry.description,
+        };
+    })
+        .filter((entry, index, entries) => entries.findIndex((candidate) => candidate.cmd === entry.cmd) === index);
+}
+export function listAppV3SlashCommandIds() {
+    return listAppV3SlashCommands().flatMap((cmd) => [cmd.id, ...(cmd.aliases ?? [])]);
+}
+export function listAgentToolNames() {
+    return AGENT_TOOL_DEFINITIONS.map((tool) => tool.name);
+}
+export function listDesktopPaletteCommandIds() {
+    return listDesktopPaletteCommands().map((command) => command.id);
+}
+export function listDesktopShortcutIds() {
+    return DEFAULT_SHORTCUTS.map((shortcut) => shortcut.id);
+}
+export function listDesktopTrayActionIds() {
+    return DEFAULT_TRAY_ACTIONS.map((action) => action.id);
+}
+export function normalizeSlashUsage(usage) {
+    const canonical = usage.trim().split(/\s+/)[0] ?? "";
+    return canonical.startsWith("/") ? canonical : `/${canonical}`;
+}
+export function renderAffordanceList(entries) {
+    if (entries.length === 0)
+        return "(no affordances)";
+    const commandWidth = Math.max(...entries.map((entry) => Math.max(...entry.routes.map((route) => route.command?.length ?? 0))));
+    const surfaceWidth = Math.max(...entries.map((entry) => entry.routes[0]?.surface.length ?? 0));
+    return entries
+        .map((entry) => {
+        const primary = entry.routes[0];
+        const surface = (primary?.surface ?? "").padEnd(surfaceWidth);
+        const command = (primary?.command ?? entry.id).padEnd(commandWidth);
+        return `${surface}  ${command}  ${entry.description}`;
+    })
+        .join("\n");
+}
+export function findSlashAffordanceDrift(actualSlashCommandIds, registryEntries = AFFORDANCE_REGISTRY) {
+    const registered = new Set(registryEntries
+        .filter((entry) => entry.routes.some((route) => route.surface === "tui" && route.kind === "slash"))
+        .flatMap((entry) => entry.routes.map((route) => route.command).filter(isString)));
+    const actual = new Set(actualSlashCommandIds.map(normalizeSlashUsage));
+    const missing = [...actual].filter((id) => !registered.has(id)).sort();
+    const orphaned = [...registered].filter((id) => !actual.has(id)).sort();
+    return { missing, orphaned };
+}
+export function findToolAffordanceDrift(actualToolNames, registryEntries = AFFORDANCE_REGISTRY) {
+    const registered = new Set(registryEntries
+        .filter((entry) => entry.routes.some((route) => route.kind === "tool"))
+        .flatMap((entry) => entry.routes.map((route) => route.command).filter(isString)));
+    const actual = new Set(actualToolNames);
+    const missing = [...actual].filter((name) => !registered.has(name)).sort();
+    const orphaned = [...registered].filter((name) => !actual.has(name)).sort();
+    return { missing, orphaned };
+}
+export function findDesktopPaletteAffordanceDrift(actualPaletteCommandIds, registryEntries = AFFORDANCE_REGISTRY) {
+    return findDesktopAffordanceDrift("palette", actualPaletteCommandIds, registryEntries);
+}
+export function findDesktopShortcutAffordanceDrift(actualShortcutIds, registryEntries = AFFORDANCE_REGISTRY) {
+    return findDesktopAffordanceDrift("shortcut", actualShortcutIds, registryEntries);
+}
+export function findDesktopTrayAffordanceDrift(actualTrayActionIds, registryEntries = AFFORDANCE_REGISTRY) {
+    return findDesktopAffordanceDrift("tray", actualTrayActionIds, registryEntries);
+}
+export function findRpcAffordanceDrift(actualRpcMethods, registryEntries) {
+    const registered = new Set(registryEntries
+        .filter((entry) => entry.routes.some((route) => route.surface === "daemon" && route.kind === "rpc"))
+        .flatMap((entry) => entry.routes.map((route) => route.command).filter(isString)));
+    const actual = new Set(actualRpcMethods);
+    const missing = [...actual].filter((method) => !registered.has(method)).sort();
+    const orphaned = [...registered].filter((method) => !actual.has(method)).sort();
+    return { missing, orphaned };
+}
+function cli(id, command, description, category) {
+    return {
+        id,
+        title: command,
+        description,
+        category,
+        routes: [{ surface: "cli", kind: "command", command: `wotann ${command}` }],
+    };
+}
+function slash(id, usage, description, category) {
+    return {
+        id: `tui.slash.${id.slice(1)}`,
+        title: usage,
+        description,
+        category,
+        routes: [{ surface: "tui", kind: "slash", command: id }],
+    };
+}
+function buildAppV3SlashAffordances() {
+    return dedupeById(listAppV3SlashCommands().flatMap((cmd) => {
+        const canonical = slash(cmd.id, cmd.id, cmd.description, cmd.category);
+        const aliases = (cmd.aliases ?? []).map((alias) => slash(alias, alias, `Alias for ${cmd.id}: ${cmd.description}`, cmd.category));
+        return [canonical, ...aliases];
+    }));
+}
+function buildAgentToolAffordances() {
+    return AGENT_TOOL_DEFINITIONS.map((tool) => ({
+        id: `agent.tool.${tool.name}`,
+        title: tool.name,
+        description: tool.description,
+        category: "Tools",
+        routes: [
+            { surface: "tui", kind: "tool", command: tool.name },
+            { surface: "daemon", kind: "tool", command: tool.name },
+        ],
+    }));
+}
+function buildDesktopPaletteAffordances() {
+    return listDesktopPaletteCommands().map((command) => ({
+        id: `desktop.palette.${command.id}`,
+        title: command.label,
+        description: command.description,
+        category: command.category,
+        routes: [
+            {
+                surface: "desktop",
+                kind: "palette",
+                command: command.id,
+                ...(command.shortcut ? { path: command.shortcut } : {}),
+            },
+        ],
+    }));
+}
+function buildDesktopShortcutAffordances() {
+    return DEFAULT_SHORTCUTS.map((shortcut) => ({
+        id: `desktop.shortcut.${shortcut.id}`,
+        title: shortcut.label,
+        description: shortcut.action,
+        category: shortcut.scope,
+        routes: [
+            {
+                surface: "desktop",
+                kind: "shortcut",
+                command: shortcut.id,
+                path: shortcut.keys,
+                os: ["macos", "linux", "windows"],
+            },
+        ],
+    }));
+}
+function buildDesktopTrayAffordances() {
+    return DEFAULT_TRAY_ACTIONS.map((action) => ({
+        id: `desktop.tray.${action.id}`,
+        title: action.label,
+        description: `Tray quick action dispatches ${action.command}`,
+        category: "tray",
+        routes: [
+            {
+                surface: "desktop",
+                kind: "tray",
+                command: action.id,
+                path: action.command,
+                os: ["macos", "linux", "windows"],
+            },
+        ],
+    }));
+}
+function listAppV3SlashCommands() {
+    const router = createSlashRouter();
+    const shellState = {
+        getModel: () => "model",
+        getProvider: () => "provider",
+        getMode: () => "ask",
+        listProviders: () => [],
+        listCommands: () => router.list().map((cmd) => ({ id: cmd.id, description: cmd.description })),
+        clearTranscript: () => { },
+    };
+    for (const cmd of buildV3IntrinsicCommands(shellState))
+        router.register(cmd);
+    for (const cmd of TERMINAL_COMMANDS)
+        router.register(cmd);
+    for (const cmd of CODEX_PARITY_COMMANDS)
+        router.register(cmd);
+    for (const cmd of CROSS_SURFACE_COMMANDS)
+        router.register(cmd);
+    return router.list();
+}
+function listDesktopPaletteCommands() {
+    const noop = () => { };
+    const callbacks = {
+        enhancePrompt: noop,
+        newConversation: noop,
+        clearHistory: noop,
+        openSettings: noop,
+        switchModel: noop,
+        toggleMode: noop,
+        showCost: noop,
+        showMemory: noop,
+        showProviders: noop,
+        showHelp: noop,
+        showHealth: noop,
+        showFleet: noop,
+        compactContext: noop,
+    };
+    return createDefaultPaletteCommands(callbacks);
+}
+function findDesktopAffordanceDrift(kind, actualIds, registryEntries) {
+    const registered = new Set(registryEntries
+        .filter((entry) => entry.routes.some((route) => route.surface === "desktop" && route.kind === kind))
+        .flatMap((entry) => entry.routes.map((route) => route.command).filter(isString)));
+    const actual = new Set(actualIds);
+    const missing = [...actual].filter((id) => !registered.has(id)).sort();
+    const orphaned = [...registered].filter((id) => !actual.has(id)).sort();
+    return { missing, orphaned };
+}
+function dedupeById(entries) {
+    const seen = new Set();
+    const out = [];
+    for (const entry of entries) {
+        if (seen.has(entry.id))
+            continue;
+        seen.add(entry.id);
+        out.push(entry);
+    }
+    return out;
+}
+function isString(value) {
+    return typeof value === "string" && value.length > 0;
+}

package/dist/affordances/runtime-rpc.d.ts

@@ -0,0 +1,4 @@
+import type { AffordanceEntry, AffordanceFilter } from "./registry.js";
+export declare function listKairosRpcMethods(): readonly string[];
+export declare function buildKairosRpcAffordances(methods?: readonly string[]): readonly AffordanceEntry[];
+export declare function listAffordancesWithRuntimeRpc(filter?: AffordanceFilter): readonly AffordanceEntry[];

package/dist/affordances/runtime-rpc.js

@@ -0,0 +1,31 @@
+import { KairosRPCHandler } from "../daemon/kairos-rpc.js";
+import { listAffordances } from "./registry.js";
+export function listKairosRpcMethods() {
+    const handler = new KairosRPCHandler();
+    return handler.getMethods().slice().sort();
+}
+export function buildKairosRpcAffordances(methods = listKairosRpcMethods()) {
+    return methods.map((method) => ({
+        id: `daemon.rpc.${method.replaceAll(".", "-")}`,
+        title: method,
+        description: `KAIROS daemon JSON-RPC method: ${method}`,
+        category: method.split(".")[0] ?? "rpc",
+        routes: [{ surface: "daemon", kind: "rpc", command: method }],
+    }));
+}
+export function listAffordancesWithRuntimeRpc(filter = {}) {
+    const staticEntries = listAffordances(filter);
+    const includeRpc = filter.kind === undefined || filter.kind === "rpc" || filter.surface === undefined || filter.surface === "daemon";
+    if (!includeRpc)
+        return staticEntries;
+    const rpcEntries = buildKairosRpcAffordances().filter((entry) => {
+        if (filter.surface !== undefined && !entry.routes.some((route) => route.surface === filter.surface)) {
+            return false;
+        }
+        if (filter.kind !== undefined && !entry.routes.some((route) => route.kind === filter.kind)) {
+            return false;
+        }
+        return true;
+    });
+    return [...staticEntries, ...rpcEntries];
+}

package/dist/agents/background-agent.d.ts

@@ -45,6 +45,8 @@ export interface BackgroundTaskStatus {
     readonly branchName: string | null;
     readonly prUrl: string | null;
     readonly error: string | null;
+    readonly projectDir?: string;
+    readonly repoRoot?: string | null;
 }
 export declare class BackgroundAgentManager {
     private readonly tasks;
@@ -77,4 +79,3 @@ export declare class BackgroundAgentManager {
     private emitStatus;
     loadPersistedTasks(): void;
 }
-//# sourceMappingURL=background-agent.d.ts.map

package/dist/agents/background-agent.js

@@ -11,7 +11,7 @@
  */
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, rmSync, readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { randomBytes } from "node:crypto";
 import { resolveWotannHomeSubdir } from "../utils/wotann-home.js";
 import { safeWriteFile } from "../utils/path-realpath.js";
@@ -51,6 +51,8 @@ export class BackgroundAgentManager {
             branchName,
             prUrl: null,
             error: null,
+            projectDir: resolve(config.workingDir),
+            repoRoot: detectRepoRoot(config.workingDir),
         };
         this.tasks.set(id, status);
         this.queue.push(id);
@@ -327,4 +329,15 @@ export class BackgroundAgentManager {
         }
     }
 }
-//# sourceMappingURL=background-agent.js.map
+function detectRepoRoot(cwd) {
+    try {
+        return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/agents/file-scope-policy.d.ts

@@ -113,4 +113,3 @@ export declare const DOCS_ONLY_POLICY: AgentScopePolicy;
  * I18n-only policy — locale files only.
  */
 export declare const I18N_ONLY_POLICY: AgentScopePolicy;
-//# sourceMappingURL=file-scope-policy.d.ts.map

package/dist/agents/file-scope-policy.js

@@ -187,4 +187,3 @@ export const I18N_ONLY_POLICY = createPolicy({
     allowPatterns: ["locales/**", "i18n/**", "**/*.po", "**/*.mo"],
     defaultDeny: true,
 });
-//# sourceMappingURL=file-scope-policy.js.map

package/dist/agents/required-reading.d.ts

@@ -54,4 +54,3 @@ export declare function renderRequiredReadingBlock(resolved: readonly ResolvedRe
  * this to abort agent boot instead of silently proceeding.
  */
 export declare function hasMandatoryFailures(resolved: readonly ResolvedRequiredReading[]): boolean;
-//# sourceMappingURL=required-reading.d.ts.map

package/dist/agents/required-reading.js

@@ -115,4 +115,3 @@ export function renderRequiredReadingBlock(resolved) {
 export function hasMandatoryFailures(resolved) {
     return resolved.some((r) => r.error && !r.optional);
 }
-//# sourceMappingURL=required-reading.js.map

package/dist/agents/yaml-manifest.d.ts

@@ -122,4 +122,3 @@ export declare function diffManifests(a: AgentYamlManifest, b: AgentYamlManifest
  * plugin-shipped base. The result is deeply frozen.
  */
 export declare function mergeManifests(base: AgentYamlManifest, override: AgentYamlManifest): AgentYamlManifest;
-//# sourceMappingURL=yaml-manifest.d.ts.map

package/dist/agents/yaml-manifest.js

@@ -957,4 +957,3 @@ function mergeByJson(a, b) {
     }
     return Object.freeze(out);
 }
-//# sourceMappingURL=yaml-manifest.js.map

package/dist/api/anthropic-gateway.d.ts

@@ -107,7 +107,7 @@ interface OpenAIChatResponse {
             readonly role: "assistant";
             readonly content: string | null;
         };
-        readonly finish_reason: "stop" | "length" | "tool_calls" | null;
+        readonly finish_reason: "stop" | "length" | "tool_calls" | "content_filter" | null;
     }>;
     readonly usage: {
         readonly prompt_tokens: number;
@@ -121,8 +121,9 @@ interface OpenAIStreamChunk {
         readonly delta: {
             readonly content?: string;
             readonly role?: "assistant";
+            readonly tool_calls?: readonly unknown[];
         };
-        readonly finish_reason: "stop" | "length" | null;
+        readonly finish_reason: "stop" | "length" | "tool_calls" | "content_filter" | null;
     }>;
 }
 export type AnthropicHandler = (req: OpenAIChatRequest) => Promise<OpenAIChatResponse>;
@@ -192,4 +193,3 @@ export declare function handleMessagesRequest(req: IncomingMessage, res: ServerR
     stream: AnthropicStreamHandler | null;
 }): Promise<void>;
 export {};
-//# sourceMappingURL=anthropic-gateway.d.ts.map

package/dist/api/anthropic-gateway.js

@@ -262,4 +262,3 @@ export async function handleMessagesRequest(req, res, handlers) {
         }));
     }
 }
-//# sourceMappingURL=anthropic-gateway.js.map

package/dist/api/oauth-provider-proxy.d.ts

@@ -0,0 +1,65 @@
+import type { AgentMessage } from "../core/types.js";
+import type { ProviderAdapter, StreamChunk as ProviderStreamChunk, ToolSchema } from "../providers/types.js";
+import type { ChatCompletionRequest, ChatCompletionResponse, ModelListResponse, StreamChunk } from "./server.js";
+export declare const DEFAULT_OAUTH_PROXY_PORT = 8645;
+export declare const DEFAULT_OAUTH_PROXY_HOST = "127.0.0.1";
+export interface OAuthProxyProviderState {
+    readonly enabled: boolean;
+    readonly enabledAt?: string;
+}
+export interface OAuthProxyOptInState {
+    readonly providers?: Readonly<Record<string, OAuthProxyProviderState>>;
+}
+export interface OAuthProxyAdapter {
+    readonly name: string;
+    readonly displayName: string;
+    readonly authHint: string;
+    isOptedIn(): boolean;
+    isAuthenticated(): Promise<boolean>;
+    listModels(): Promise<readonly string[]>;
+    query(options: OAuthProxyQueryOptions): AsyncGenerator<ProviderStreamChunk>;
+}
+export interface OAuthProxyQueryOptions {
+    readonly prompt: string;
+    readonly systemPrompt?: string;
+    readonly messages: readonly AgentMessage[];
+    readonly model: string;
+    readonly maxTokens?: number;
+    readonly temperature?: number;
+    readonly tools?: readonly ToolSchema[];
+}
+export interface OAuthProxyHandlers {
+    request(req: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+    stream(req: ChatCompletionRequest, write: (chunk: StreamChunk) => void): Promise<void>;
+    models(): Promise<ModelListResponse>;
+    health(): Promise<{
+        readonly status: "ok" | "auth_required" | "opt_in_required";
+        readonly upstream: string;
+        readonly authenticated: boolean;
+        readonly optedIn: boolean;
+    }>;
+}
+export declare function resolveOAuthProxyOptInPath(pathOverride?: string): string;
+export declare function readOAuthProxyOptIn(pathOverride?: string): OAuthProxyOptInState;
+export declare function isOAuthProxyProviderOptedIn(provider: string, pathOverride?: string): boolean;
+export declare function persistOAuthProxyProviderOptIn(provider: string, enabled: boolean, pathOverride?: string): Promise<{
+    readonly path: string;
+    readonly enabled: boolean;
+}>;
+export declare function createCodexOAuthProxyAdapter(options?: {
+    readonly optInPath?: string;
+    readonly adapter?: ProviderAdapter;
+}): OAuthProxyAdapter;
+export declare function createOAuthProxyAdapter(name: string, options?: {
+    readonly optInPath?: string;
+}): OAuthProxyAdapter;
+export declare function listOAuthProxyProviders(options?: {
+    readonly optInPath?: string;
+}): readonly {
+    readonly name: string;
+    readonly displayName: string;
+    readonly optedIn: boolean;
+    readonly supported: boolean;
+    readonly note?: string;
+}[];
+export declare function createOAuthProxyHandlers(adapter: OAuthProxyAdapter): OAuthProxyHandlers;