@caupulican/pi-adaptative 0.81.38 → 0.81.40

package/dist/core/extensions/storage.d.ts

@@ -0,0 +1,8 @@
+import type { ExtensionStorage } from "./types.ts";
+/**
+ * Create a pure, namespaced extension storage view. Merely requesting the view performs no I/O;
+ * durable/cache directories are created only when the extension writes to them, and transient work
+ * is created only through an explicit leased acquisition.
+ */
+export declare function createExtensionStorage(agentDir: string, namespace: string, assertActive: () => void, registerDisposer: (disposer: () => void) => void): ExtensionStorage;
+//# sourceMappingURL=storage.d.ts.map

package/dist/core/extensions/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/core/extensions/storage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAA2B,MAAM,YAAY,CAAC;AAE5E;;;;GAIG;AACH,wBAAgB,sBAAsB,CACrC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,IAAI,EACxB,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,GAC9C,gBAAgB,CAqBlB","sourcesContent":["import { acquireWorkRun, boundedWorkRetention, extensionCacheDir, extensionStateDir } from \"../agent-paths.ts\";\nimport type { ExtensionStorage, ExtensionWorkRunOptions } from \"./types.ts\";\n\n/**\n * Create a pure, namespaced extension storage view. Merely requesting the view performs no I/O;\n * durable/cache directories are created only when the extension writes to them, and transient work\n * is created only through an explicit leased acquisition.\n */\nexport function createExtensionStorage(\n\tagentDir: string,\n\tnamespace: string,\n\tassertActive: () => void,\n\tregisterDisposer: (disposer: () => void) => void,\n): ExtensionStorage {\n\tconst stateDir = extensionStateDir(agentDir, namespace);\n\tconst cacheDir = extensionCacheDir(agentDir, namespace);\n\n\treturn {\n\t\tnamespace,\n\t\tstateDir,\n\t\tcacheDir,\n\t\tacquireWorkRun(options: ExtensionWorkRunOptions = {}) {\n\t\t\tassertActive();\n\t\t\tconst lease = acquireWorkRun({\n\t\t\t\tagentDir,\n\t\t\t\tcategory: \"extensions\",\n\t\t\t\ttenant: namespace,\n\t\t\t\trunId: options.runId,\n\t\t\t\tretention: boundedWorkRetention(options.retention),\n\t\t\t});\n\t\t\tregisterDisposer(lease.release);\n\t\t\treturn lease;\n\t\t},\n\t};\n}\n"]}

package/dist/core/extensions/storage.js

@@ -0,0 +1,28 @@
+import { acquireWorkRun, boundedWorkRetention, extensionCacheDir, extensionStateDir } from "../agent-paths.js";
+/**
+ * Create a pure, namespaced extension storage view. Merely requesting the view performs no I/O;
+ * durable/cache directories are created only when the extension writes to them, and transient work
+ * is created only through an explicit leased acquisition.
+ */
+export function createExtensionStorage(agentDir, namespace, assertActive, registerDisposer) {
+    const stateDir = extensionStateDir(agentDir, namespace);
+    const cacheDir = extensionCacheDir(agentDir, namespace);
+    return {
+        namespace,
+        stateDir,
+        cacheDir,
+        acquireWorkRun(options = {}) {
+            assertActive();
+            const lease = acquireWorkRun({
+                agentDir,
+                category: "extensions",
+                tenant: namespace,
+                runId: options.runId,
+                retention: boundedWorkRetention(options.retention),
+            });
+            registerDisposer(lease.release);
+            return lease;
+        },
+    };
+}
+//# sourceMappingURL=storage.js.map

package/dist/core/extensions/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../../src/core/extensions/storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG/G;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CACrC,QAAgB,EAChB,SAAiB,EACjB,YAAwB,EACxB,gBAAgD,EAC7B;IACnB,MAAM,QAAQ,GAAG,iBAAiB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IACxD,MAAM,QAAQ,GAAG,iBAAiB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IAExD,OAAO;QACN,SAAS;QACT,QAAQ;QACR,QAAQ;QACR,cAAc,CAAC,OAAO,GAA4B,EAAE,EAAE;YACrD,YAAY,EAAE,CAAC;YACf,MAAM,KAAK,GAAG,cAAc,CAAC;gBAC5B,QAAQ;gBACR,QAAQ,EAAE,YAAY;gBACtB,MAAM,EAAE,SAAS;gBACjB,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,SAAS,EAAE,oBAAoB,CAAC,OAAO,CAAC,SAAS,CAAC;aAClD,CAAC,CAAC;YACH,gBAAgB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAChC,OAAO,KAAK,CAAC;QAAA,CACb;KACD,CAAC;AAAA,CACF","sourcesContent":["import { acquireWorkRun, boundedWorkRetention, extensionCacheDir, extensionStateDir } from \"../agent-paths.ts\";\nimport type { ExtensionStorage, ExtensionWorkRunOptions } from \"./types.ts\";\n\n/**\n * Create a pure, namespaced extension storage view. Merely requesting the view performs no I/O;\n * durable/cache directories are created only when the extension writes to them, and transient work\n * is created only through an explicit leased acquisition.\n */\nexport function createExtensionStorage(\n\tagentDir: string,\n\tnamespace: string,\n\tassertActive: () => void,\n\tregisterDisposer: (disposer: () => void) => void,\n): ExtensionStorage {\n\tconst stateDir = extensionStateDir(agentDir, namespace);\n\tconst cacheDir = extensionCacheDir(agentDir, namespace);\n\n\treturn {\n\t\tnamespace,\n\t\tstateDir,\n\t\tcacheDir,\n\t\tacquireWorkRun(options: ExtensionWorkRunOptions = {}) {\n\t\t\tassertActive();\n\t\t\tconst lease = acquireWorkRun({\n\t\t\t\tagentDir,\n\t\t\t\tcategory: \"extensions\",\n\t\t\t\ttenant: namespace,\n\t\t\t\trunId: options.runId,\n\t\t\t\tretention: boundedWorkRetention(options.retention),\n\t\t\t});\n\t\t\tregisterDisposer(lease.release);\n\t\t\treturn lease;\n\t\t},\n\t};\n}\n"]}

package/dist/core/extensions/types.d.ts

@@ -13,11 +13,13 @@ import type { Api, AssistantMessageEvent, AssistantMessageEventStream, Context,
 import type { AutocompleteItem, AutocompleteProvider, Component, EditorComponent, EditorTheme, KeyId, OverlayHandle, OverlayOptions, TUI } from "@caupulican/pi-tui";
 import type { Static, TSchema } from "typebox";
 import type { Theme } from "../../modes/interactive/theme/theme.ts";
+import type { WorkRetentionOptions, WorkRunLease } from "../../utils/work-directory.ts";
 import type { BashResult } from "../bash-executor.ts";
 import type { MemoryProvider as ContextMemoryProvider } from "../context/memory-provider-contract.ts";
 import type { EventBus } from "../event-bus.ts";
 import type { ExecOptions, ExecResult } from "../exec.ts";
 import type { ReadonlyFooterDataProvider } from "../footer-data-provider.ts";
+import type { HumanInputPresentationRequest, HumanInputPresentationResult } from "../human-input.ts";
 import type { KeybindingsManager } from "../keybindings.ts";
 import type { MemoryProvider } from "../memory/memory-provider.ts";
 import type { ModelRegistry } from "../model-registry.ts";
@@ -65,6 +67,8 @@ export type EditorFactory = (tui: TUI, theme: EditorTheme, keybindings: Keybindi
  * Each mode (interactive, RPC, print) provides its own implementation.
  */
 export interface ExtensionUIContext {
+    /** Present a transport-neutral, typed owner-input request. */
+    askQuestions(request: HumanInputPresentationRequest, opts?: Pick<ExtensionUIDialogOptions, "signal">): Promise<HumanInputPresentationResult>;
     /** Show a selector and return the user's choice. */
     select(title: string, options: string[], opts?: ExtensionUIDialogOptions): Promise<string | undefined>;
     /** Show a confirmation dialog. */
@@ -207,7 +211,7 @@ export interface CompactOptions {
 export interface ExtensionContext {
     /** UI methods for user interaction */
     ui: ExtensionUIContext;
-    /** Whether UI is available (false in print/RPC mode) */
+    /** Whether the host can settle UI requests (false in print mode; true for TUI and RPC hosts). */
     hasUI: boolean;
     /** Runtime mode hosting this extension invocation. */
     mode: "tui" | "print" | "rpc";
@@ -810,10 +814,90 @@ export interface ResolvedCommand extends RegisteredCommand {
 }
 /** Handler function type for events */
 export type ExtensionHandler<E, R = undefined> = (event: E, ctx: ExtensionContext) => Promise<R | void> | R | void;
+/** Options for one transient extension work run. */
+export interface ExtensionWorkRunOptions {
+    runId?: string;
+    retention?: Omit<WorkRetentionOptions, "now">;
+}
+/**
+ * Namespaced extension-owned storage. Paths are pure and do not create directories. Transient work
+ * must be acquired through a lease, which the host releases automatically on unload or failed load.
+ */
+export interface ExtensionStorage {
+    readonly namespace: string;
+    readonly stateDir: string;
+    readonly cacheDir: string;
+    acquireWorkRun(options?: ExtensionWorkRunOptions): WorkRunLease;
+}
+/**
+ * Report for an out-of-process managed lane (e.g. a tmux worker) at dispatch or terminal. `laneId` is
+ * a stable identifier the CALLER chooses (e.g. a tmux job id or slug) and reuses unchanged across both
+ * reports of the same lane. The host preserves it as the canonical durable lane identity so goal
+ * bindings and terminal reports remain correlated across controller reloads.
+ *
+ * External status, changed files, usage, and provider execution remain caller claims. Dispatch authority
+ * is different: the host compiles the claimed tool/path/budget scope into a typed execution grant and
+ * persists it before the extension may start the process. This proves the host authorization boundary,
+ * not that a third-party child CLI enforces the same scope internally.
+ */
+export interface ManagedLaneDispatch {
+    /** Monotonic turn number for this logical lane. */
+    sequence: number;
+    /** Exact task instruction dispatched to the external worker. */
+    instructions: string;
+    /** Owner-selected immutable execution profile identity. */
+    profileId: string;
+    /** Provider/launcher identity used by the external process. */
+    provider: string;
+    /** Authorization record that covered this launch or follow-up. */
+    authorizationId: string;
+    /** How the owner authority was established. */
+    authorizationKind: "standing-grant" | "one-shot-owner-approval" | "legacy-recovery";
+    /** Exact child tool surface requested at launch. */
+    allowedTools: readonly string[];
+    /** Exact write path claims requested at launch. */
+    writePaths: readonly string[];
+    /** Advisory cross-process cost ceiling when supplied by the owner grant. */
+    maxCostUsd?: number;
+    /** Lease duration for this externally supervised turn. */
+    leaseTtlMs: number;
+}
+interface ManagedLaneEventBase {
+    laneId: string;
+    /** Goal this managed lane's work is bound to, if any — tags the tracked lane for goal orchestration. */
+    goalId?: string;
+    /**
+     * Worktree-sync lane key this managed lane was dispatched into. A caller claim like every other
+     * field here; the host retains it for routing/review but does not treat it as verified authority.
+     */
+    worktreeLaneKey?: string;
+}
+export type ManagedLaneEvent = (ManagedLaneEventBase & {
+    phase: "dispatch";
+    dispatch: ManagedLaneDispatch;
+}) | (ManagedLaneEventBase & {
+    phase: "terminal";
+    status?: string;
+    reasonCode?: string;
+    changedFiles?: readonly string[];
+    /**
+     * Terminal-only usage claim for this managed lane's out-of-process work (e.g. a tmux worker's own
+     * usage report). ADVISORY, same trust level as every other field on this event — the host attributes
+     * `usage.cost.total` onto the completed lane's `costUsd` verbatim, with NO re-pricing (the caller's
+     * model is unknown to the host, so re-pricing is both impossible and unnecessary). Ignored on
+     * `phase: "dispatch"`.
+     */
+    usage?: Usage;
+});
 /**
  * ExtensionAPI passed to extension factory functions.
  */
 export interface ExtensionAPI {
+    /**
+     * Bind this extension generation to one portable storage namespace. Repeated calls with the same
+     * namespace return the same view; selecting a second namespace is rejected to prevent sprawl.
+     */
+    getStorage(namespace: string): ExtensionStorage;
     on(event: "resources_discover", handler: ExtensionHandler<ResourcesDiscoverEvent, ResourcesDiscoverResult>): void;
     on(event: "session_start", handler: ExtensionHandler<SessionStartEvent>): void;
     on(event: "session_before_switch", handler: ExtensionHandler<SessionBeforeSwitchEvent, SessionBeforeSwitchResult>): void;
@@ -913,6 +997,17 @@ export interface ExtensionAPI {
         sourceSessionId?: string;
         reportId?: string;
     }): void;
+    /**
+     * Report an out-of-process managed lane's dispatch or terminal outcome (e.g. a tmux worker) so the
+     * host's LaneTracker treats it as a first-class lane — visible in `/autonomy` + `delegate_status`,
+     * holding a reload-quiesce unit while dispatched, and leaving a bounded claim snapshot on terminal.
+     *
+     * HONEST TRUST BOUNDARY: this is a report, not a grant of in-process sandboxing — the host is the
+     * lane-tracking SSOT and only ever records what the extension claims. Call once with
+     * `phase: "dispatch"` when the out-of-process work starts, and exactly once more with
+     * `phase: "terminal"` using the SAME `laneId` when it ends.
+     */
+    reportManagedLane(event: ManagedLaneEvent): void;
     /** Set the current model. Returns false if no API key available. */
     setModel(model: Model<any>): Promise<boolean>;
     /** Get current thinking level. */
@@ -1143,6 +1238,8 @@ export interface ExtensionRuntimeState {
     /** Memory-provider objects owned by each extension generation, for exact live unload. */
     memoryProvidersByExtension: Map<string, Set<MemoryProvider>>;
     contextMemoryProvidersByExtension: Map<string, Set<ContextMemoryProvider>>;
+    /** Active namespace owner, preventing unrelated extensions from silently sharing storage. */
+    extensionStorageOwners: Map<string, Extension>;
 }
 /**
  * Action implementations for pi.* API methods.
@@ -1171,6 +1268,7 @@ export interface ExtensionActions {
         sourceSessionId?: string;
         reportId?: string;
     }) => void;
+    reportManagedLane: (event: ManagedLaneEvent) => void;
 }
 /**
  * Actions for ExtensionContext (ctx.* in event handlers).
@@ -1239,6 +1337,8 @@ export interface Extension {
     commands: Map<string, RegisteredCommand>;
     flags: Map<string, ExtensionFlag>;
     shortcuts: Map<KeyId, ExtensionShortcut>;
+    /** Canonical storage view requested by this extension generation, if any. */
+    storage?: ExtensionStorage;
     /** Optional lazy loader for tool-only extensions loaded on first tool use. */
     lazy?: {
         loaded: boolean;