codiedev 0.9.80 → 0.10.0-beta.10

package/dist/copilotHooks.d.ts

@@ -1,85 +0,0 @@
-/**
- * GitHub Copilot: VS Code Copilot Chat's agent and the Copilot CLI run on the
- * same runtime and write the same session record,
- * `$COPILOT_HOME/session-state/<sessionId>/events.jsonl` (plus
- * `workspace.yaml`), and both read user hooks from `$COPILOT_HOME/hooks/*.json`.
- * Everything Copilot-specific is translated here, at the process boundary, so
- * the shared capture pipeline only ever sees the Claude-shaped transcript it
- * already parses.
- */
-/** `$COPILOT_HOME`, else `~/.copilot` (the runtime honours the same variable). */
-export declare function copilotHome(env?: NodeJS.ProcessEnv, home?: string): string;
-export declare function copilotSessionDir(sessionId: string, home?: string): string | undefined;
-/** sessionEnd carries no transcript path; the session id names the file. */
-export declare function copilotTranscriptPath(sessionId: string | undefined, home?: string): string | undefined;
-export type CopilotWorkspace = {
-    id?: string;
-    cwd?: string;
-    gitRoot?: string;
-    branch?: string;
-    /** "vscode-agent-host" (VS Code Copilot Chat) or "github/cli" (Copilot CLI). */
-    clientName?: string;
-};
-/** workspace.yaml is flat `key: value` lines; no YAML dependency needed. */
-export declare function parseCopilotWorkspace(yaml: string): CopilotWorkspace;
-/** The workspace.yaml beside a transcript (or for a session id); {} if absent. */
-export declare function readCopilotWorkspace(transcriptPathOrDir: string | undefined): CopilotWorkspace;
-export declare const COPILOT_VSCODE_CLIENT = "vscode-agent-host";
-/**
- * How the session was launched. VS Code names itself in workspace.yaml; the
- * CLI doesn't record whether it ran headless, so that comes from the process
- * that launched the hook (`detected`, see launchContext). Unknown stays
- * unknown rather than guessing "human".
- */
-export declare function copilotLaunch(clientName: string | undefined, detected: string | undefined): string | undefined;
-/**
- * Copilot's hook payloads are camelCase (`sessionId`, `transcriptPath`,
- * `toolName`/`toolArgs`/`toolResult`); preToolUse in the CLI batches calls as
- * `toolCalls: [{id, name, args}]`. Translate to the shared snake_case shape.
- * The FIRST tool call fills tool_name/tool_input; `copilotToolCalls` keeps all
- * of them so security can check each.
- */
-export declare function normalizeCopilotHookInput<T extends Record<string, unknown>>(input: T, home?: string): T & Record<string, unknown>;
-export type CopilotToolCall = {
-    id?: string;
-    name: string;
-    input: unknown;
-};
-/** Copilot's preToolUse deny output. */
-export declare function copilotPreToolBlockResponse(reason: string): {
-    permissionDecision: "deny";
-    permissionDecisionReason: string;
-};
-/** Only a byte-empty record is safe to discard (same rule as Cursor). */
-export declare function isCopilotTranscriptEmpty(content: string): boolean;
-/** session.shutdown carries the per-model token totals; written after sessionEnd. */
-export declare function hasCopilotShutdown(content: string): boolean;
-export type NormalizedCopilotTranscript = {
-    /** Claude-shaped JSONL for the shared parsers and the upload. */
-    content: string;
-    /** Fleet-mode sub-agents run inside this file (subagent.started). */
-    subagents: {
-        count: number;
-        truncated: boolean;
-    };
-    /** True once session.shutdown (token totals) has been written. */
-    final: boolean;
-};
-/**
- * events.jsonl → Claude-shaped JSONL:
- *   session.start          → system record (cwd, branch, entrypoint for VS Code)
- *   user.message           → user text
- *   assistant.message      → assistant text + tool_use blocks (model on every call)
- *   tool.execution_complete→ user tool_result (git output feeds branch/sha joins)
- *   skill.invoked          → copilot.skill_invoked (one skill run)
- *   session.shutdown       → copilot.usage per model (tokens, sub-agents
- *                            included; requests counted from the assistant
- *                            calls, so 0 here) + copilot.usage_summary
- *   session.usage_checkpoint → copilot.usage_summary (premium requests and
- *                            nano-AIU so far; superseded by shutdown)
- *   subagent.started       → counted as a fleet sub-agent
- * Hooks, permissions, system prompts and checkpoints are dropped.
- */
-export declare function normalizeCopilotTranscript(raw: string, opts?: {
-    clientName?: string;
-}): NormalizedCopilotTranscript;

package/dist/copilotInstallation.d.ts

@@ -1,10 +0,0 @@
-export declare function inspectCopilotHooks(file?: string, security?: boolean): {
-    status: "not-installed";
-    detail: string;
-} | {
-    status: "fail";
-    detail: string;
-} | {
-    status: "pass";
-    detail: string;
-};

package/dist/cursorHooks.d.ts

@@ -1,13 +0,0 @@
-/** Normalize Cursor's native hook payload into the shared capture shape. */
-export declare function normalizeCursorHookInput<T extends Record<string, unknown>>(input: T): T & Record<string, unknown>;
-/** Normalize Cursor message roles and native tools at the capture boundary. */
-export declare function normalizeCursorTranscript(content: string): string;
-/** Cursor may change its private JSONL record shape independently of the hook
- * contract. Only a byte-empty snapshot is safe to discard; a non-empty file
- * that the current normalizer cannot parse must still be uploaded for backend
- * recovery and diagnosis. */
-export declare function isCursorTranscriptEmpty(content: string): boolean;
-/** The IDE transcript often omits usage entirely; absence must not become
- * measured zero. CLI records with explicit token fields retain their totals. */
-export declare function cursorTranscriptHasUsage(content: string): boolean;
-export declare function cursorObservedModel(content: string): string | undefined;

package/dist/cursorLifecycle.d.ts

@@ -1,2 +0,0 @@
-export declare function recordCursorLifecycle(input: Record<string, unknown>, final: boolean): void;
-export declare function cursorLifecycleRecords(sessionId: string | undefined): string;

package/dist/detection.d.ts

@@ -1,30 +0,0 @@
-export interface ClaudeCodeProbe {
-    dirExists: boolean;
-    binOnPath: boolean;
-}
-/**
- * Claude Code is "installed" if either ~/.claude exists (the user has
- * launched the app at least once) OR the `claude` binary is on PATH (the
- * user installed via npm/brew but hasn't launched yet). Either signal is
- * sufficient — we want to wire up the hook the moment the user has
- * obviously committed to the tool.
- */
-export declare function detectClaudeCode(probe: ClaudeCodeProbe): boolean;
-/**
- * True iff `cmd` looks like a hook command codiedev itself wrote. Used
- * both by the install filter (so `connect` replaces the existing entry
- * instead of stacking another one) and by `codiedev doctor` (so it can
- * grade whether the hook is wired up).
- *
- * Must match every form codiedev can write:
- *   - Legacy `npx codiedev-hook <subcommand>`
- *   - Absolute path from npm-registry install:
- *     `<node> /.../node_modules/codiedev/dist/hook.js <subcommand>`
- *   - Absolute path from `npm link` dev install (the monorepo folder
- *     is named `codiedev-cli`, not `codiedev`):
- *     `<node> /.../codiedev-cli/dist/hook.js <subcommand>`
- *
- * The `codiedev[^/\\]*` allows the trailing `-cli` (or any future suffix)
- * without matching unrelated paths like `notcodiedev/dist/hook.js`.
- */
-export declare function isCodiedevHookCommand(cmd: string | undefined): boolean;

package/dist/harnessDirs.d.ts

@@ -1,15 +0,0 @@
-/** Claude Code: `$CLAUDE_CONFIG_DIR` or ~/.claude. */
-export declare function claudeConfigDir(env?: NodeJS.ProcessEnv, home?: string): string;
-/** Claude Code's user state file. Lives inside `$CLAUDE_CONFIG_DIR` when set, else ~/.claude.json. */
-export declare function claudeUserConfigPath(env?: NodeJS.ProcessEnv, home?: string): string;
-/** Codex: `$CODEX_HOME` or ~/.codex. */
-export declare function codexHome(env?: NodeJS.ProcessEnv, home?: string): string;
-/** OpenCode: `$XDG_CONFIG_HOME/opencode` or ~/.config/opencode. */
-export declare function openCodeConfigDir(env?: NodeJS.ProcessEnv, home?: string): string;
-/** pi: `$PI_CODING_AGENT_DIR` or ~/.pi/agent. Holds extensions/, skills/,
- * sessions/ and the global AGENTS.md. */
-export declare function piAgentDir(env?: NodeJS.ProcessEnv, home?: string): string;
-/** `~`-abbreviated path for user-facing output. */
-export declare function displayPath(p: string, home?: string): string;
-export declare function claudeConfigDirInUse(dir?: string, exists?: (p: string) => boolean): boolean;
-export declare function codexHomeInUse(dir?: string, exists?: (p: string) => boolean): boolean;

package/dist/hook.d.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-export declare function buildDiscoveryContext(skills: Array<{
-    key: string;
-    title: string;
-    score: number;
-}>): string | null;

package/dist/inboxFormat.d.ts

@@ -1,38 +0,0 @@
-export interface InboxPing {
-    pingId: string;
-    createdAt: number;
-    readAt?: number;
-    from: {
-        name: string;
-        email: string;
-    } | null;
-    subjectKey: string | null;
-    subject: {
-        title?: string;
-    } | null;
-    preview: string;
-}
-export interface InboxMention {
-    mentionId: string;
-    createdAt: number;
-    readAt?: number | null;
-    from: {
-        name: string;
-        email: string;
-    } | null;
-    postTitle: string | null;
-    preview: string | null;
-    url: string | null;
-}
-/**
- * Render the inbox for BOTH surfaces — `codiedev inbox` and the MCP
- * `codiedev_inbox` tool an agent calls for "any messages?". Shared so the
- * agent path can never drift back to pings-only while the human path shows
- * mentions.
- */
-export declare function formatInbox(opts: {
-    pings: InboxPing[];
-    mentions?: InboxMention[];
-    unreadOnly: boolean;
-    limit?: number;
-}): string[];

package/dist/launchContext.d.ts

@@ -1,46 +0,0 @@
-export declare function codieLaunchFromArgv(argv: readonly string[]): string;
-/** One launching process's command line → a Cursor launch value. */
-export declare function cursorLaunchFromCommand(command: string): string | undefined;
-/**
- * One launching process's command line → a Copilot CLI launch value. The CLI
- * runs as `…/@github/copilot-<platform>/copilot [flags]` under
- * `node …/bin/copilot [flags]`; `-p`/`--prompt` is headless (scripted). VS
- * Code's agent (`copilot-runtime --headless`) is named by workspace.yaml
- * instead, so it never matches here.
- */
-export declare function copilotLaunchFromCommand(command: string): string | undefined;
-type Ps = (pid: number) => {
-    ppid: number;
-    command: string;
-} | null;
-/**
- * Windows: one PowerShell call returns the whole ancestor chain (spawning
- * PowerShell per level would cost ~0.5s each). CommandLine needs CIM, which
- * every supported Windows has; any failure means "unknown", never a guess.
- */
-export declare function windowsAncestors(startPid: number, depth: number): Array<{
-    pid: number;
-    ppid: number;
-    command: string;
-}> | null;
-type LaunchDeps = {
-    platform?: string;
-    ps?: Ps;
-    depth?: number;
-    windows?: typeof windowsAncestors;
-};
-/**
- * Walk up to `depth` ancestors (a shell or `npx` usually sits between Cursor
- * and the hook) and return the first Cursor launch found.
- */
-export declare function detectCursorLaunch(startPid?: number, deps?: LaunchDeps): string | undefined;
-/** The Copilot CLI that launched this hook (`copilot:print` / `copilot:cli`). */
-export declare function detectCopilotLaunch(startPid?: number, deps?: LaunchDeps): string | undefined;
-/** The launch value a hook invocation should carry into its capture job. */
-export declare function hookLaunch(hookCommand: string | undefined, input: {
-    launch?: unknown;
-}, deps?: {
-    copilotClientName?: string;
-    detectCopilot?: () => string | undefined;
-}): string | undefined;
-export {};

package/dist/launcher.d.ts

@@ -1,25 +0,0 @@
-export declare const LAUNCHER_FILE = "codiedev-hook-launcher.cjs";
-export interface InstallRecord {
-    hookScript: string;
-    version?: string;
-    recordedAt: number;
-}
-export declare function launcherPath(): string;
-/** True iff `cmd` invokes the stable launcher (from any state dir). */
-export declare function usesLauncher(cmd: string | undefined): boolean;
-export declare function readInstallRecord(): InstallRecord | null;
-/**
- * The hook script worth recording: absolute and present, and a global install over an npx cache
- * copy (npm prunes ~/.npm/_npx, and hooks pointed there go quietly dead). Null = don't record.
- */
-export declare function stableHookScript(hookScript: string, globalCandidates?: string[]): string | null;
-/** Point the launcher at `hookScript`. Atomic, so a hook mid-launch never reads half a file. */
-export declare function recordCurrentInstall(requested: string): boolean;
-/**
- * Make sure the launcher exists and forwards to `hookScript`, returning the
- * launcher path to bake into hook configs — or null if the state dir is not
- * writable, in which case callers keep baking the direct path. Memoized:
- * one connect writes ~20 hook entries.
- */
-export declare function ensureLauncher(requested: string): string | null;
-export declare function resetLauncherCacheForTests(): void;

package/dist/limitEvent.d.ts

@@ -1,15 +0,0 @@
-export type LimitKind = "session" | "user_spend" | "org_spend" | "other";
-export interface LimitEvent {
-    kind: LimitKind;
-    at: number;
-    resetText: string | null;
-    reason?: string;
-}
-export declare function classifyLimitKind(text: string): LimitKind;
-export declare function parseLimitEventFromTranscript(transcript: string): LimitEvent | null;
-/** Parse the structured rate-limit snapshot written to Codex rollout JSONL. */
-export declare function parseCodexLimitEventFromTranscript(transcript: string): LimitEvent | null;
-/** Only explicit provider errors qualify; never scan user/assistant prose. */
-export declare function parseNativeLimitError(input: Record<string, unknown>, now?: number): LimitEvent | null;
-export declare function parseNativeLimitEventFromTranscript(transcript: string): LimitEvent | null;
-export declare function tailForLimitEvent(transcript: string, maxChars?: number): string;

package/dist/limitEventReporter.d.ts

@@ -1,21 +0,0 @@
-import { type LimitEvent } from "./limitEvent";
-export type LimitEventSource = "claude-code" | "codex" | "cursor" | "copilot" | "pi";
-export type LimitEventPayload = LimitEvent & {
-    source: LimitEventSource;
-    sessionId?: string;
-    transcriptTail?: string;
-};
-export declare function postLimitEvent(config: {
-    backendUrl: string;
-    token: string;
-}, payload: LimitEventPayload, timeoutMs?: number): Promise<void>;
-export declare function reportTranscriptLimitEvent(args: {
-    config: {
-        backendUrl: string;
-        token: string;
-    };
-    source: LimitEventSource;
-    sessionId?: string;
-    transcript: string;
-    emitMinimalOnMiss?: boolean;
-}): Promise<boolean>;

package/dist/managedPi.d.ts

@@ -1,48 +0,0 @@
-import { type CatalogModel } from "./codieLauncher";
-export declare const PI_PROVIDER_ID = "codiedev";
-/** Env vars pi reads provider credentials from (`pi --help`, pi 0.73). */
-export declare const PI_PROVIDER_ENV: string[];
-export declare const GUARD_FILE = "codie-guard.ts";
-export declare const CAPTURE_FILE = "codiedev-capture.ts";
-/** Where the guard points every other provider: a loopback port nothing
- * listens on, so a request (and whatever key it carries) never leaves the
- * machine. */
-export declare const BLOCKED_BASE_URL = "http://127.0.0.1:9/blocked-by-codiedev";
-/** The pi extension that keeps a managed session on Codiedev models and tags
- * each gateway request with the session, repo and skills, so gateway billing
- * joins the captured pi session (same headers as the OpenCode metadata
- * plugin, assets/git-refs.mjs). */
-export declare const GUARD_SOURCE: string;
-export declare function managedPiAgentDir(stateDir: string): string;
-/** pi's models.json entry for the gateway. The key is read from
- * CODIEDEV_GATEWAY_KEY at request time (pi resolves an env var name). */
-export declare function piProviderConfig(gatewayUrl: string, catalog: CatalogModel[]): Record<string, unknown>;
-/** Rewrite everything Codiedev owns in the managed agent dir. Sessions (and
- * anything else pi keeps there) are left alone. Returns the extensions to load. */
-export declare function prepareManagedPiDir(opts: {
-    agentDir: string;
-    gatewayUrl: string;
-    catalog: CatalogModel[];
-    model?: string;
-    skillPaths?: string[];
-    agentSecurityEnabled: boolean;
-}): string[];
-/** The child env: no provider credentials, pi pointed at the managed dir. */
-export declare function managedPiEnv(env: NodeJS.ProcessEnv, agentDir: string, key: string, platform?: NodeJS.Platform): NodeJS.ProcessEnv;
-export declare class ManagedPiArgError extends Error {
-}
-/** Refuse what would bring other credentials or code into the session, then
- * pin extension loading to the managed extensions. */
-export declare function managedPiArgs(args: string[], extensions: string[]): string[];
-export declare function runManagedPi(opts: {
-    args: string[];
-    key: string;
-    gatewayUrl: string;
-    catalog: CatalogModel[];
-    stateDir: string;
-    skillPaths?: string[];
-    agentSecurityEnabled: boolean;
-    env?: NodeJS.ProcessEnv;
-    /** Test seam: resolve the pi CLI entry without installing. */
-    resolvePi?: () => string;
-}): number;

package/dist/mcp.d.ts

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-/**
- * Codiedev MCP server.
- *
- * Exposes the Codiedev artifact-collaboration surface as Model Context
- * Protocol tools so Claude Code / Codex / any MCP-capable agent can invoke
- * them natively from natural language (e.g. "push the spec we just worked on").
- *
- * Reads the same ~/.codiedev/config.json the CLI uses. Install + wire up by
- * running `npx codiedev connect`.
- */
-export {};

package/dist/nativeSteering.d.ts

@@ -1,5 +0,0 @@
-/** Native records only: quoted denial/interrupt text in conversation is not evidence. */
-export declare function parseNativeSteering(content: string): {
-    interrupts: number;
-    rejections: number;
-};

package/dist/packs/codie.d.ts

@@ -1,45 +0,0 @@
-export interface CodiePackConfig {
-    skillPaths: string[];
-    agents: Record<string, {
-        description: string;
-        prompt: string;
-        mode: "subagent";
-        model?: string;
-    }>;
-    plugins: string[];
-    notes: string[];
-}
-/** A model the account approves, as Codie's catalog lists it. */
-export interface LevelCatalogModel {
-    id: string;
-    name?: string;
-    cost?: {
-        input: number;
-        output: number;
-    };
-    tier?: string;
-    level?: string;
-}
-/** Resolve an agent level (opus = Strongest, sonnet = Balanced, haiku =
- * Fastest) to one of the account's approved models:
- * 1. explicit tier/level metadata on the catalog entry, when the gateway sends it
- * 2. the same model family by name (e.g. a "claude-opus-…" model), newest first
- * 3. by price: Strongest = priciest, Fastest = cheapest, Balanced = in between
- * Otherwise undefined → Codie's governed default. Only catalog ids are returned. */
-export declare function levelToModel(level: string, catalog: LevelCatalogModel[]): {
-    model?: string;
-    how: string;
-};
-/** Map a Claude agent `model:` to an OpenCode model id, or undefined to let
- * Codie's governed default apply. */
-export declare function mapAgentModel(value: string | undefined, approved?: Set<string>, catalog?: LevelCatalogModel[]): {
-    model?: string;
-    note?: string;
-};
-export declare function codiePackConfig(root: string, options?: {
-    approvedModels?: Set<string>;
-    catalog?: LevelCatalogModel[];
-}): CodiePackConfig;
-/** Merge pack config into an OpenCode config without clobbering anything the
- * user or Codie already set: existing skill paths, agents and plugins win. */
-export declare function mergeCodiePackConfig(existing: Record<string, any>, packs: CodiePackConfig): Record<string, any>;

package/dist/packs/harnesses.d.ts

@@ -1,74 +0,0 @@
-import { PackManifest } from "./manifest";
-import { RegistryEntry } from "./store";
-export declare const HARNESSES: readonly ["claude", "copilot", "codex", "cursor", "codie", "pi"];
-export type HarnessName = (typeof HARNESSES)[number];
-export interface RunResult {
-    status: number | null;
-    stdout: string;
-    stderr: string;
-    error?: string;
-}
-export type Runner = (command: string, args: string[], options?: {
-    cwd?: string;
-}) => RunResult;
-export declare function defaultRunner(env: NodeJS.ProcessEnv): Runner;
-/** True when `bin` is an executable file on `env.PATH`. */
-export declare function onPath(bin: string, env: NodeJS.ProcessEnv): boolean;
-export interface AdapterContext {
-    root: string;
-    env: NodeJS.ProcessEnv;
-    home: string;
-    run: Runner;
-    manifest: PackManifest;
-    pluginDir: string;
-    /** Same plugin without agent model levels (Codex, Copilot, Cursor). */
-    portablePluginDir: string;
-    previous?: RegistryEntry;
-}
-export interface AdapterResult {
-    harness: HarnessName;
-    status: "ok" | "skipped" | "failed" | "dry-run";
-    detail: string;
-    /** Debug-level notes (printed with CODIEDEV_DEBUG; always in --json). */
-    notes?: string[];
-}
-export interface Adapter {
-    name: HarnessName;
-    detect(ctx: Omit<AdapterContext, "manifest" | "pluginDir" | "portablePluginDir" | "previous">): boolean;
-    /** Returns a short success detail; throws on failure. */
-    install(ctx: AdapterContext): string;
-    /** Human-readable description of what install would do (for --dry-run). */
-    plan(ctx: AdapterContext): string;
-    /** Remove the pack from this tool. Returns a detail; throws on failure. */
-    uninstall(ctx: UninstallContext): string;
-}
-export interface UninstallContext {
-    root: string;
-    env: NodeJS.ProcessEnv;
-    home: string;
-    run: Runner;
-    slug: string;
-}
-export declare const claudeAdapter: Adapter;
-export declare const copilotAdapter: Adapter;
-export declare const codexAdapter: Adapter;
-export declare const CURSOR_MARKER = ".codiedev-pack";
-/** Fallback: copy skills to ~/.cursor/skills/<name>/, never overwriting a
- * skill dir Codiedev didn't write, and pruning ones this pack no longer has. */
-export declare function copyCursorSkills(home: string, manifest: PackManifest, pluginDirPath: string): string[];
-/** Remove every ~/.cursor/skills dir this pack's fallback copy wrote. */
-export declare function removeCursorSkills(home: string, slug: string): number;
-export declare function cursorLocalPluginsDir(home: string): string;
-export declare function cursorPluginDir(home: string, slug: string): string;
-/** Copy the plugin dir into place via a sibling temp dir + rename. Refuses to
- * replace a dir that doesn't carry our marker for this pack. */
-export declare function installCursorPlugin(home: string, slug: string, sourceDir: string): string;
-/** Remove our copy (only when it carries our marker). */
-export declare function removeCursorPlugin(home: string, slug: string): boolean;
-export declare const cursorAdapter: Adapter;
-export declare const codieAdapter: Adapter;
-/** pi has no plugin system; it loads extra skill dirs from settings.json
- * `skills`. Point it at the portable copy (no Claude model aliases). */
-export declare const piAdapter: Adapter;
-export declare const ADAPTERS: Adapter[];
-export declare function parseHarnessList(value: string | undefined): HarnessName[] | undefined;

package/dist/packs/hookGate.d.ts

@@ -1,53 +0,0 @@
-import { spawnSync } from "child_process";
-/** Skill names a hook payload shows as running, across the five tools:
- * - Claude:  tool_name "Skill",  tool_input.skill "<plugin>:<name>"
- * - Copilot: tool_name "skill",  tool_input.skill "<name>" (also camelCase toolName/toolArgs)
- * - Codie:   tool_name "skill",  tool_input.name "<name>"
- * - Cursor:  tool_name "Read",   tool_input.file_path ".../skills/<name>/SKILL.md"
- * - Codex:   tool_name "Bash",   tool_input.command containing ".../skills/<name>/SKILL.md" */
-export declare function skillsFromPayload(payload: unknown): string[];
-export interface GateArgs {
-    skills: string[];
-    /** `-- <argv…>`: exec'd directly (legacy `sh -c '<cmd>'` included). */
-    command: string[];
-    /** `--cmd-b64 <base64url>`: a command line for the platform shell. */
-    cmdB64?: string;
-}
-/** Largest decoded `--cmd-b64` command we run. */
-export declare const MAX_GATED_COMMAND_BYTES: number;
-/** Canonical form (what the portal writes): base64url of the UTF-8 command, no
- * padding. Only [A-Za-z0-9_-], so no shell on any platform expands or
- * re-quotes it — a `$(…)` in the gated command can't run before the gate. */
-export declare function encodeGatedCommand(command: string): string;
-/** Strict decode: canonical base64url only, ≤16KB, valid UTF-8, no NUL. */
-export declare function decodeGatedCommand(value: string): string;
-export declare function parseGateArgs(argv: string[]): GateArgs;
-export declare function gateMatches(skills: string[], payload: unknown): boolean;
-export interface GatePlan {
-    file: string;
-    args: string[];
-    /** cmd.exe needs its /c line passed verbatim (Node would re-quote it). */
-    verbatim?: boolean;
-    note?: string;
-}
-export interface PlanOptions {
-    platform?: NodeJS.Platform;
-    env?: NodeJS.ProcessEnv;
-    /** Whether `sh` is runnable (only consulted for the legacy form on Windows). */
-    hasSh?: () => boolean;
-}
-/** Split a CODIEDEV_HOOK_SHELL value ("pwsh -NoProfile -Command") into argv,
- * honouring simple "double" or 'single' quotes. */
-export declare function splitShellOverride(value: string): string[];
-/** The decoded `--cmd-b64` command line, run by the platform shell
- * (/bin/sh -c on POSIX, cmd.exe /d /s /c on Windows, or CODIEDEV_HOOK_SHELL). */
-export declare function planShellCommand(line: string, options?: PlanOptions): GatePlan;
-/** `-- <argv…>`: exec'd directly, no shell. Legacy `sh -c '<cmd>'` (packs saved
- * before --cmd-b64) runs as given, except on Windows without sh, where <cmd>
- * goes to cmd.exe. */
-export declare function planGateCommand(command: string[], options?: PlanOptions): GatePlan;
-/** Returns the exit status to use. */
-export declare function runHookGate(argv: string[], stdin: string, env?: NodeJS.ProcessEnv, options?: Omit<PlanOptions, "env"> & {
-    spawn?: typeof spawnSync;
-}): number;
-export declare function runHookGateCli(argv: string[]): void;

package/dist/packs/install.d.ts

@@ -1,46 +0,0 @@
-import { CodexHookTrustEntry } from "../codexHookTrust";
-import { AdapterResult, HarnessName, Runner } from "./harnesses";
-import { PackManifest } from "./manifest";
-import { Registry } from "./store";
-export interface InstallOptions {
-    manifests: PackManifest[];
-    harnesses?: HarnessName[];
-    dryRun?: boolean;
-    env?: NodeJS.ProcessEnv;
-    home?: string;
-    run?: Runner;
-    now?: () => number;
-}
-export interface PackInstallResult {
-    slug: string;
-    channel?: string;
-    version: number;
-    contentHash: string;
-    dir: string;
-    files: string[];
-    results: AdapterResult[];
-    harnesses: string[];
-}
-/** Where Codex unpacked this pack's hooks.json after `codex plugin add`. */
-export declare function codexPackHooksPath(codexDir: string, slug: string, version: number): string | null;
-/** Trust entries for every registry pack installed into Codex. */
-export declare function codexPackTrustEntries(registry: Registry, codexDir: string): Map<string, CodexHookTrustEntry[]>;
-export declare function installPacks(options: InstallOptions): PackInstallResult[];
-export interface UninstallOptions {
-    slugs: string[];
-    env?: NodeJS.ProcessEnv;
-    home?: string;
-    run?: Runner;
-}
-export interface PackUninstallResult {
-    slug: string;
-    results: AdapterResult[];
-}
-/** Remove packs that no longer apply (unassigned or archived): run each
- * tool's uninstall, drop the plugin dir, the marketplace entry, the registry
- * entry, its Codex trust entries and its shim hooks. Unknown slugs are a
- * no-op. A tool failing to uninstall never keeps the pack registered — the
- * pack is no longer authorized, so local state must stop advertising it. */
-export declare function uninstallPacks(options: UninstallOptions): PackUninstallResult[];
-export declare function formatUninstallLines(results: PackUninstallResult[]): string[];
-export declare function formatResultLines(results: PackInstallResult[]): string[];