@cjhyy/code-shell-core 0.7.0 → 0.8.0

package/dist/engine/types.d.ts

@@ -2,7 +2,7 @@
  * Public Engine configuration & result types.
  *
  * Extracted out of engine/engine.ts so consumers (protocol server, run
- * factory, product layer, settings/disk-defaults, SDK index) can import the
+ * factory, product layer, engine/disk-defaults, SDK index) can import the
  * Engine's *types* without importing the 3000-line Engine *implementation* —
  * which would pull the whole engine module (and its transitive deps) into a
  * type-only consumer and make engine.ts a "type water tower". engine.ts
@@ -12,8 +12,8 @@
  */
 import type { ClientDefaults, LLMConfig, SessionOrigin, TerminalReason, TokenUsage } from "../types.js";
 import type { AgentPresetName } from "../preset/index.js";
-import type { GoalConfig } from "./goal.js";
-import type { ApprovalBackend } from "../tool-system/permission.js";
+import type { GoalConfig, GoalTerminationReason } from "../goal/lifecycle.js";
+import type { ApprovalBackend, ApprovalRouter } from "../tool-system/permission.js";
 import type { SandboxConfig } from "../tool-system/sandbox/index.js";
 import type { CostStateStore } from "./cost-store.js";
 import type { AskUserFn } from "../tool-system/builtin/ask-user.js";
@@ -21,6 +21,10 @@ import type { SettingsScope } from "../settings/manager.js";
 import type { EngineRuntime } from "./runtime.js";
 import type { HookEventName } from "../hooks/events.js";
 import type { HookHandler } from "../hooks/registry.js";
+import type { CapabilityModule } from "../capabilities/index.js";
+import type { ExtensionModule } from "../tool-system/capability-module.js";
+import type { RunBehaviorProfile } from "./run-types.js";
+import type { LegacyPetWorkDelegation } from "../types.js";
 export interface EngineConfig {
     llm: LLMConfig;
     /**
@@ -41,6 +45,16 @@ export interface EngineConfig {
     preset?: AgentPresetName;
     enabledBuiltinTools?: string[];
     disabledBuiltinTools?: string[];
+    /** Trusted optional product capabilities installed by the owning host. */
+    capabilities?: readonly CapabilityModule[];
+    /** Lightweight runtime tools and queries loaded by the host process. */
+    extensionModules?: readonly ExtensionModule[];
+    /**
+     * Named per-run behavior profiles selectable via EngineRunOptions.behaviorMode
+     * or a profile's activateForSessionKinds. Merged (by id, later wins) over the
+     * core defaults and any ExtensionModule.behaviorProfiles.
+     */
+    behaviorProfiles?: readonly RunBehaviorProfile[];
     /**
      * When false, `Bash(run_in_background=true)` is rejected and the
      * background-shell tools are disabled (design §5.5). Set false by
@@ -70,6 +84,8 @@ export interface EngineConfig {
     sessionStorageDir?: string;
     maxContextTokens?: number;
     approvalBackend?: ApprovalBackend;
+    /** Connection-scoped permission approval router supplied by an interactive host. */
+    approvalRouter?: ApprovalRouter;
     hooks?: EngineHookConfig[];
     askUser?: AskUserFn;
     /** Browser automation bridge (browser_* tools). Wired by the host (desktop)
@@ -77,6 +93,8 @@ export interface EngineConfig {
     browserBridge?: import("../tool-system/browser-bridge.js").BrowserBridge;
     /** Host-backed workspace switch bridge (desktop only). */
     workspaceBridge?: import("../tool-system/workspace-bridge.js").WorkspaceBridge;
+    /** Host-backed panel discovery/focus bridge (interactive Desktop only). */
+    panelBridge?: import("../tool-system/panel-bridge.js").PanelHostBridge;
     /** Inject a cookie credential into the built-in browser (InjectCredential
      *  tool). Wired by the host after construction via setInjectCredential.
      *  Undefined → the tool degrades with a clear "no browser" error. */
@@ -134,7 +152,7 @@ export interface EngineConfig {
      * worktree tools with SwitchSessionWorkspace because Electron main owns the
      * authoritative workspace switch service and UI refresh path.
      */
-    builtinToolHost?: "desktop";
+    builtinToolHost?: string;
     /**
      * Optional shared EngineRuntime providing pre-constructed shared resources
      * (modelPool, toolRegistry, etc.). When provided, Engine uses these instead
@@ -177,7 +195,20 @@ export interface EngineHookConfig {
 export interface EngineResult {
     text: string;
     reason: TerminalReason;
+    /** Goal-specific stop outcome; omitted for ordinary completion/met verdicts. */
+    goalTermination?: GoalTerminationReason;
     sessionId: string;
     turnCount: number;
     usage: TokenUsage;
+    /**
+     * Structured results reported by the run's active behavior profile, keyed by
+     * profile id (each profile's reportResult(key, value) calls land under
+     * extensions[profileId][key]). Absent when no profile reported anything.
+     */
+    extensions?: Record<string, unknown>;
+    /**
+     * Present only when Mimi successfully invoked DelegateWork during this run.
+     * @deprecated Compat mirror of `extensions.pet?.workDelegation`.
+     */
+    petWorkDelegation?: LegacyPetWorkDelegation;
 }

package/dist/engine/types.js

@@ -2,7 +2,7 @@
  * Public Engine configuration & result types.
  *
  * Extracted out of engine/engine.ts so consumers (protocol server, run
- * factory, product layer, settings/disk-defaults, SDK index) can import the
+ * factory, product layer, engine/disk-defaults, SDK index) can import the
  * Engine's *types* without importing the 3000-line Engine *implementation* —
  * which would pull the whole engine module (and its transitive deps) into a
  * type-only consumer and make engine.ts a "type water tower". engine.ts

package/dist/{engine/goal.d.ts → goal/lifecycle.d.ts}

@@ -11,8 +11,18 @@
  * so an unattended goal run can't burn tokens or wall time without bound.
  */
 export interface GoalConfig {
+    /** Stable unique identity for this concrete armed goal instance. */
+    goalId?: string;
+    /** Monotonic control revision for edit/pause/resume race fencing. */
+    revision?: number;
     /** The objective text shown to the judge / injected into context. */
     objective: string;
+    /**
+     * A paused goal remains persisted and visible, but is not inherited by a
+     * bare send and does not install the run-level stop judge. Resuming flips
+     * this back to false without creating a new goal identity.
+     */
+    paused?: boolean;
     /** Hard cap on total tokens (prompt+completion) for the whole goal run. */
     tokenBudget?: number;
     /** Hard cap on wall-clock duration of the whole goal run, in ms. */
@@ -47,21 +57,84 @@ export interface GoalConfig {
      */
     setAtMs?: number;
 }
-/** A forced terminal outcome for one concrete persisted goal instance. */
-export type GoalTerminationReason = "stop_blocks_exhausted" | "token_budget_exhausted" | "time_budget_exhausted" | "max_turns_exhausted";
+/** Persisted V1 lifecycle. Identity/control fields live outside config exactly once. */
+export type GoalLifecycleConfig = Omit<GoalConfig, "goalId" | "revision" | "paused">;
+export type GoalLifecycleTerminalReason = "completed" | "cancelled" | "user_cleared" | "stop_blocks_exhausted" | "token_budget_exhausted" | "time_budget_exhausted" | "max_turns_exhausted";
+interface GoalLifecycleBaseV1 {
+    version: 1;
+    goalId: string;
+    revision: number;
+    config: GoalLifecycleConfig;
+    updatedAtMs: number;
+}
+export type GoalLifecycleV1 = (GoalLifecycleBaseV1 & {
+    phase: "active";
+}) | (GoalLifecycleBaseV1 & {
+    phase: "paused";
+}) | (GoalLifecycleBaseV1 & {
+    phase: "waiting";
+    waitingSinceMs: number;
+    waitingFor: "finite_background_work";
+}) | (GoalLifecycleBaseV1 & {
+    phase: "terminal";
+    terminal: {
+        reason: GoalLifecycleTerminalReason;
+        atMs: number;
+    };
+});
+export type GoalLifecyclePhase = GoalLifecycleV1["phase"];
+/** Build one canonical lifecycle record from the compatibility GoalConfig view. */
+export declare function createGoalLifecycle(goal: GoalConfig, phase?: Exclude<GoalLifecyclePhase, "terminal" | "waiting">, nowMs?: number): GoalLifecycleV1;
+/** Compatibility view consumed by Engine/protocol while persistence uses the union. */
+export declare function goalConfigFromLifecycle(lifecycle: GoalLifecycleV1): GoalConfig;
+export declare function isGoalLifecycleArmable(lifecycle: GoalLifecycleV1): boolean;
+export declare function isGoalLifecycleCurrent(lifecycle: GoalLifecycleV1): boolean;
+/** Strict persisted decoder. Unknown versions and partial unions fail closed. */
+export declare function decodeGoalLifecycle(value: unknown): GoalLifecycleV1 | undefined;
+export declare function waitGoalLifecycle(lifecycle: GoalLifecycleV1, nowMs?: number): GoalLifecycleV1 | undefined;
+export declare function armGoalLifecycle(lifecycle: GoalLifecycleV1, nowMs?: number): GoalLifecycleV1 | undefined;
+export declare function terminateGoalLifecycle(lifecycle: GoalLifecycleV1, reason: GoalLifecycleTerminalReason, nowMs?: number): GoalLifecycleV1 | undefined;
+/** A forced stop outcome for a Goal run. Some outcomes intentionally preserve the Goal. */
+export type GoalTerminationReason = "stop_blocks_exhausted" | "token_budget_exhausted" | "time_budget_exhausted" | "max_turns_exhausted" | "judge_prompt_too_large";
+/** Outcomes that permanently close one concrete persisted Goal instance. */
+export type PersistedGoalTerminationReason = Exclude<GoalTerminationReason, "judge_prompt_too_large"> | "completed" | "cancelled" | "user_cleared";
 /**
  * Persisted terminal marker used to prevent a stale whole-state writer from
- * making an exhausted goal armable again. `objective + setAtMs` is the goal
- * instance identity; `terminatedAtMs` only orders competing tombstones.
+ * making a completed, cancelled, or exhausted goal armable again.
+ * `goalId` is the authoritative instance identity. `objective + setAtMs` is
+ * retained only for pre-goalId state compatibility; `terminatedAtMs` orders
+ * the legacy single-marker view while goalTerminals preserves the identity set.
  */
 export interface GoalTerminal {
+    /** Identity of the concrete goal instance that reached a terminal state. */
+    goalId?: string;
+    /** Goal control revision that reached the terminal state. */
+    revision?: number;
     objective: string;
     setAtMs?: number;
-    reason: GoalTerminationReason;
+    reason: PersistedGoalTerminationReason;
     terminatedAtMs?: number;
 }
 /** True only when both values identify the same concrete goal instance. */
-export declare function isSameGoalInstance(left: Pick<GoalConfig, "objective" | "setAtMs"> | undefined, right: Pick<GoalConfig, "objective" | "setAtMs"> | undefined): boolean;
+export declare function isSameGoalInstance(left: Pick<GoalConfig, "goalId" | "objective" | "setAtMs"> | undefined, right: Pick<GoalConfig, "goalId" | "objective" | "setAtMs"> | undefined): boolean;
+/** Same concrete goal and same edit/pause/resume revision. */
+export declare function isSameGoalVersion(left: Pick<GoalConfig, "goalId" | "objective" | "setAtMs" | "revision"> | undefined, right: Pick<GoalConfig, "goalId" | "objective" | "setAtMs" | "revision"> | undefined): boolean;
+/** Bound stale-writer protection while retaining enough recent terminal identities. */
+export declare const MAX_GOAL_TERMINALS = 64;
+/**
+ * Deterministic identity for a pre-goalId persisted goal. Two detached
+ * snapshots of the same session/legacy signature must migrate to the same id.
+ */
+export declare function deriveLegacyGoalId(sessionId: string, goal: Pick<GoalConfig, "objective" | "setAtMs" | "tokenBudget" | "timeBudgetMs" | "maxTurns" | "maxStopBlocks">): string;
+/** Merge terminal identities oldest→newest, dedupe by instance, and cap growth. */
+export declare function mergeGoalTerminals(...sources: Array<GoalTerminal | readonly GoalTerminal[] | undefined>): GoalTerminal[];
+/** Whether this concrete goal is present in the bounded terminal identity set. */
+export declare function isGoalTerminated(goal: GoalConfig | undefined, terminals: readonly GoalTerminal[] | undefined, latest?: GoalTerminal): boolean;
+/** Record one terminal identity on a state-like holder without losing prior identities. */
+export declare function recordGoalTerminal(state: {
+    goalTerminal?: GoalTerminal;
+    goalTerminals?: GoalTerminal[];
+}, goal: GoalConfig, reason: PersistedGoalTerminationReason, terminatedAtMs?: number): GoalTerminal;
 /**
  * Default consecutive-stop-block cap for goal runs. The real safety net for an
  * unattended goal is the token/time budget + maxTurns; this cap only stops a
@@ -202,3 +275,4 @@ export declare function recordGoalUsage(tracker: GoalBudgetTracker, turnTokens:
 export declare function goalBudgetExceeded(tracker: GoalBudgetTracker, nowMs: number): boolean;
 /** Identify which goal budget forced termination, preserving token-first precedence. */
 export declare function goalBudgetTerminationReason(tracker: GoalBudgetTracker, nowMs: number): Extract<GoalTerminationReason, "token_budget_exhausted" | "time_budget_exhausted"> | undefined;
+export {};