@crewx/sdk 0.9.0-rc.16 → 0.9.0-rc.160

package/dist/plugins/sqlite-tracing.d.ts

@@ -1,15 +1,61 @@
 import { CrewxPlugin } from '../plugin';
 import type { Crewx } from '../facade/Crewx';
+export interface SqliteTracingMetrics {
+    flushCount: number;
+    flushedEntries: number;
+    maxQueueEntries: number;
+    maxQueueBytes: number;
+    appendFailureCount: number;
+    appendFailureEntries: number;
+    appendFailureBytes: number;
+    appendFailureByCode: Record<string, number>;
+    appendFailureByCause: Record<string, number>;
+    pendingQueueEntries: number;
+    pendingQueueBytes: number;
+}
+export interface SqliteTracingRunnerIdentity {
+    detachedRunner: boolean;
+    assignedTaskId?: string;
+}
+export interface OwnedTaskRun {
+    taskId: string;
+    runEpoch: number;
+    workspaceId: string | null;
+    ownership: 'runner' | 'caller';
+}
 export interface SqliteTracingPluginOptions {
     dbRoot?: string;
     version?: string;
+    runnerIdentity?: SqliteTracingRunnerIdentity;
+    inheritWorktreeOwner?: boolean;
 }
 export declare class SqliteTracingPlugin extends CrewxPlugin {
     readonly name = "sqlite-tracing";
     private unsubs;
     private readonly dbPath;
     private readonly version;
+    private readonly inheritWorktreeOwner;
+    private readonly runnerIdentity;
+    private taskRepo?;
+    private readonly heartbeatTaskIds;
+    private readonly ownedTaskRuns;
+    private readonly ignoredDetachedTaskIds;
+    private readonly queues;
+    private metrics;
     constructor(opts?: SqliteTracingPluginOptions);
     attach(crewx: Crewx): void;
     detach(_crewx: Crewx): void;
+    listOwnedRunningTasks(): OwnedTaskRun[];
+    stopOwnedRunningTasksForHostShutdown(): Promise<void>;
+    getMetrics(): SqliteTracingMetrics;
+    private resolveTaskId;
+    private recordOwnedTaskRun;
+    private removeOwnedTaskRun;
+    private enqueueLog;
+    private recoverPartialResult;
+    private handleStopRequested;
+    private flushTaskLogs;
+    private flushAllTaskLogs;
+    private clearAllTimers;
+    private recordAppendFailure;
 }

package/dist/process/index.d.ts

@@ -0,0 +1,2 @@
+export { checkProcessOwnership, checkProcessOwnershipAsync, probeProcessLiveness, terminateProcessTree, UNIX_PROCESS_POLL_INTERVAL_MS, UNIX_SIGKILL_CONFIRM_MS, UNIX_SIGTERM_GRACE_MS, } from './process-control.js';
+export type { ProcessCommandLineResult, ProcessCommandResult, ProcessCommandRunner, ProcessCommandRunnerAsync, ProcessControlOptions, ProcessLiveness, ProcessOwnership, ProcessTerminationResult, ProcessTerminationStatus, } from './process-control.js';

package/dist/process/index.js

@@ -0,0 +1 @@
+'use strict';var child_process=require('child_process');var P=3e3;var _=2e3,S=25,R=100;function p(e){return e instanceof Error?e:e===void 0?void 0:new Error(String(e))}function g(e){return typeof e=="object"&&e!==null&&"code"in e?String(e.code):void 0}function w(e){return Number.isSafeInteger(e)&&e>0}function v(e,t){try{let r=child_process.spawnSync(e,t,{encoding:"utf8",timeout:P,windowsHide:!0});return {status:r.status,stdout:typeof r.stdout=="string"?r.stdout:"",stderr:typeof r.stderr=="string"?r.stderr:"",error:r.error}}catch(r){return {status:null,stdout:"",stderr:"",error:p(r)}}}function O(e,t){return new Promise(r=>{let n;try{n=child_process.spawn(e,t,{windowsHide:!0});}catch(a){r({status:null,stdout:"",stderr:"",error:p(a)});return}let o="",i="",u=false,s,m=setTimeout(()=>{try{n.kill();}catch{}s({status:null,stdout:o,stderr:i,error:new Error(`Command timed out after ${P}ms`)});},P);s=a=>{u||(u=true,clearTimeout(m),r(a));},n.stdout?.setEncoding("utf8"),n.stderr?.setEncoding("utf8"),n.stdout?.on("data",a=>{o+=String(a);}),n.stderr?.on("data",a=>{i+=String(a);}),n.once("error",a=>{s({status:null,stdout:o,stderr:i,error:a});}),n.once("close",a=>{s({status:a,stdout:o,stderr:i});});})}async function L(e,t,r){return r.runCommandAsync?r.runCommandAsync(e,t):r.runCommand?r.runCommand(e,t):O(e,t)}function b(e){return new Promise(t=>{setTimeout(t,Math.max(0,e));})}function x(){return new Promise(e=>{setImmediate(e);})}function f(e,t=process.kill){try{return t(e,0),"alive"}catch(r){return g(r)==="ESRCH"?"not_found":g(r)==="EPERM"?"alive":"unknown"}}function M(e,t){if(!w(e))return {status:"unknown"};let r=t.platform??process.platform,n=t.runCommand??v,o=r==="win32"?"powershell.exe":"ps",i=r==="win32"?["-NoLogo","-NoProfile","-NonInteractive","-ExecutionPolicy","Bypass","-Command",`$p = Get-CimInstance -ClassName Win32_Process -Filter 'ProcessId = ${e}' -ErrorAction Stop; if ($null -ne $p) { [Console]::Write([string]$p.CommandLine) }`]:["-p",String(e),"-o","command="],u;try{u=n(o,i);}catch{return {status:"unknown"}}if(u.error||u.status!==0)return {status:"unknown"};let s=u.stdout.trim();return s?{status:"found",commandLine:s}:{status:"not_found"}}function N(e,t){let r=f(-e,t),n=f(e,t);return r==="alive"||n==="alive"?"alive":r==="unknown"||n==="unknown"?"unknown":"not_found"}async function h(e,t,r,n){let o=Math.max(0,r),i=Math.max(1,n.pollIntervalMs??S),u=Date.now()+o,s,m=o===0,a=n.sleep?Promise.resolve().then(()=>n.sleep(o)).then(()=>{},()=>{}):new Promise(c=>{s=setTimeout(c,o);});a.then(()=>{m=true;});try{for(await x();;){let c=N(e,t);if(c==="not_found")return c;let l=u-Date.now();if(m||l<=0)return c;await Promise.race([a,b(Math.min(i,l))]);}}finally{s!==void 0&&clearTimeout(s);}}async function y(e,t,r,n,o){let i=await h(e,t,o.hardConfirmMs??R,{...o,sleep:void 0});return i==="not_found"?r?{status:"not_found",pid:e,method:n}:{status:"terminated",pid:e,method:n}:i==="alive"?{status:"failed",pid:e,method:n,error:"Process is still running after termination attempt"}:{status:"failed",pid:e,method:n,error:"Unable to verify process termination"}}function A(e,t,r={}){let n=M(e,r);if(n.status!=="found")return n.status;let o=r.platform??process.platform,i=o==="win32"?n.commandLine.toLowerCase():n.commandLine;return t.filter(s=>s.trim().length>0).some(s=>{let m=o==="win32"?s.toLowerCase():s;return i.includes(m)})?"owned":"not_owned"}async function G(e,t,r={}){if(!w(e))return "unknown";let n=r.platform??process.platform,o=n==="win32"?"powershell.exe":"ps",i=n==="win32"?["-NoLogo","-NoProfile","-NonInteractive","-ExecutionPolicy","Bypass","-Command",`$p = Get-CimInstance -ClassName Win32_Process -Filter 'ProcessId = ${e}' -ErrorAction Stop; if ($null -ne $p) { [Console]::Write([string]$p.CommandLine) }`]:["-p",String(e),"-o","command="],u;try{u=await L(o,i,r);}catch{return "unknown"}if(u.error||u.status!==0)return "unknown";let s=u.stdout.trim();if(!s)return "not_found";let m=n==="win32"?s.toLowerCase():s;return t.filter(c=>c.trim().length>0).some(c=>{let l=n==="win32"?c.toLowerCase():c;return m.includes(l)})?"owned":"not_owned"}async function $(e,t={}){let r=t.platform??process.platform,n=r==="win32"?"taskkill":"process-group",o=d=>({status:"failed",pid:e,method:n,error:d});if(!w(e))return o("Invalid process ID");let i=t.kill??process.kill,u=f(e,i);if(u==="not_found")return {status:"not_found",pid:e,method:n};if(u!=="alive")return o("Unable to determine whether the process is alive");if(r==="win32"){let d;try{d=await L("taskkill",["/PID",String(e),"/T","/F"],t);}catch(k){d={status:null,stdout:"",stderr:"",error:p(k)};}let C=f(e,i);return C==="not_found"?d.status===0&&!d.error?{status:"terminated",pid:e,method:n}:{status:"not_found",pid:e,method:n}:o(C==="alive"?"Process is still running after termination attempt":"Unable to verify process termination")}let s,m=t.signal??"SIGKILL";try{i(-e,m);}catch(d){s=d;}if(m==="SIGKILL")return y(e,i,s,n,t);if(await h(e,i,t.graceMs??_,t)==="not_found")return s?{status:"not_found",pid:e,method:n}:{status:"terminated",pid:e,method:n};let c;try{i(-e,"SIGKILL");}catch(d){c=d;}let l=await y(e,i,c,n,t);return l.status==="terminated"?l:l.status==="not_found"?s?l:{status:"terminated",pid:e,method:n}:o(l.error??"Process termination failed")}exports.UNIX_PROCESS_POLL_INTERVAL_MS=S;exports.UNIX_SIGKILL_CONFIRM_MS=R;exports.UNIX_SIGTERM_GRACE_MS=_;exports.checkProcessOwnership=A;exports.checkProcessOwnershipAsync=G;exports.probeProcessLiveness=f;exports.terminateProcessTree=$;

package/dist/process/process-control.d.ts

@@ -0,0 +1,41 @@
+export type ProcessLiveness = 'alive' | 'not_found' | 'unknown';
+export type ProcessOwnership = 'owned' | 'not_owned' | 'not_found' | 'unknown';
+export type ProcessTerminationStatus = 'terminated' | 'not_found' | 'failed';
+export interface ProcessCommandResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+}
+export type ProcessCommandRunner = (command: string, args: string[]) => ProcessCommandResult;
+export type ProcessCommandRunnerAsync = (command: string, args: string[]) => Promise<ProcessCommandResult>;
+export interface ProcessControlOptions {
+    platform?: NodeJS.Platform;
+    kill?: typeof process.kill;
+    runCommand?: ProcessCommandRunner;
+    runCommandAsync?: ProcessCommandRunnerAsync;
+    sleep?: (ms: number) => void | PromiseLike<void>;
+    graceMs?: number;
+    pollIntervalMs?: number;
+    hardConfirmMs?: number;
+}
+export interface ProcessCommandLineResult {
+    status: 'found' | 'not_found' | 'unknown';
+    commandLine?: string;
+}
+export interface ProcessTerminationResult {
+    status: ProcessTerminationStatus;
+    pid: number;
+    method: 'taskkill' | 'process-group';
+    error?: string;
+}
+export declare const POSIX_COOPERATIVE_STOP_SIGNAL: NodeJS.Signals;
+export declare const UNIX_SIGTERM_GRACE_MS = 2000;
+export declare const UNIX_PROCESS_POLL_INTERVAL_MS = 25;
+export declare const UNIX_SIGKILL_CONFIRM_MS = 100;
+export declare function probeProcessLiveness(pid: number, kill?: typeof process.kill): ProcessLiveness;
+export declare function checkProcessOwnership(pid: number, markers: readonly string[], options?: ProcessControlOptions): ProcessOwnership;
+export declare function checkProcessOwnershipAsync(pid: number, markers: readonly string[], options?: ProcessControlOptions): Promise<ProcessOwnership>;
+export declare function terminateProcessTree(pid: number, options?: ProcessControlOptions & {
+    signal?: NodeJS.Signals;
+}): Promise<ProcessTerminationResult>;

package/dist/prompt/tag-names.d.ts

@@ -0,0 +1,22 @@
+export declare const PROMPT_TAGS: {
+    readonly crewxSystemPrompt: "crewx_system_prompt";
+    readonly systemPrompt: "system_prompt";
+    readonly threadContext: "crewx_thread_context";
+    readonly threadState: "thread_state";
+    readonly apps: "apps";
+    readonly appsGuidance: "apps_guidance";
+    readonly availableApps: "available_apps";
+    readonly crewxUiState: "crewx_ui_state";
+    readonly highlights: "highlights";
+    readonly highlight: "highlight";
+    readonly omittedTurns: "omitted_turns";
+    readonly messages: "messages";
+    readonly message: "message";
+    readonly userQuery: "user_query";
+    readonly execOutput: "exec_output";
+};
+export declare const LEGACY_PROMPT_TAGS: {
+    readonly conversationHistory: "conversation_history";
+    readonly semanticContinuity: "semantic_continuity";
+    readonly execOutput: "exec-output";
+};

package/dist/provider/acp/connection.d.ts

@@ -6,6 +6,7 @@ export interface AcpConnectionOptions {
     env?: Record<string, string>;
     cwd?: string;
     timeoutMs?: number;
+    idleMs?: number;
     onStderr?: (line: string) => void;
     onPid?: (pid: number) => void;
     configOptions?: Record<string, string>;
@@ -17,7 +18,12 @@ export declare class AcpConnection {
     private disposed;
     private stderrBuffer;
     private collectedStderr;
+    private stderrDecoder;
+    private stderrDecodeChain;
     private pendingUpdateCallback;
+    private idleWatchdog;
+    private idleReject;
+    private idlePromise;
     private authMethods;
     private _initResponse;
     get initResponse(): InitializeResponse | null;

package/dist/provider/acp/meta.d.ts

@@ -1,3 +1,7 @@
+import type { ProviderDefaultProfile } from '../models.js';
+import type { ProviderOptionSpec } from '../models.js';
+import type { ModelTier } from '../../config/models.generated.js';
+import type { ModelApiPricing } from '../../config/pricing.types.js';
 import type { InitializeResponse, NewSessionResponse } from './types.js';
 export interface AcpProviderMetaResult {
     id: string;
@@ -11,11 +15,18 @@ export interface AcpProviderMetaResult {
     models: Array<{
         id: string;
         name?: string;
+        description?: string;
+        contextWindowTokens?: number;
+        tier?: ModelTier;
+        recommended?: boolean;
+        apiPricing?: ModelApiPricing;
     }>;
     modelOverrides?: Record<string, {
         effort?: string[];
         defaultEffort?: string;
     }>;
+    providerOptions?: ProviderOptionSpec[];
+    defaults?: ProviderDefaultProfile;
     capabilities: Record<string, boolean>;
 }
 declare function extractProviderMeta(adapterId: string, displayName: string | undefined, initResponse: InitializeResponse, sessionResponse: NewSessionResponse): AcpProviderMetaResult;

package/dist/provider/bridge.d.ts

@@ -1,11 +1,13 @@
 import type { CliProviderAdapter } from './cli/adapter.types.js';
 export declare function parseStreamJsonOutput(raw: string): string;
 export declare function parseResultEventUsage(raw: string): ProviderUsage | null;
-export { ProviderError, IdleTimeoutError, TotalTimeoutError, type ProviderErrorCode, type ProviderErrorKind, type ProviderErrorOptions, } from './errors.js';
+export { ProviderError, IdleTimeoutError, TotalTimeoutError, type ProviderErrorCode, type ProviderErrorKind, type ProviderErrorOptions, ResumeTimeoutError, } from './errors.js';
 export declare function shouldFallbackToGhCopilot(providerId: string, err: unknown, platform?: NodeJS.Platform): boolean;
 export declare const KILL_GRACE_MS = 2000;
 export interface RunCliProcessOptions {
     timeoutMs?: number;
+    idleMs?: number;
+    resumeSessionId?: string;
     env?: Record<string, string>;
     cwd?: string;
     onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
@@ -54,10 +56,13 @@ export interface ProviderQueryOptions {
     model?: string;
     effort?: string;
     mode?: string;
+    providerOptions?: Record<string, unknown>;
     context?: string;
     systemPrompt?: string;
     additionalArgs?: string[];
     resumeSessionId?: string;
+    providerSessionId?: string;
+    onProviderSessionId?: (id: string) => void;
     onOutput?: (line: string, level: 'stdout' | 'stderr') => void;
     onPid?: (pid: number) => void;
     onCommand?: (command: string) => void;
@@ -68,6 +73,7 @@ export interface ProviderQueryOptions {
     env?: Record<string, string>;
     cwd?: string;
     timeoutMs?: number;
+    idleMs?: number;
     configOptions?: Record<string, string>;
     tools?: import('../facade/Crewx').ToolDefinition[];
     maxSteps?: number;

package/dist/provider/classify-task-error.d.ts

@@ -0,0 +1,2 @@
+import type { TaskErrorProjection } from './task-error.types.js';
+export declare function classifyTaskError(input: unknown): TaskErrorProjection;

package/dist/provider/cli/adapter.types.d.ts

@@ -1,18 +1,29 @@
 import type { ProviderQueryOptions, ProviderUsage } from '../bridge.js';
 import type { TaskLogEntry } from '../../types/task-log.types.js';
+import type { ModelTier } from '../../config/models.generated.js';
 import { ProviderError } from '../errors.js';
+export interface ParseEventContext {
+    readonly rowIndex: number;
+    readonly state: Map<string, unknown>;
+}
 export interface CliProviderAdapter {
     readonly command: string;
+    createSessionId?(): string;
     readonly meta?: {
         displayName?: string;
         models?: Array<{
             id: string;
             name?: string;
+            description?: string;
+            contextWindowTokens?: number;
+            tier?: ModelTier;
         }>;
         defaultTimeoutMs?: {
             query?: number;
             execute?: number;
         };
+        defaultIdleMs?: number;
+        defaultResumeTimeoutMs?: number;
         capabilities?: {
             resume?: boolean;
             image?: boolean;
@@ -27,13 +38,14 @@ export interface CliProviderAdapter {
         env?: Record<string, string>;
     };
     extractText(stdout: string): string;
+    extractPartialText?(stdout: string): string | undefined;
     extractFailure?(line: string): Error | null;
-    interpretExit?(code: number, stderr: string): Error | null;
+    interpretExit?(code: number, stderr: string, stdout?: string): Error | null;
     parseResultMeta?(stdout: string): {
         usage?: ProviderUsage | null;
         model?: string | null;
     };
-    parseEvent?(line: string, timestamp?: string): TaskLogEntry[];
+    parseEvent?(line: string, timestamp?: string, context?: ParseEventContext): TaskLogEntry[];
     suppressOutputLine?(line: string): boolean;
 }
 export declare class RateLimitError extends ProviderError {

package/dist/provider/cli/adapters/agent-call.util.d.ts

@@ -1,3 +1,3 @@
 import type { TaskLogEntry } from '../../../types/task-log.types';
 export declare function isAgentCallCommand(command: string): boolean;
-export declare function parseAgentCall(timestamp: string, command: string): TaskLogEntry;
+export declare function parseAgentCall(timestamp: string, command: string, toolUseId?: string): TaskLogEntry;

package/dist/provider/cli/adapters/cli-knob.util.d.ts

@@ -6,3 +6,10 @@ export declare function codexModeArgs(mode?: string): string[];
 export declare function codexResumeModeArgs(mode?: string): string[];
 export declare function codexEffortArgs(effort?: string): string[];
 export declare function claudeModeArgs(mode?: string): string[];
+export declare function claudeEffortArgs(effort?: string): string[];
+export declare function grokModeArgs(mode?: string): string[];
+export declare function grokAlwaysApproveArgs(alwaysApprove?: unknown): string[];
+export declare function grokSandboxArgs(sandbox?: unknown, onWarning?: (message: string) => void): string[];
+export declare function grokEffortArgs(effort?: string): string[];
+export declare function antigravityModeArgs(mode?: string): string[];
+export declare function antigravityEffortArgs(effort?: string): string[];

package/dist/provider/cli/adapters/codex-item.d.ts

@@ -0,0 +1 @@
+export declare function isCodexDisplaySkippedStart(value: unknown): boolean;

package/dist/provider/cli/adapters/event-timestamp.util.d.ts

@@ -0,0 +1 @@
+export declare function resolveEventTimestamp(parsed: unknown, fallbackTs: string): string;

package/dist/provider/cli/adapters/grok.d.ts

@@ -0,0 +1,2 @@
+import type { CliProviderAdapter } from '../adapter.types.js';
+export declare const grokAdapter: CliProviderAdapter;

package/dist/provider/cli/adapters/index.d.ts

@@ -5,6 +5,11 @@ export { copilotAdapter } from './copilot.js';
 export { codexAdapter } from './codex.js';
 export { opencodeAdapter } from './opencode.js';
 export { antigravityAdapter } from './antigravity.js';
+export { grokAdapter } from './grok.js';
 export { isAgentCallCommand, parseAgentCall } from './agent-call.util.js';
 export declare const BUILTIN_ADAPTERS: Record<string, CliProviderAdapter>;
 export declare function parseStdoutEvent(timestamp: string, message: string, providerId?: string): TaskLogEntry[];
+export interface LogParseSession {
+    parse(timestamp: string, message: string, rowIndex: number): TaskLogEntry[];
+}
+export declare function createLogParseSession(providerId?: string): LogParseSession;

package/dist/provider/cli/index.d.ts

@@ -1,3 +1,4 @@
-export { BUILTIN_ADAPTERS, parseStdoutEvent, claudeAdapter, copilotAdapter, codexAdapter, opencodeAdapter, antigravityAdapter, isAgentCallCommand, parseAgentCall, } from './adapters/index.js';
-export type { CliProviderAdapter } from './adapter.types.js';
+export { BUILTIN_ADAPTERS, parseStdoutEvent, createLogParseSession, claudeAdapter, copilotAdapter, codexAdapter, opencodeAdapter, antigravityAdapter, grokAdapter, isAgentCallCommand, parseAgentCall, } from './adapters/index.js';
+export type { CliProviderAdapter, ParseEventContext } from './adapter.types.js';
 export { RateLimitError } from './adapter.types.js';
+export type { LogParseSession } from './adapters/index.js';

package/dist/provider/cli/meta.d.ts

@@ -1,4 +1,5 @@
 import type { AcpProviderMetaResult } from '../acp/meta.js';
+import type { ModelTier } from '../../config/models.generated.js';
 import type { CliProviderAdapter } from './adapter.types.js';
 export declare function queryOpencodeModels(): Promise<Array<{
     id: string;
@@ -6,6 +7,10 @@ export declare function queryOpencodeModels(): Promise<Array<{
 export declare function cliAdapterMetaToProviderMeta(key: string, adapter: CliProviderAdapter, overrideModels?: Array<{
     id: string;
     name?: string;
+    description?: string;
+    contextWindowTokens?: number;
+    tier?: ModelTier;
+    recommended?: boolean;
 }>): AcpProviderMetaResult | null;
 export declare function queryAllCliProviderMetas(options?: {
     includeOpencodeRuntimeModels?: boolean;

package/dist/provider/cli/protocol-envelope.d.ts

@@ -0,0 +1,3 @@
+export declare function shouldSkipRawStdoutJsonFallback(message: string, providerId?: string): boolean;
+export declare function isProtocolOnlyText(text: string, providerId?: string): boolean;
+export declare function isMetadataOnlyProtocolLine(message: string, providerId: string): boolean;

package/dist/provider/errors.d.ts

@@ -1,5 +1,5 @@
 export type ProviderErrorKind = 'transient' | 'permanent' | 'config';
-export type ProviderErrorCode = 'QUOTA_EXHAUSTED' | 'RATE_LIMITED' | 'EMPTY_OUTPUT' | 'AUTH_REQUIRED' | 'MODEL_UNAVAILABLE' | 'TIMEOUT_IDLE' | 'TIMEOUT_TOTAL' | 'PROVIDER_NOT_FOUND' | 'INVALID_PROVIDER_FORMAT' | 'PROVIDER_CRASHED' | 'UNKNOWN';
+export type ProviderErrorCode = 'QUOTA_EXHAUSTED' | 'RATE_LIMITED' | 'EMPTY_OUTPUT' | 'AUTH_REQUIRED' | 'MODEL_UNAVAILABLE' | 'TIMEOUT_IDLE' | 'TIMEOUT_TOTAL' | 'TIMEOUT_RESUME' | 'PROVIDER_NOT_FOUND' | 'INVALID_PROVIDER_FORMAT' | 'PROVIDER_CRASHED' | 'UNKNOWN';
 export interface ProviderErrorOptions {
     code?: ProviderErrorCode;
     kind?: ProviderErrorKind;
@@ -10,6 +10,7 @@ export declare class ProviderError extends Error {
     readonly code: ProviderErrorCode;
     readonly kind?: ProviderErrorKind;
     readonly retryAfterMs?: number;
+    stdout?: string;
     constructor(message: string, providerStr: string, options?: ProviderErrorOptions);
 }
 export declare class IdleTimeoutError extends ProviderError {
@@ -18,3 +19,6 @@ export declare class IdleTimeoutError extends ProviderError {
 export declare class TotalTimeoutError extends ProviderError {
     constructor(message: string, providerStr: string);
 }
+export declare class ResumeTimeoutError extends ProviderError {
+    constructor(message: string, providerStr: string);
+}

package/dist/provider/idle-watchdog.d.ts

@@ -0,0 +1,19 @@
+export interface IdleWatchdogOptions {
+    timeoutMs: number;
+    onIdle: () => void;
+    now?: () => number;
+}
+export declare class IdleWatchdog {
+    private readonly timeoutMs;
+    private readonly onIdleCb;
+    private readonly now;
+    private timer;
+    private lastActivity;
+    private settled;
+    constructor(options: IdleWatchdogOptions);
+    start(): void;
+    refresh(): void;
+    stop(): void;
+    private scheduleCheck;
+    private fireIdle;
+}

package/dist/provider/models.d.ts

@@ -1,9 +1,22 @@
-import { type ModelCatalogEntry, type ProviderCatalogEntry, type ProviderModeEntry, type ProviderModelOverride } from '../config/models.generated.js';
-export type { ModelCatalogEntry, ProviderCatalogEntry, ProviderModeEntry, ProviderModelOverride, } from '../config/models.generated.js';
+import { type ModelCatalogEntry, type ModelTier, type ProviderCatalogEntry, type ProviderDefaultProfile, type ProviderModeEntry, type ProviderModelOverride } from '../config/models.generated.js';
+import type { ModelApiPricing } from '../config/pricing.types.js';
+export type { ModelTier, ModelCatalogEntry, ProviderCatalogEntry, ProviderDefaultProfile, ProviderDefaults, ProviderModeEntry, ProviderOptionSpec, ProviderModelOverride, } from '../config/models.generated.js';
+export type ModelMergeEntry = {
+    id: string;
+    name?: string;
+    description?: string;
+    contextWindowTokens?: number;
+    tier?: ModelTier;
+    recommended?: boolean;
+    apiPricing?: ModelApiPricing;
+};
 export declare function setModelsOverride(providers: Record<string, ProviderCatalogEntry | ModelCatalogEntry[]>): void;
 export declare function clearModelsOverride(): void;
+export declare function setModelsDefaultsOverride(providers: Record<string, ProviderDefaultProfile>): void;
+export declare function clearModelsDefaultsOverride(): void;
 export declare function getProviderModels(provider: string): ModelCatalogEntry[];
 export declare function getProviderCatalog(provider: string): ProviderCatalogEntry;
+export declare function getProviderDefaultProfile(provider: string): ProviderDefaultProfile | undefined;
 export declare function getProviderModes(provider: string): ProviderModeEntry[];
 export declare function getProviderEffort(provider: string, model?: string): string[];
 export declare function getProviderModelOverrides(provider: string): Record<string, ProviderModelOverride>;
@@ -11,13 +24,5 @@ export declare function getClaudeModels(): ModelCatalogEntry[];
 export declare function getCodexModels(): ModelCatalogEntry[];
 export declare function getCopilotModels(): ModelCatalogEntry[];
 export declare function getAntigravityModels(): ModelCatalogEntry[];
-export declare function mergeModels(a: Array<{
-    id: string;
-    name?: string;
-}>, b: Array<{
-    id: string;
-    name?: string;
-}>): Array<{
-    id: string;
-    name?: string;
-}>;
+export declare function mergeModels(a: ModelMergeEntry[], b: ModelMergeEntry[]): ModelMergeEntry[];
+export declare function withApiPricing(models: ModelMergeEntry[]): ModelMergeEntry[];

package/dist/provider/order.d.ts

@@ -1,4 +1,4 @@
-export declare const PROVIDER_ORDER: readonly ["codex", "claude", "opencode", "antigravity", "copilot"];
+export declare const PROVIDER_ORDER: readonly ["codex", "claude", "grok", "opencode", "antigravity", "copilot"];
 export declare function providerRank(id: string): number;
 export declare function compareProviders(a: string, b: string): number;
 export declare function normalizeProviderId(provider?: string): string;

package/dist/provider/parse-usage.d.ts

@@ -3,4 +3,10 @@ export interface ParsedUsage {
     outputTokens: number;
     cachedInputTokens: number;
 }
+export interface ClaudePartialUsage {
+    inputTokens: number;
+    cachedInputTokens: number;
+    model?: string;
+}
+export declare function parseClaudePartialUsage(stdout: string): ClaudePartialUsage | undefined;
 export declare function parseUsage(stdout: string): ParsedUsage | undefined;

package/dist/provider/provider-selection.d.ts

@@ -0,0 +1,8 @@
+import type { CliProviderAdapter } from './cli/adapter.types.js';
+export declare function lookupCliAdapter(providerStr: string): CliProviderAdapter | undefined;
+export type ProviderAvailabilityDeps = {
+    lookupAdapter?: (providerStr: string) => CliProviderAdapter | undefined;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function isProviderAvailable(providerStr: string, deps?: ProviderAvailabilityDeps): boolean;
+export declare function selectAvailableProvider(providers: string | string[], deps?: ProviderAvailabilityDeps): string;

package/dist/provider/redact-technical-message.d.ts

@@ -0,0 +1 @@
+export declare function redactTechnicalMessage(value: unknown): string | undefined;

package/dist/provider/task-error.types.d.ts

@@ -0,0 +1,17 @@
+export type TaskErrorCode = 'USAGE_LIMITED' | 'CONTEXT_WINDOW_EXCEEDED' | 'INPUT_TOO_LARGE' | 'MODEL_NOT_SUPPORTED' | 'MODEL_AT_CAPACITY' | 'AUTH_REQUIRED' | 'CLI_NOT_AVAILABLE' | 'CLI_UPDATE_REQUIRED' | 'AGENT_NOT_FOUND' | 'PERMISSION_OR_TRUST' | 'TIMEOUT_OR_STUCK' | 'NETWORK_OR_PROVIDER_TRANSIENT' | 'PROVIDER_CONFIGURATION' | 'AGENT_MODE_RESTRICTED' | 'PROCESS_FAILED';
+export interface TaskErrorMeta {
+    resetAt?: string | number;
+    model?: string;
+    cliName?: string;
+    envKey?: string;
+    upstreamType?: string;
+    upstreamCode?: string | number;
+    mode?: string;
+    referenceId?: string;
+    technicalMessage?: string;
+}
+export interface TaskErrorProjection {
+    errorCode: TaskErrorCode | null;
+    errorProvider: string | null;
+    errorMeta?: TaskErrorMeta;
+}

package/dist/publish/constants.d.ts

@@ -0,0 +1,6 @@
+export interface ExcludeRuleDef {
+    label: string;
+    test(basename: string, relPath: string, isDir: boolean): boolean;
+}
+export declare const EXCLUDE_RULES: ExcludeRuleDef[];
+export declare function matchExclude(basename: string, relPath: string, isDir: boolean): string | null;

package/dist/publish/errors.d.ts

@@ -0,0 +1,7 @@
+export type PublishErrorCode = 'APP_ID_REQUIRED' | 'APP_DEFINITION_HASH_REQUIRED' | 'APP_NOT_FOUND' | 'APP_AMBIGUOUS' | 'APP_NAME_CONFLICT' | 'APP_DEFINITION_CONFLICT' | 'APP_PACKAGE_ROOT_INVALID' | 'APP_UI_MANIFEST_INVALID' | 'APP_SKILL_MISSING' | 'APP_INITIAL_STATE_OUT_OF_SCOPE' | 'PACKAGE_PATH_TRAVERSAL' | 'PACKAGE_SYMLINK' | 'PACKAGE_FILE_INVALID' | 'PACKAGE_SIZE_LIMIT' | 'PACKAGE_GENERATED_FILE_MISSING' | 'PACKAGE_STAGED_BYTES_MISMATCH' | 'PUBLISH_SECRET_FINDINGS' | 'PUBLISH_CONTENT_ID_MISSING' | 'PUBLISH_CONTENT_SUSPENDED' | 'CONTENT_REJECTED' | 'APP_VERSION_MUST_INCREASE' | 'APP_VERSION_INVALID';
+export declare class PublishError extends Error {
+    readonly code: PublishErrorCode;
+    readonly name = "PublishError";
+    constructor(code: PublishErrorCode, detail?: string);
+}
+export declare function publishError(code: PublishErrorCode, detail?: string): PublishError;

package/dist/publish/index.d.ts

@@ -0,0 +1,50 @@
+import type { ExcludedEntry } from './scan';
+import type { SecretFinding } from './secrets';
+import type { PublishManifest } from './manifest';
+import { uploadToMarketplace } from './upload';
+import type { PublishUploadOptions, PublishUploadResult } from './upload';
+export declare const DEFAULT_PUBLISH_MAX_FILES = 10000;
+export declare const DEFAULT_PUBLISH_MAX_BYTES: number;
+export interface PublishOptions {
+    version?: string;
+    appId?: string;
+    expectedDefinitionHash?: string;
+    maxFileCount?: number;
+    maxTotalBytes?: number;
+    maxFiles?: number;
+    maxBytes?: number;
+}
+export interface PublishPlan {
+    manifest: PublishManifest;
+    included: string[];
+    excluded: ExcludedEntry[];
+    secretFindings: SecretFinding[];
+}
+export declare function planPublish(dir: string, opts?: PublishOptions): Promise<PublishPlan>;
+export declare function packPublish(dir: string, opts?: PublishOptions): Promise<{
+    manifest: PublishManifest;
+    tgzPath: string;
+}>;
+export declare function packTemplate(dir: string, opts?: PublishOptions): Promise<{
+    manifest: PublishManifest;
+    tgzPath: string;
+}>;
+export declare function packApp(dir: string, opts: PublishOptions & {
+    appId: string;
+    expectedDefinitionHash: string;
+}): Promise<{
+    manifest: Extract<PublishManifest, {
+        type: 'app';
+    }>;
+    tgzPath: string;
+}>;
+export type { PublishManifest, PublishTemplateManifest, PublishAppManifest, ManifestFile, BuildManifestOptions, BuildAppManifestOptions, } from './manifest';
+export type { ExcludedEntry, ScanResult } from './scan';
+export type { SecretFinding } from './secrets';
+export type { CreateArchiveOptions } from './pack';
+export { EXCLUDE_RULES } from './constants';
+export { uploadToMarketplace };
+export type { PublishUploadOptions, PublishUploadResult };
+export { MARKETPLACE_API_PREFIX } from './marketplace-api.constants';
+export { PublishError } from './errors';
+export type { PublishErrorCode } from './errors';