instar 0.28.113 → 0.28.114

package/dist/providers/primitives/capability/fileSystemAccess.d.ts

@@ -0,0 +1,42 @@
+/**
+ * FileSystemAccess — sandboxing for the agent's filesystem operations.
+ *
+ * Determines what level of filesystem access a session has. Composes with
+ * `PathAllowlist` for fine-grained per-path control.
+ *
+ * Maps to:
+ *   - Claude: implicit (skip-permissions flag plus PathAllowlist via `--add-dir`)
+ *   - Codex: `sandbox_mode = "read-only" | "workspace-write" | "danger-full-access"`
+ *     in config.toml
+ *
+ * The abstraction surfaces three sandbox tiers that map cleanly to Codex's
+ * three modes. Claude approximates "workspace-write" with its default and
+ * "danger-full-access" via skip-permissions.
+ */
+import { CapabilityFlag } from '../../capabilities.js';
+export interface FileSystemAccess {
+    readonly capability: typeof CapabilityFlag.FileSystemAccess;
+    /** Build a portable filesystem-access spec for session establishment. */
+    buildSpec(mode: SandboxMode, options?: FilesystemAccessOptions): FileSystemAccessSpec;
+    /** Sandbox modes supported by this provider. */
+    supportedModes(): ReadonlySet<SandboxMode>;
+}
+export type SandboxMode = 
+/** Read-only access to all paths (except those explicitly denied). */
+'read-only'
+/** Read everywhere; write only inside the workspace (working directory tree). */
+ | 'workspace-write'
+/** Unrestricted read/write. Use with extreme caution; reserve for trusted workflows. */
+ | 'danger-full-access';
+export interface FilesystemAccessOptions {
+    /** Override the workspace root (defaults to session's workingDirectory). */
+    workspaceRoot?: string;
+    /** Override the user's $HOME if the sandbox shouldn't follow it. */
+    homeOverride?: string;
+}
+export type FileSystemAccessSpec = Readonly<{
+    readonly __brand: 'FileSystemAccessSpec';
+    readonly mode: SandboxMode;
+    readonly options?: FilesystemAccessOptions;
+}>;
+//# sourceMappingURL=fileSystemAccess.d.ts.map

package/dist/providers/primitives/capability/fileSystemAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSystemAccess.d.ts","sourceRoot":"","sources":["../../../../src/providers/primitives/capability/fileSystemAccess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,OAAO,cAAc,CAAC,gBAAgB,CAAC;IAE5D,yEAAyE;IACzE,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,oBAAoB,CAAC;IAEtF,gDAAgD;IAChD,cAAc,IAAI,WAAW,CAAC,WAAW,CAAC,CAAC;CAC5C;AAED,MAAM,MAAM,WAAW;AACrB,sEAAsE;AACpE,WAAW;AACb,iFAAiF;GAC/E,iBAAiB;AACnB,wFAAwF;GACtF,oBAAoB,CAAC;AAEzB,MAAM,WAAW,uBAAuB;IACtC,4EAA4E;IAC5E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,uBAAuB,CAAC;CAC5C,CAAC,CAAC"}

package/dist/providers/primitives/capability/fileSystemAccess.js

@@ -0,0 +1,17 @@
+/**
+ * FileSystemAccess — sandboxing for the agent's filesystem operations.
+ *
+ * Determines what level of filesystem access a session has. Composes with
+ * `PathAllowlist` for fine-grained per-path control.
+ *
+ * Maps to:
+ *   - Claude: implicit (skip-permissions flag plus PathAllowlist via `--add-dir`)
+ *   - Codex: `sandbox_mode = "read-only" | "workspace-write" | "danger-full-access"`
+ *     in config.toml
+ *
+ * The abstraction surfaces three sandbox tiers that map cleanly to Codex's
+ * three modes. Claude approximates "workspace-write" with its default and
+ * "danger-full-access" via skip-permissions.
+ */
+export {};
+//# sourceMappingURL=fileSystemAccess.js.map

package/dist/providers/primitives/capability/fileSystemAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSystemAccess.js","sourceRoot":"","sources":["../../../../src/providers/primitives/capability/fileSystemAccess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/providers/primitives/capability/pathAllowlist.d.ts

@@ -0,0 +1,41 @@
+/**
+ * PathAllowlist — fine-grained per-path filesystem access rules.
+ *
+ * Composes with `FileSystemAccess` to specify exceptions: a `read-only`
+ * session that needs write access to a specific scratch directory, or a
+ * `workspace-write` session that's blocked from a specific subtree.
+ *
+ * Maps to:
+ *   - Claude: `--add-dir <path>` CLI flag (additive, no deny semantics)
+ *   - Codex: `permissions.<name>.filesystem` named profiles with path-based
+ *     rules; more expressive
+ *
+ * The abstraction supports both allow and deny rules with a clear
+ * precedence (deny wins). Providers that lack deny semantics map deny
+ * rules to "no allow rule for this path" approximation.
+ */
+import { CapabilityFlag } from '../../capabilities.js';
+export interface PathAllowlist {
+    readonly capability: typeof CapabilityFlag.PathAllowlist;
+    /** Build a portable spec from a rule set. */
+    buildSpec(rules: PathAllowlistRules): PathAllowlistSpec;
+    /** Whether this provider supports explicit deny rules. */
+    supportsDenyRules(): boolean;
+}
+export interface PathAllowlistRules {
+    /** Paths the session may read. Absolute paths or workspace-relative. */
+    readAllow?: ReadonlyArray<string>;
+    /** Paths the session may write. */
+    writeAllow?: ReadonlyArray<string>;
+    /** Paths denied even if allowed by another rule. Deny wins on conflict. */
+    deny?: ReadonlyArray<string>;
+    /**
+     * Whether allowlist rules apply recursively to subdirectories. Default true.
+     */
+    recursive?: boolean;
+}
+export type PathAllowlistSpec = Readonly<{
+    readonly __brand: 'PathAllowlistSpec';
+    readonly rules: PathAllowlistRules;
+}>;
+//# sourceMappingURL=pathAllowlist.d.ts.map

package/dist/providers/primitives/capability/pathAllowlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathAllowlist.d.ts","sourceRoot":"","sources":["../../../../src/providers/primitives/capability/pathAllowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,OAAO,cAAc,CAAC,aAAa,CAAC;IAEzD,6CAA6C;IAC7C,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,iBAAiB,CAAC;IAExD,0DAA0D;IAC1D,iBAAiB,IAAI,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,wEAAwE;IACxE,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAClC,mCAAmC;IACnC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,2EAA2E;IAC3E,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;CACpC,CAAC,CAAC"}

package/dist/providers/primitives/capability/pathAllowlist.js

@@ -0,0 +1,18 @@
+/**
+ * PathAllowlist — fine-grained per-path filesystem access rules.
+ *
+ * Composes with `FileSystemAccess` to specify exceptions: a `read-only`
+ * session that needs write access to a specific scratch directory, or a
+ * `workspace-write` session that's blocked from a specific subtree.
+ *
+ * Maps to:
+ *   - Claude: `--add-dir <path>` CLI flag (additive, no deny semantics)
+ *   - Codex: `permissions.<name>.filesystem` named profiles with path-based
+ *     rules; more expressive
+ *
+ * The abstraction supports both allow and deny rules with a clear
+ * precedence (deny wins). Providers that lack deny semantics map deny
+ * rules to "no allow rule for this path" approximation.
+ */
+export {};
+//# sourceMappingURL=pathAllowlist.js.map

package/dist/providers/primitives/capability/pathAllowlist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathAllowlist.js","sourceRoot":"","sources":["../../../../src/providers/primitives/capability/pathAllowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG"}

package/dist/providers/primitives/capability/toolAccess.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ToolAccess — whether the provider can invoke tools at all, and which kinds.
+ *
+ * Tool inventory and registration. Distinct from `ToolAllowlist` which
+ * gates which registered tools are usable per session.
+ *
+ * Maps to:
+ *   - Claude: built-in tools (Read, Edit, Bash, Write, ...) + MCP-registered
+ *   - Codex: built-in tools + MCP-registered + plugin-registered
+ *
+ * Providers expose a list of tool kinds they support. The abstraction
+ * groups them into broad categories so callers can ask "does this provider
+ * support web access?" without enumerating specific tool names.
+ */
+import { CapabilityFlag } from '../../capabilities.js';
+export interface ToolAccess {
+    readonly capability: typeof CapabilityFlag.ToolAccess;
+    /** Tool kinds this provider can invoke. */
+    supportedToolKinds(): ReadonlySet<ToolKind>;
+    /**
+     * List the specific tool names available. Names are provider-specific
+     * (e.g., 'Read' on Claude, 'fs_read' on Codex) — callers comparing across
+     * providers should use `supportedToolKinds` instead.
+     */
+    registeredTools(): ReadonlyArray<RegisteredTool>;
+}
+export type ToolKind = 'file-read' | 'file-write' | 'file-edit' | 'bash' | 'web-fetch' | 'web-search' | 'mcp' | 'subagent-spawn' | 'task-delegation' | 'computer-use' | 'image-generation' | 'code-execution';
+export interface RegisteredTool {
+    /** Provider-specific name. */
+    name: string;
+    /** Abstract category. */
+    kind: ToolKind;
+    /** Whether the tool is enabled by default for new sessions. */
+    enabledByDefault: boolean;
+    /** Whether invocations require user approval per call. */
+    requiresApproval: boolean;
+}
+//# sourceMappingURL=toolAccess.d.ts.map

package/dist/providers/primitives/capability/toolAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolAccess.d.ts","sourceRoot":"","sources":["../../../../src/providers/primitives/capability/toolAccess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,UAAU,EAAE,OAAO,cAAc,CAAC,UAAU,CAAC;IAEtD,2CAA2C;IAC3C,kBAAkB,IAAI,WAAW,CAAC,QAAQ,CAAC,CAAC;IAE5C;;;;OAIG;IACH,eAAe,IAAI,aAAa,CAAC,cAAc,CAAC,CAAC;CAClD;AAED,MAAM,MAAM,QAAQ,GAChB,WAAW,GACX,YAAY,GACZ,WAAW,GACX,MAAM,GACN,WAAW,GACX,YAAY,GACZ,KAAK,GACL,gBAAgB,GAChB,iBAAiB,GACjB,cAAc,GACd,kBAAkB,GAClB,gBAAgB,CAAC;AAErB,MAAM,WAAW,cAAc;IAC7B,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,+DAA+D;IAC/D,gBAAgB,EAAE,OAAO,CAAC;IAC1B,0DAA0D;IAC1D,gBAAgB,EAAE,OAAO,CAAC;CAC3B"}

package/dist/providers/primitives/capability/toolAccess.js

@@ -0,0 +1,16 @@
+/**
+ * ToolAccess — whether the provider can invoke tools at all, and which kinds.
+ *
+ * Tool inventory and registration. Distinct from `ToolAllowlist` which
+ * gates which registered tools are usable per session.
+ *
+ * Maps to:
+ *   - Claude: built-in tools (Read, Edit, Bash, Write, ...) + MCP-registered
+ *   - Codex: built-in tools + MCP-registered + plugin-registered
+ *
+ * Providers expose a list of tool kinds they support. The abstraction
+ * groups them into broad categories so callers can ask "does this provider
+ * support web access?" without enumerating specific tool names.
+ */
+export {};
+//# sourceMappingURL=toolAccess.js.map

package/dist/providers/primitives/capability/toolAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolAccess.js","sourceRoot":"","sources":["../../../../src/providers/primitives/capability/toolAccess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/providers/primitives/capability/toolAllowlist.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ToolAllowlist — restrict which tools a session may invoke.
+ *
+ * Composes with the session-establishment primitives — when starting a
+ * session, the caller passes a constructed `ToolAllowlistSpec` and the
+ * adapter applies it provider-natively.
+ *
+ * Maps to:
+ *   - Claude: `--allowed-tools` CLI flag + `.claude/settings.json` policy
+ *   - Codex: `mcp_servers.<id>` allowlist + sandbox-mode gating; identity
+ *     match (command/url value) is part of the allowlist key, not just name
+ */
+import { CapabilityFlag } from '../../capabilities.js';
+export interface ToolAllowlist {
+    readonly capability: typeof CapabilityFlag.ToolAllowlist;
+    /** Construct a portable allowlist spec to pass to session starts. */
+    buildSpec(rules: ToolAllowlistRules): ToolAllowlistSpec;
+}
+/**
+ * Rules supplied by the caller, in portable form. The adapter translates
+ * to its native config shape.
+ */
+export interface ToolAllowlistRules {
+    /**
+     * Either explicit allow-list (only these are permitted) or deny-list
+     * (everything except these). Allow-list is more secure; default for
+     * untrusted contexts.
+     */
+    mode: 'allowlist' | 'denylist';
+    /** Tool kinds (broad categories) covered by this rule set. */
+    toolKinds: ReadonlyArray<import('./toolAccess.js').ToolKind>;
+    /**
+     * Specific tool names, when finer-grained control is needed. Adapter
+     * matches against its native tool names. Cross-provider portability
+     * suffers when using this — prefer toolKinds when possible.
+     */
+    toolNames?: ReadonlyArray<string>;
+    /**
+     * For MCP servers, an additional identity check (command path or URL
+     * value). Required by Codex; ignored by Claude. Including it never hurts
+     * portability — it's silently ignored by adapters that don't enforce it.
+     */
+    mcpIdentities?: ReadonlyArray<{
+        name: string;
+        commandOrUrl: string;
+    }>;
+}
+/**
+ * Opaque allowlist spec to pass to session-starting primitives. The shape
+ * is intentionally opaque to callers — each adapter knows how to interpret
+ * its own spec.
+ */
+export type ToolAllowlistSpec = Readonly<{
+    readonly __brand: 'ToolAllowlistSpec';
+    readonly rules: ToolAllowlistRules;
+}>;
+//# sourceMappingURL=toolAllowlist.d.ts.map

package/dist/providers/primitives/capability/toolAllowlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolAllowlist.d.ts","sourceRoot":"","sources":["../../../../src/providers/primitives/capability/toolAllowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,OAAO,cAAc,CAAC,aAAa,CAAC;IAEzD,qEAAqE;IACrE,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,iBAAiB,CAAC;CACzD;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,IAAI,EAAE,WAAW,GAAG,UAAU,CAAC;IAC/B,8DAA8D;IAC9D,SAAS,EAAE,aAAa,CAAC,OAAO,iBAAiB,EAAE,QAAQ,CAAC,CAAC;IAC7D;;;;OAIG;IACH,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAClC;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACvE;AAED;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;CACpC,CAAC,CAAC"}

package/dist/providers/primitives/capability/toolAllowlist.js

@@ -0,0 +1,14 @@
+/**
+ * ToolAllowlist — restrict which tools a session may invoke.
+ *
+ * Composes with the session-establishment primitives — when starting a
+ * session, the caller passes a constructed `ToolAllowlistSpec` and the
+ * adapter applies it provider-natively.
+ *
+ * Maps to:
+ *   - Claude: `--allowed-tools` CLI flag + `.claude/settings.json` policy
+ *   - Codex: `mcp_servers.<id>` allowlist + sandbox-mode gating; identity
+ *     match (command/url value) is part of the allowlist key, not just name
+ */
+export {};
+//# sourceMappingURL=toolAllowlist.js.map

package/dist/providers/primitives/capability/toolAllowlist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolAllowlist.js","sourceRoot":"","sources":["../../../../src/providers/primitives/capability/toolAllowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/providers/primitives/capability/webAccess.d.ts

@@ -0,0 +1,45 @@
+/**
+ * WebAccess — agent's ability to fetch URLs and search the web.
+ *
+ * Maps to:
+ *   - Claude: built-in `WebFetch` and `WebSearch` tools
+ *   - Codex: `web_search` (on by default, cached), toggleable via
+ *     `permissions.<name>.network`
+ *
+ * Composes with PathAllowlist's network analog (currently inline here, not a
+ * separate primitive — if it grows, factor out). Allows domain allow/deny
+ * lists and a toggle for whether the agent may search vs. only fetch known URLs.
+ */
+import { CapabilityFlag } from '../../capabilities.js';
+export interface WebAccess {
+    readonly capability: typeof CapabilityFlag.WebAccess;
+    /** Build a portable web-access spec for session establishment. */
+    buildSpec(rules: WebAccessRules): WebAccessSpec;
+    /** Whether this provider supports web search (vs. only direct fetch). */
+    supportsSearch(): boolean;
+}
+export interface WebAccessRules {
+    /** Whether the session may fetch arbitrary URLs. Default true. */
+    allowFetch?: boolean;
+    /** Whether the session may search the web. Default true. */
+    allowSearch?: boolean;
+    /**
+     * If non-empty, fetches are restricted to these domains (and subdomains).
+     * Search results are filtered to these domains where the provider supports it.
+     */
+    domainAllow?: ReadonlyArray<string>;
+    /** Domains always denied. Deny wins on conflict. */
+    domainDeny?: ReadonlyArray<string>;
+    /**
+     * Whether the provider's prompt-injection protections are required.
+     * Anthropic's WebFetch warns the model about untrusted content; Codex's
+     * web_search does similar. Default true; set false only for trusted
+     * fetches like internal documentation.
+     */
+    promptInjectionProtection?: boolean;
+}
+export type WebAccessSpec = Readonly<{
+    readonly __brand: 'WebAccessSpec';
+    readonly rules: WebAccessRules;
+}>;
+//# sourceMappingURL=webAccess.d.ts.map

package/dist/providers/primitives/capability/webAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webAccess.d.ts","sourceRoot":"","sources":["../../../../src/providers/primitives/capability/webAccess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,UAAU,EAAE,OAAO,cAAc,CAAC,SAAS,CAAC;IAErD,kEAAkE;IAClE,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,aAAa,CAAC;IAEhD,yEAAyE;IACzE,cAAc,IAAI,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,kEAAkE;IAClE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC,oDAAoD;IACpD,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;CAChC,CAAC,CAAC"}

package/dist/providers/primitives/capability/webAccess.js

@@ -0,0 +1,14 @@
+/**
+ * WebAccess — agent's ability to fetch URLs and search the web.
+ *
+ * Maps to:
+ *   - Claude: built-in `WebFetch` and `WebSearch` tools
+ *   - Codex: `web_search` (on by default, cached), toggleable via
+ *     `permissions.<name>.network`
+ *
+ * Composes with PathAllowlist's network analog (currently inline here, not a
+ * separate primitive — if it grows, factor out). Allows domain allow/deny
+ * lists and a toggle for whether the agent may search vs. only fetch known URLs.
+ */
+export {};
+//# sourceMappingURL=webAccess.js.map

package/dist/providers/primitives/capability/webAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webAccess.js","sourceRoot":"","sources":["../../../../src/providers/primitives/capability/webAccess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/providers/primitives/control/authCredentialInjection.d.ts

@@ -0,0 +1,64 @@
+/**
+ * AuthCredentialInjection — inject the right credentials at session-spawn time.
+ *
+ * Different providers use different env vars and different credential
+ * formats. This primitive lets callers specify "use this credential" in a
+ * provider-agnostic way; the adapter resolves to the correct mechanism.
+ *
+ * Maps to:
+ *   - Claude: `CLAUDE_CODE_OAUTH_TOKEN` (for `sk-ant-oat...` subscription
+ *     OAuth) or `ANTHROPIC_API_KEY` (for `sk-ant-api...` direct API)
+ *   - Codex: `CODEX_API_KEY` env var, `codex login --with-api-key`,
+ *     or OAuth via `codex login`
+ *
+ * Distinct from CredentialStorageProvider (which manages persistent
+ * storage) — this primitive is about injection at spawn time.
+ */
+import type { CancellationOptions } from '../../types.js';
+import { CapabilityFlag } from '../../capabilities.js';
+export interface AuthCredentialInjection {
+    readonly capability: typeof CapabilityFlag.AuthCredentialInjection;
+    /**
+     * Build a portable credential spec to pass to session-start methods.
+     * Adapter resolves to its native env-var routing.
+     */
+    buildSpec(credential: ProviderCredential): AuthCredentialSpec;
+    /**
+     * Validate that a credential is well-formed for this provider. Returns
+     * null if valid, or an error message describing what's wrong. Does NOT
+     * verify the credential actually authenticates — that requires a live
+     * call against the provider.
+     */
+    validate(credential: ProviderCredential): string | null;
+    /**
+     * Test the credential against the provider with a no-op call. Resolves
+     * if valid; rejects with AuthError if invalid. Costs one API call.
+     */
+    probe(credential: ProviderCredential, options?: CancellationOptions): Promise<void>;
+}
+export type ProviderCredential = 
+/** OAuth subscription token (Anthropic Max, OpenAI ChatGPT). */
+{
+    kind: 'oauth-subscription';
+    token: string;
+}
+/** Direct API key (Anthropic API, OpenAI API). */
+ | {
+    kind: 'api-key';
+    key: string;
+}
+/** Bearer token for an arbitrary endpoint (custom-model-provider, gateway). */
+ | {
+    kind: 'bearer';
+    token: string;
+    endpoint?: string;
+}
+/** No authentication (purely local model). */
+ | {
+    kind: 'none';
+};
+export type AuthCredentialSpec = Readonly<{
+    readonly __brand: 'AuthCredentialSpec';
+    readonly credential: ProviderCredential;
+}>;
+//# sourceMappingURL=authCredentialInjection.d.ts.map

package/dist/providers/primitives/control/authCredentialInjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authCredentialInjection.d.ts","sourceRoot":"","sources":["../../../../src/providers/primitives/control/authCredentialInjection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,UAAU,EAAE,OAAO,cAAc,CAAC,uBAAuB,CAAC;IAEnE;;;OAGG;IACH,SAAS,CAAC,UAAU,EAAE,kBAAkB,GAAG,kBAAkB,CAAC;IAE9D;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,kBAAkB,GAAG,MAAM,GAAG,IAAI,CAAC;IAExD;;;OAGG;IACH,KAAK,CACH,UAAU,EAAE,kBAAkB,EAC9B,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAED,MAAM,MAAM,kBAAkB;AAC5B,gEAAgE;AAC9D;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AAC/C,kDAAkD;GAChD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE;AAClC,+EAA+E;GAC7E;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE;AACtD,8CAA8C;GAC5C;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAErB,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;CACzC,CAAC,CAAC"}

package/dist/providers/primitives/control/authCredentialInjection.js

@@ -0,0 +1,18 @@
+/**
+ * AuthCredentialInjection — inject the right credentials at session-spawn time.
+ *
+ * Different providers use different env vars and different credential
+ * formats. This primitive lets callers specify "use this credential" in a
+ * provider-agnostic way; the adapter resolves to the correct mechanism.
+ *
+ * Maps to:
+ *   - Claude: `CLAUDE_CODE_OAUTH_TOKEN` (for `sk-ant-oat...` subscription
+ *     OAuth) or `ANTHROPIC_API_KEY` (for `sk-ant-api...` direct API)
+ *   - Codex: `CODEX_API_KEY` env var, `codex login --with-api-key`,
+ *     or OAuth via `codex login`
+ *
+ * Distinct from CredentialStorageProvider (which manages persistent
+ * storage) — this primitive is about injection at spawn time.
+ */
+export {};
+//# sourceMappingURL=authCredentialInjection.js.map

package/dist/providers/primitives/control/authCredentialInjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authCredentialInjection.js","sourceRoot":"","sources":["../../../../src/providers/primitives/control/authCredentialInjection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG"}

package/dist/providers/primitives/control/compactionLifecycle.d.ts

@@ -0,0 +1,68 @@
+/**
+ * CompactionLifecycle — observe and respond to context compaction.
+ *
+ * As a session grows long, the provider's context window fills and the
+ * agent needs to compact. Some providers emit a PreCompact hook event
+ * (Claude); others compact silently when a threshold is reached (Codex).
+ * The abstraction presents a uniform "pre-compact" observation point so
+ * consumers can persist resumption state regardless of provider.
+ *
+ * Maps to:
+ *   - Claude: PreCompact hook event + /tmp/claude-session-<id>/compacting
+ *     marker file. Capability flag `PreCompactHook` is true.
+ *   - Codex: auto-compact at `effective_window - 13k` tokens; no hook
+ *     event. Adapter SYNTHESIZES the pre-compact signal by polling
+ *     `turn.completed.usage.context_window_used` and emitting the
+ *     observation when crossing a threshold. Capability flag
+ *     `PreCompactHook` is false; the synthesized notice is best-effort.
+ *
+ * Used by Instar's existing CompactionSentinel + SessionMigrator. Lets
+ * sessions emit their working state to a resume payload before the
+ * compaction happens, so the next round picks up cleanly.
+ */
+import type { CancellationOptions, ProviderSpecific, SessionHandle } from '../../types.js';
+import { CapabilityFlag } from '../../capabilities.js';
+export interface CompactionLifecycle {
+    readonly capability: typeof CapabilityFlag.CompactionLifecycle;
+    /** Whether the provider has a native pre-compact hook. */
+    hasNativePreCompactHook(): boolean;
+    /**
+     * Subscribe to pre-compaction notifications. Adapter delivers events
+     * before compaction happens (native or synthesized).
+     */
+    subscribePreCompact(session: SessionHandle, options?: CancellationOptions): AsyncIterable<PreCompactNotice>;
+    /** Subscribe to post-compaction notifications (always synthesized today). */
+    subscribePostCompact(session: SessionHandle, options?: CancellationOptions): AsyncIterable<PostCompactNotice>;
+    /**
+     * Manually trigger compaction. Maps to Claude's `/compact` slash command
+     * or Codex's `thread/compact/start` JSON-RPC method.
+     */
+    triggerCompact(session: SessionHandle, options?: CancellationOptions): Promise<void>;
+}
+export interface PreCompactNotice {
+    session: SessionHandle;
+    /** ISO 8601 UTC timestamp of the notice. */
+    timestamp: string;
+    /** Whether this came from a native hook or was synthesized. */
+    source: 'native' | 'synthesized';
+    /** Estimated tokens used (if available). */
+    contextWindowUsed?: number;
+    /** Estimated tokens until forced compaction (if available). */
+    remainingBeforeForced?: number;
+    /**
+     * Caller-supplied "save state before compaction" hook. Adapters that
+     * support delaying compaction until the caller has saved (Claude's
+     * pre-compact hook can return a wait directive) honor this. Others
+     * complete the save best-effort before compaction begins.
+     */
+    saveState?: (payload: unknown) => Promise<void>;
+    providerSpecific?: ProviderSpecific;
+}
+export interface PostCompactNotice {
+    session: SessionHandle;
+    timestamp: string;
+    /** Estimated tokens reclaimed by the compaction. */
+    tokensReclaimed?: number;
+    providerSpecific?: ProviderSpecific;
+}
+//# sourceMappingURL=compactionLifecycle.d.ts.map

package/dist/providers/primitives/control/compactionLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compactionLifecycle.d.ts","sourceRoot":"","sources":["../../../../src/providers/primitives/control/compactionLifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC3F,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,OAAO,cAAc,CAAC,mBAAmB,CAAC;IAE/D,0DAA0D;IAC1D,uBAAuB,IAAI,OAAO,CAAC;IAEnC;;;OAGG;IACH,mBAAmB,CACjB,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,aAAa,CAAC,gBAAgB,CAAC,CAAC;IAEnC,6EAA6E;IAC7E,oBAAoB,CAClB,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAEpC;;;OAGG;IACH,cAAc,CACZ,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,MAAM,EAAE,QAAQ,GAAG,aAAa,CAAC;IACjC,4CAA4C;IAC5C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,+DAA+D;IAC/D,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,aAAa,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC"}

package/dist/providers/primitives/control/compactionLifecycle.js

@@ -0,0 +1,24 @@
+/**
+ * CompactionLifecycle — observe and respond to context compaction.
+ *
+ * As a session grows long, the provider's context window fills and the
+ * agent needs to compact. Some providers emit a PreCompact hook event
+ * (Claude); others compact silently when a threshold is reached (Codex).
+ * The abstraction presents a uniform "pre-compact" observation point so
+ * consumers can persist resumption state regardless of provider.
+ *
+ * Maps to:
+ *   - Claude: PreCompact hook event + /tmp/claude-session-<id>/compacting
+ *     marker file. Capability flag `PreCompactHook` is true.
+ *   - Codex: auto-compact at `effective_window - 13k` tokens; no hook
+ *     event. Adapter SYNTHESIZES the pre-compact signal by polling
+ *     `turn.completed.usage.context_window_used` and emitting the
+ *     observation when crossing a threshold. Capability flag
+ *     `PreCompactHook` is false; the synthesized notice is best-effort.
+ *
+ * Used by Instar's existing CompactionSentinel + SessionMigrator. Lets
+ * sessions emit their working state to a resume payload before the
+ * compaction happens, so the next round picks up cleanly.
+ */
+export {};
+//# sourceMappingURL=compactionLifecycle.js.map

package/dist/providers/primitives/control/compactionLifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compactionLifecycle.js","sourceRoot":"","sources":["../../../../src/providers/primitives/control/compactionLifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

package/dist/providers/primitives/control/contextScopeControl.d.ts

@@ -0,0 +1,67 @@
+/**
+ * ContextScopeControl — control what context the session loads at startup.
+ *
+ * Providers automatically load instruction files (CLAUDE.md / AGENTS.md)
+ * and settings from various scopes (user-global, project, current-dir).
+ * Sometimes callers want to exclude project context (e.g., for
+ * lightweight classification calls that shouldn't pick up the agent's
+ * personality).
+ *
+ * Maps to:
+ *   - Claude: `--setting-sources` CLI flag (e.g., `user` to exclude
+ *     project CLAUDE.md). The existing ClaudeCliIntelligenceProvider
+ *     uses this to keep judgment calls clean.
+ *   - Codex: `project_doc_max_bytes`, `project_doc_fallback_filenames`,
+ *     `trusted-project gating` in config.toml. AGENTS.md cascade is
+ *     root→cwd with override files (richer than Claude's monolithic).
+ *
+ * Asymmetric on cascade semantics: Claude has a flat priority (project >
+ * user > builtin), Codex has a layered cascade. The abstraction presents
+ * a uniform `scopes: ('builtin' | 'user' | 'project' | 'directory')[]`
+ * include-list; adapters translate.
+ */
+import type { CancellationOptions } from '../../types.js';
+import { CapabilityFlag } from '../../capabilities.js';
+export interface ContextScopeControl {
+    readonly capability: typeof CapabilityFlag.ContextScopeControl;
+    /** Build a portable scope spec for session establishment. */
+    buildSpec(scopes: ContextScopeRules): ContextScopeSpec;
+    /** Which scopes are available in this provider. */
+    supportedScopes(): ReadonlySet<ContextScope>;
+    /**
+     * Materialize a per-scope instruction file. Used during migration
+     * (writing CLAUDE.md when scaffolding) and during dynamic context
+     * injection (writing a temporary AGENTS.override.md).
+     */
+    writeInstructionFile(scope: ContextScope, path: string, content: string, options?: CancellationOptions): Promise<void>;
+}
+export type ContextScope = 
+/** Built-in defaults from the provider. */
+'builtin'
+/** User-global (~/.claude/CLAUDE.md, ~/.codex/AGENTS.md). */
+ | 'user'
+/** Project root (./CLAUDE.md, ./AGENTS.md). */
+ | 'project'
+/** Current working directory (when different from project root). */
+ | 'directory'
+/** Override file (Codex's AGENTS.override.md). */
+ | 'override';
+export interface ContextScopeRules {
+    /** Which scopes to include. Order = precedence; later wins. */
+    include: ReadonlyArray<ContextScope>;
+    /**
+     * Max bytes per scope (Codex enforces 32 KiB per AGENTS.md). Adapters
+     * that don't enforce silently ignore.
+     */
+    maxBytesPerScope?: number;
+    /**
+     * Optional fallback filenames the adapter should search if the canonical
+     * file is absent. Codex supports this natively; Claude ignores.
+     */
+    fallbackFilenames?: ReadonlyArray<string>;
+}
+export type ContextScopeSpec = Readonly<{
+    readonly __brand: 'ContextScopeSpec';
+    readonly rules: ContextScopeRules;
+}>;
+//# sourceMappingURL=contextScopeControl.d.ts.map

package/dist/providers/primitives/control/contextScopeControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextScopeControl.d.ts","sourceRoot":"","sources":["../../../../src/providers/primitives/control/contextScopeControl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,OAAO,cAAc,CAAC,mBAAmB,CAAC;IAE/D,6DAA6D;IAC7D,SAAS,CAAC,MAAM,EAAE,iBAAiB,GAAG,gBAAgB,CAAC;IAEvD,mDAAmD;IACnD,eAAe,IAAI,WAAW,CAAC,YAAY,CAAC,CAAC;IAE7C;;;;OAIG;IACH,oBAAoB,CAClB,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAED,MAAM,MAAM,YAAY;AACtB,2CAA2C;AACzC,SAAS;AACX,6DAA6D;GAC3D,MAAM;AACR,+CAA+C;GAC7C,SAAS;AACX,oEAAoE;GAClE,WAAW;AACb,kDAAkD;GAChD,UAAU,CAAC;AAEf,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IACrC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC3C;AAED,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC,CAAC,CAAC"}