@skaile/workspaces 5.5.0 → 5.6.1

package/dist/{project-SVS4UMGL.js.map → project-VMOHUXBD.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"project-SVS4UMGL.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"project-VMOHUXBD.js"}

package/dist/resolver/index.js

@@ -1,17 +1,17 @@
-export { buildRequiresPreamble, parseCompactionDirectives, parseSkillFrontmatter, parseSkillRequirements, validateConnectorRequirements, validateFlowVersions, validateRequirements } from '../chunk-JAJG4G5E.js';
-import '../chunk-3JHFFIQ6.js';
+export { buildRequiresPreamble, parseCompactionDirectives, parseSkillFrontmatter, parseSkillRequirements, validateConnectorRequirements, validateFlowVersions, validateRequirements } from '../chunk-ZBBM6O6P.js';
+import '../chunk-TZCQ7ZWQ.js';
 import '../chunk-4GY63JU6.js';
-import '../chunk-YK7WJSTD.js';
-import '../chunk-XGIS325V.js';
+import '../chunk-BF33SCLY.js';
+import '../chunk-46OVMT76.js';
 import '../chunk-5BEFNLOR.js';
 import '../chunk-A2ULN3KX.js';
-import '../chunk-ORUHADS6.js';
+import '../chunk-2W4LBLIN.js';
 import '../chunk-MFHKHXDE.js';
-import '../chunk-TOSHZX4C.js';
-import '../chunk-SR4RFKHM.js';
+import '../chunk-CPSIPIX7.js';
+import '../chunk-7ZHLYXTI.js';
 import '../chunk-RVRB27AN.js';
-import '../chunk-LFMX2UEF.js';
-import '../chunk-WX74MVNA.js';
+import '../chunk-PA7WLID3.js';
+import '../chunk-AO7VJ6G6.js';
 import '../chunk-ICSCSM5D.js';
 import '../chunk-JMKB7IB4.js';
 import '../chunk-MJHSLODD.js';

package/dist/runner/index.js

@@ -1,12 +1,12 @@
-export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CONNECTOR_MUTATE_NOT_READY, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_READ_MAX_CHUNK_BYTES, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MOUNT_WRITE_MAX_CHUNK_BYTES, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WRITE_RANGE_PARTIAL_TTL_MS, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, capabilitySignatureInputs, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, computeDirectoryTotals, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createManagedCodexSubpromptDriver, createSessionStimulusBus, defineCapability, deleteSession, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, driverActiveAfterTurnEnd, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickChatFlowTarget, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, reconnectedRunNeedsAgentTurn, recreateKeepingLiveFlows, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, restoredRunHasWorkToResume, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, takeRunnerWsAuthToken, toActiveFlowTarget, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile, writeRangeChunk, writeRangePartialPath } from '../chunk-G2O2AARG.js';
-import '../chunk-LFEGIZTW.js';
-import '../chunk-CODXK5L5.js';
-import '../chunk-WHSQSVN2.js';
+export { AgentRunError, CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CONNECTOR_MUTATE_NOT_READY, CapabilityRegistry, CompileManifestEntrySchema, CompositionError, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, DEFAULT_MAX_FINISHED_TREES, DEFAULT_RUN_LIMITS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_READ_MAX_CHUNK_BYTES, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MOUNT_WRITE_MAX_CHUNK_BYTES, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, UnknownCompositionKindError, WRITE_RANGE_PARTIAL_TTL_MS, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildCompositionRunSnapshot, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildRunnerAgentSections, buildStoreSnapshotReplay, builtinCapabilities, canonicalJson, capabilityLogInstance, capabilitySignatureInputs, clearPreInitRingSink, clearSession, compileComposition, compositionRunSnapshotPath, computeCapabilitySignature, computeDirectoryTotals, computeRevisionHash, connectorRefreshKind, createAgentSession, createCompositionContentSource, createFlowConnectorReadiness, createInMemoryRunStore, createManagedCodexSubpromptDriver, createRunController, createSessionStimulusBus, defineCapability, deleteSession, describeComposition, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, driverActiveAfterTurnEnd, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hashAgentFiles, hashContent, hostOpResumeStimulus, installPreInitRingSink, instanceForSession, isCompositionError, isEmptyKnowledgeIndex, isSessionRootPathAllowed, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadCompositionRunSnapshot, loadKnowledgeDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickChatFlowTarget, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, reconnectedRunNeedsAgentTurn, recreateKeepingLiveFlows, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentInstance, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, restoredRunHasWorkToResume, runAgentChat, saveCompositionRunSnapshot, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, stripFrontmatter, takeRunnerWsAuthToken, toActiveFlowTarget, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile, writeRangeChunk, writeRangePartialPath } from '../chunk-RGXVQZOV.js';
+import '../chunk-4GNJELPH.js';
+import '../chunk-6NPINANG.js';
+import '../chunk-SX4UIDKT.js';
 import '../chunk-R6O6YWU7.js';
-import '../chunk-GCYD4EGY.js';
-import '../chunk-JELTQ4H7.js';
+import '../chunk-KYXOGHY6.js';
+import '../chunk-45VFGT7A.js';
 import '../chunk-4ZTPYIBE.js';
-import '../chunk-SNVOASTL.js';
+import '../chunk-2XFUXGV6.js';
 import '../chunk-X5YPJV4N.js';
 import '../chunk-O7SG5PC2.js';
 import '../chunk-7QBNJTTQ.js';
@@ -15,51 +15,56 @@ import '../chunk-5LKOAX7I.js';
 import '../chunk-32NA4TVC.js';
 export { assembleSystemPrompt, buildCapabilitiesPromptSection, buildLinkedPeersPromptSection } from '../chunk-W3UDISS2.js';
 import '../chunk-HCYS7GFP.js';
-import '../chunk-XBM5ND55.js';
+import '../chunk-7KLC4LZO.js';
 import '../chunk-4R6DROGN.js';
-import '../chunk-JAJG4G5E.js';
-import '../chunk-JKWU6ULI.js';
+import '../chunk-ZBBM6O6P.js';
+import '../chunk-SDFROXSA.js';
 import '../chunk-CT6NQSA4.js';
-import '../chunk-UHLBDAJR.js';
-import '../chunk-QMWMSZQ4.js';
-import '../chunk-X4GO3GJZ.js';
-import '../chunk-JBPG5KQC.js';
-import '../chunk-LAI7X6I2.js';
+import '../chunk-UAP2XHRF.js';
+import '../chunk-FK6HPLQA.js';
+import '../chunk-2GRB5ITE.js';
+import '../chunk-VX3INFBA.js';
+import '../chunk-VBBBZDI7.js';
 import '../chunk-EINLFFP6.js';
 import '../chunk-LOO5CB5M.js';
-import '../chunk-BNUZEYC3.js';
-import '../chunk-LCULZ4ED.js';
+import '../chunk-NARITJS2.js';
+import '../chunk-27HS2DHB.js';
 import '../chunk-XBSQ4KMC.js';
 import '../chunk-YROR332M.js';
-import '../chunk-V7VDSFPS.js';
+import '../chunk-5B5IZVEP.js';
 import '../chunk-6E6PKKAD.js';
 import '../chunk-IFGTRL2I.js';
-import '../chunk-DPMKI26Y.js';
+import '../chunk-AOAZCSDI.js';
 import '../chunk-37FTLYFP.js';
 import '../chunk-QZLWJETK.js';
 import '../chunk-XUUYAS3Z.js';
 import '../chunk-NFGRW3L7.js';
 import '../chunk-QCI6D7E4.js';
-import '../chunk-K2K7OF4P.js';
-export { globalSettingsPath, loadSettings, mapLegacyFields, projectSettingsPath, resolveSettings, saveSettings } from '../chunk-3JHFFIQ6.js';
+import '../chunk-DMLDYFDS.js';
+import '../chunk-MX3UQXLU.js';
+import '../chunk-XOGG7VDZ.js';
+import '../chunk-BTISGSK4.js';
+import '../chunk-R7FOF242.js';
+import '../chunk-3TXEJN4W.js';
+import '../chunk-FRHE7FFB.js';
+export { globalSettingsPath, loadSettings, mapLegacyFields, projectSettingsPath, resolveSettings, saveSettings } from '../chunk-TZCQ7ZWQ.js';
 import '../chunk-4GY63JU6.js';
-import '../chunk-YK7WJSTD.js';
-import '../chunk-XGIS325V.js';
+import '../chunk-BF33SCLY.js';
+import '../chunk-46OVMT76.js';
 export { DRIVER_DEFAULTS, resolveDriverPaths } from '../chunk-5BEFNLOR.js';
 import '../chunk-A2ULN3KX.js';
-import '../chunk-ORUHADS6.js';
+import '../chunk-2W4LBLIN.js';
 import '../chunk-MFHKHXDE.js';
-export { DRIVER_TARGETS, SUPPORTED_DRIVER_TARGETS } from '../chunk-TOSHZX4C.js';
-import '../chunk-SR4RFKHM.js';
+export { DRIVER_TARGETS, SUPPORTED_DRIVER_TARGETS } from '../chunk-CPSIPIX7.js';
+import '../chunk-7ZHLYXTI.js';
 import '../chunk-RVRB27AN.js';
-import '../chunk-LFMX2UEF.js';
-import '../chunk-WX74MVNA.js';
+import '../chunk-PA7WLID3.js';
+import '../chunk-AO7VJ6G6.js';
 import '../chunk-ICSCSM5D.js';
 import '../chunk-JMKB7IB4.js';
 import '../chunk-MJHSLODD.js';
 import '../chunk-C3CAXQMA.js';
 import '../chunk-BOFL7GIF.js';
-import '../chunk-5CYEWBPB.js';
 import '../chunk-NSBPE2FW.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/runner/src/agent-capabilities.d.ts

@@ -0,0 +1,101 @@
+/**
+ * agent-capabilities.ts
+ *
+ * The agent composition capabilities of protocol v2 (framework origin,
+ * `agent` side): `agent.list|run|status|cancel|result`, `approval.decide`,
+ * `memory.read|write|append|list` and `trigger.list|upsert|toggle`.
+ *
+ * Switched on by what the host advertises in `session_init.capabilities`:
+ *
+ * | Host advertises      | Registered                                                  |
+ * |----------------------|-------------------------------------------------------------|
+ * | `host.agent_run`     | `agent.*` (host spawns the runs) + `approval.decide`        |
+ * | `host.memory_store`  | `memory.*`                                                  |
+ * | `host.trigger_store` | `trigger.*`                                                 |
+ * | none                 | `agent.*` + `approval.decide`, served in-process, only when |
+ * |                      | the workspace declares instances beyond the primary one;    |
+ * |                      | no `memory.*`, no `trigger.*`                               |
+ *
+ * Host-backed calls travel over the outbound `host.*` capability channel; the
+ * request/reply contracts are in `@skaile/workspaces/types` (`Host*Request`).
+ * The runner checks what it can before the host sees a call (unknown
+ * instance, `io.input`, a block that is not declared) and checks the output
+ * of every finished run against `io.output` before the model sees it.
+ *
+ * @category Capabilities
+ * @since 4.16.0
+ */
+import type { AgentRunTarget } from "./agents/instances.js";
+import type { CapabilityRegistry } from "./capability-registry.js";
+import type { ResolvedMemoryBlock } from "./composition/resolve-instance.js";
+import { type AgentEvent, type HostAgentRunReply, type HostAgentRunRequest, type Logger } from "@skaile/workspaces/types";
+/** The runtime-audience capabilities a host advertises to switch the surface on. */
+export declare const HOST_AGENT_RUN_CAPABILITY = "host.agent_run";
+export declare const HOST_MEMORY_STORE_CAPABILITY = "host.memory_store";
+export declare const HOST_TRIGGER_STORE_CAPABILITY = "host.trigger_store";
+/** How long a synchronous run, or a wait for a result, may take on the host channel. */
+export declare const AGENT_RUN_HOST_TIMEOUT_MS: number;
+/** What the host advertised. */
+export interface AgentSurfaceHosts {
+    agentRun: boolean;
+    memoryStore: boolean;
+    triggerStore: boolean;
+}
+/** Read the advertisement off the runtime-audience capability names of a `session_init`. */
+export declare function hostsFromCapabilityNames(names: ReadonlySet<string>): AgentSurfaceHosts;
+/** Runs a host-forwarded surface has seen; bounded, oldest first out. */
+export interface AgentRunLedger {
+    get(runId: string): {
+        target: AgentRunTarget;
+        input: unknown;
+    } | undefined;
+    remember(runId: string, entry: {
+        target: AgentRunTarget;
+        input: unknown;
+    }): void;
+    isFinished(runId: string): boolean;
+    markFinished(runId: string): void;
+}
+export declare function createAgentRunLedger(): AgentRunLedger;
+export interface AgentSurfaceDeps {
+    registry: CapabilityRegistry;
+    /** Session the capabilities belong to. */
+    sessionId: string;
+    /** The instance this session runs; its memory blocks are the ones `memory.*` addresses. */
+    instanceId: string;
+    /** Every instance a run can address (`loadAgentRunTargets`). */
+    targets: readonly AgentRunTarget[];
+    /** The running instance's memory blocks (`ResolvedAgentInstance.memoryBlocks`). */
+    memoryBlocks: readonly ResolvedMemoryBlock[];
+    hosts: AgentSurfaceHosts;
+    /** Outbound `host.*` invocation (over the transport). Required when any host capability is advertised. */
+    invokeHost?: (name: string, request: unknown, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }) => Promise<unknown>;
+    /** Serves `host.agent_run` inside the runner; used when the host does not advertise it. */
+    localAgentRun?: (request: HostAgentRunRequest) => Promise<HostAgentRunReply>;
+    /** Event sink (`subagent`, `memory_changed`). */
+    emit: (event: AgentEvent) => void;
+    /**
+     * Which instance each run belongs to, and which runs already emitted `finished`.
+     * The surface is re-registered on every session build; the ledger outlives it, so a
+     * rebuild between `agent.run` and `agent.result` still validates `io.output` and emits once.
+     * Create it once per host (serve process); omitted = private to this registration.
+     */
+    runLedger?: AgentRunLedger;
+    log?: Logger;
+}
+/** The `agent.*` surface is served in-process only when the workspace has something to run besides itself. */
+export declare function hasRunnableInstances(targets: readonly AgentRunTarget[]): boolean;
+/**
+ * Register the agent surface the host's advertisement and the workspace call
+ * for. Returns the registered names and a disposer; call it again after the
+ * advertisement or the instance set changes (it drops its own previous entries
+ * only through the returned disposer).
+ */
+export declare function registerAgentSurface(deps: AgentSurfaceDeps): {
+    names: string[];
+    dispose: () => void;
+};
+//# sourceMappingURL=agent-capabilities.d.ts.map

package/dist/runner/src/agent-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-capabilities.d.ts","sourceRoot":"","sources":["../../../runner/src/agent-capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAE7E,OAAO,EACL,KAAK,UAAU,EAGf,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EAOxB,KAAK,MAAM,EAEZ,MAAM,0BAA0B,CAAC;AAElC,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,mBAAmB,CAAC;AAC1D,eAAO,MAAM,4BAA4B,sBAAsB,CAAC;AAChE,eAAO,MAAM,6BAA6B,uBAAuB,CAAC;AAElE,wFAAwF;AACxF,eAAO,MAAM,yBAAyB,QAAiB,CAAC;AAExD,gCAAgC;AAChC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,4FAA4F;AAC5F,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,iBAAiB,CAMtF;AAED,yEAAyE;AACzE,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;IAC3E,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACjF,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAID,wBAAgB,oBAAoB,IAAI,cAAc,CAiBrD;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,2FAA2F;IAC3F,UAAU,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IACnC,mFAAmF;IACnF,YAAY,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC7C,KAAK,EAAE,iBAAiB,CAAC;IACzB,0GAA0G;IAC1G,UAAU,CAAC,EAAE,CACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,KACnD,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,2FAA2F;IAC3F,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAC7E,iDAAiD;IACjD,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAClC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,8GAA8G;AAC9G,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,GAAG,OAAO,CAEhF;AA4CD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG;IAC5D,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAueA"}

package/dist/runner/src/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../runner/src/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,2BAA2B,CAAC;AAY1E;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yBAAyB;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,2BAA2B;IAC3B,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACxD,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA6BD;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6ExE"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../runner/src/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,2BAA2B,CAAC;AAiB1E;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yBAAyB;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,2BAA2B;IAC3B,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACxD,0BAA0B;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA6BD;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgGxE"}

package/dist/runner/src/agents/in-process-host.d.ts

@@ -0,0 +1,56 @@
+/**
+ * agents/in-process-host.ts
+ *
+ * The `host.agent_run` contract served inside the runner, for a session whose
+ * host advertises none (plain `skaile run`, `skaile repl`, an embedded
+ * runner). It is the run controller (`run-controller.ts`) over an in-memory
+ * store, with a launcher that runs each run as a nested driver session of the
+ * role instance (`createAgentSession` with that `instanceId`), bounded by the
+ * instance's `max_turns`; the session's final reply is the run's output.
+ *
+ * It answers the same {@link HostAgentRunRequest}s a real host does, so the
+ * `agent.*` capabilities have one code path, and the run lifecycle (status
+ * machine, idempotent start, approvals, cancel) is the controller's, not
+ * re-implemented here. What it does not have: durable runs (they end with the
+ * process), a token budget (`budget.max_tokens` is not enforceable here), and
+ * delegation below one level (the nested session registers no `agent.*`
+ * capabilities).
+ */
+import type { AgentEvent as ProtocolEvent, HostAgentRunReply, HostAgentRunRequest, Logger } from "@skaile/workspaces/types";
+import type { AgentSession, AgentSessionConfig } from "../session-builder.js";
+import type { AgentRunTarget } from "./instances.js";
+export interface InProcessAgentRunHostDeps {
+    /** The instances a run can address, read per request (the set can change on a session rebuild). */
+    getTargets: () => readonly AgentRunTarget[];
+    /** Build the nested session of one run; the caller layers the parent's config under these overrides. */
+    createSession: (overrides: Partial<AgentSessionConfig>) => Promise<AgentSession>;
+    /** Id of the session the runs belong to; a run is only visible to it. */
+    sessionId: string;
+    /** `AgentRun.workspaceId`; default `local`. */
+    workspaceId?: string;
+    /** Receives the `subagent` events of the runs (started, finished). */
+    emit?: (event: ProtocolEvent) => void;
+    log?: Logger;
+}
+export type InProcessAgentRunHost = ((request: HostAgentRunRequest) => Promise<HostAgentRunReply>) & {
+    /** Cancel every live run and dispose its session (session teardown). */
+    dispose: () => Promise<void>;
+};
+/** What a role is asked: its input, and the shape its reply must have. */
+export declare function buildRolePrompt(target: AgentRunTarget, input: unknown): string;
+/**
+ * The JSON value in a role's reply: the whole reply, else the contents of a
+ * fenced block, else the span from the first opening to the last closing
+ * bracket. `undefined` when there is none.
+ */
+export declare function extractJsonOutput(text: string): unknown;
+/**
+ * The parent session's config as a nested role session starts from it: same
+ * project, providers, credentials and model; none of what ties a session to
+ * its host (resume, watchers, the capability registry and hooks, the capability
+ * prompt), so a role run registers no `agent.*` of its own.
+ */
+export declare function nestedRoleSessionConfig(parent: AgentSessionConfig): AgentSessionConfig;
+/** Build the in-process `host.agent_run` implementation: a run controller over an in-memory store. */
+export declare function createInProcessAgentRunHost(deps: InProcessAgentRunHostDeps): InProcessAgentRunHost;
+//# sourceMappingURL=in-process-host.d.ts.map

package/dist/runner/src/agents/in-process-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-process-host.d.ts","sourceRoot":"","sources":["../../../../runner/src/agents/in-process-host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EACV,UAAU,IAAI,aAAa,EAC3B,iBAAiB,EACjB,mBAAmB,EACnB,MAAM,EACP,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAUrD,MAAM,WAAW,yBAAyB;IACxC,mGAAmG;IACnG,UAAU,EAAE,MAAM,SAAS,cAAc,EAAE,CAAC;IAC5C,wGAAwG;IACxG,aAAa,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,kBAAkB,CAAC,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IACjF,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,qBAAqB,GAAG,CAAC,CACnC,OAAO,EAAE,mBAAmB,KACzB,OAAO,CAAC,iBAAiB,CAAC,CAAC,GAAG;IACjC,wEAAwE;IACxE,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAWF,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAgB9E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAqBvD;AA0CD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,GAAG,kBAAkB,CAmBtF;AA2ED,sGAAsG;AACtG,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,yBAAyB,GAC9B,qBAAqB,CA+DvB"}

package/dist/runner/src/agents/instances.d.ts

@@ -0,0 +1,62 @@
+/**
+ * agents/instances.ts
+ *
+ * The agent instances a session can see and run: the entries of `skaile.yaml`
+ * `agents:` (plus the primary `agent:` as `default`) and the `binding: run`
+ * sub-agents the running instance composes. Each one is resolved without a
+ * model and without a run snapshot (`dryRun`), so a target that does not
+ * resolve is reported as `unavailable` instead of failing the listing.
+ *
+ * Feeds `session_init_ack.instances`, `agent.list` and `agent.run`.
+ */
+import { type AgentInstanceConfig, type SkWorkspaceConfig } from "@skaile/workspaces/core";
+import type { IAssetKindRegistry } from "@skaile/workspaces/plugins";
+import type { AgentInstanceSummary, Logger } from "@skaile/workspaces/types";
+import type { AgentIo } from "@skaile/workspaces/types/manifests";
+import { type ResolvedAgentInstance, type ResolvedMemoryBlock } from "../composition/resolve-instance.js";
+/** One instance (or composed `run` sub-agent) an `agent.run` call can address. */
+export interface AgentRunTarget {
+    /** Instance id, or the alias (`composes[].as`) of a composed `run` sub-agent. */
+    id: string;
+    /** `workspace` = an `agents:` entry; `composed` = a `binding: run` item of the running instance. */
+    source: "workspace" | "composed";
+    /** `agents.<id>.ref`, or the composed item's `ref`, as written. */
+    ref: string;
+    lifecycle: "standing" | "role";
+    description?: string;
+    /** Resolved agent directory; empty when the target is unavailable. */
+    agentDir: string;
+    instance: AgentInstanceConfig;
+    io?: AgentIo;
+    /** Memory blocks of the instance (seeded content, no host content); empty when unavailable. */
+    memoryBlocks: ResolvedMemoryBlock[];
+    revisionHash?: string;
+    /** `agents.<id>.permissions.permission_mode`; `agent.run` asks for approval on `interactive`. */
+    permissionMode?: "auto" | "interactive";
+    /** Turn bound of a run: instance budget, then `permissions.max_turns`, then the asset's `runtime.max_turns`. */
+    maxTurns?: number;
+    maxTokens?: number;
+    status: "ready" | "unavailable";
+    error?: string;
+}
+export interface LoadAgentRunTargetsOpts {
+    projectDir: string;
+    wsConfig: Pick<SkWorkspaceConfig, "agent">;
+    /** Kind registry for the content source; defaults to the built-in providers. */
+    registry?: IAssetKindRegistry;
+    /** Whether the driver has native sub-agents (decides the default binding of `kind: agent` items). */
+    nativeSubagents?: boolean;
+    /** Capability names the host provides (checked against `capabilities[]`, which only warns in a dry run). */
+    hostCapabilities?: readonly string[];
+    /** The instance this session runs: its `binding: run` sub-agents are targets too. */
+    current?: {
+        resolved: ResolvedAgentInstance;
+        agentDir: string;
+    } | null;
+    log?: Logger;
+}
+/** Every `agents:` instance of the workspace, then the composed `run` sub-agents of the running instance. */
+export declare function loadAgentRunTargets(opts: LoadAgentRunTargetsOpts): Promise<AgentRunTarget[]>;
+/** The picker view of the workspace's own instances (what `session_init_ack.instances` carries). */
+export declare function summarizeInstances(targets: readonly AgentRunTarget[]): AgentInstanceSummary[];
+//# sourceMappingURL=instances.d.ts.map

package/dist/runner/src/agents/instances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instances.d.ts","sourceRoot":"","sources":["../../../../runner/src/agents/instances.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EACL,KAAK,mBAAmB,EAIxB,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAClE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EAEzB,MAAM,oCAAoC,CAAC;AAG5C,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC7B,iFAAiF;IACjF,EAAE,EAAE,MAAM,CAAC;IACX,oGAAoG;IACpG,MAAM,EAAE,WAAW,GAAG,UAAU,CAAC;IACjC,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,UAAU,GAAG,MAAM,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,+FAA+F;IAC/F,YAAY,EAAE,mBAAmB,EAAE,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iGAAiG;IACjG,cAAc,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC;IACxC,gHAAgH;IAChH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,GAAG,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC;IAC3C,gFAAgF;IAChF,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,qGAAqG;IACrG,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,4GAA4G;IAC5G,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,qFAAqF;IACrF,OAAO,CAAC,EAAE;QAAE,QAAQ,EAAE,qBAAqB,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACvE,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAsED,6GAA6G;AAC7G,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,cAAc,EAAE,CAAC,CAwC3B;AAED,oGAAoG;AACpG,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,GAAG,oBAAoB,EAAE,CAe7F"}

package/dist/runner/src/agents/json-schema.d.ts

@@ -0,0 +1,16 @@
+/**
+ * agents/json-schema.ts
+ *
+ * JSON Schema validation for a role's `io.input` / `io.output`. A role's schema
+ * is data an asset author wrote, so a schema that does not compile is reported
+ * like a value that does not match: an issue list, never a throw.
+ */
+export type SchemaCheck = {
+    ok: true;
+} | {
+    ok: false;
+    issues: string[];
+};
+/** Validate `value` against a JSON Schema object. */
+export declare function checkAgainstSchema(schema: Record<string, unknown>, value: unknown): SchemaCheck;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/runner/src/agents/json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../../../../runner/src/agents/json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,MAAM,WAAW,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AA0BzE,qDAAqD;AACrD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,WAAW,CAK/F"}

package/dist/runner/src/agents/memory-run-store.d.ts

@@ -0,0 +1,19 @@
+/**
+ * agents/memory-run-store.ts
+ *
+ * The in-process {@link RunStore}: runs, run events and approvals in maps. The
+ * store `skaile run` uses (its runs end with the process) and the one tests
+ * hand to the run controller. A host with durable storage implements
+ * `RunStore` over its database instead.
+ *
+ * Every method is synchronous inside, so the compare-and-set `transition*`
+ * methods are atomic by construction.
+ */
+import type { RunStore } from "@skaile/workspaces/types";
+/** Finished run trees an in-memory store keeps (results stay readable); older ones are evicted. */
+export declare const DEFAULT_MAX_FINISHED_TREES = 200;
+/** Build an empty in-memory {@link RunStore}. Rows are copied on the way in and out, so callers never alias stored state. */
+export declare function createInMemoryRunStore(options?: {
+    maxFinishedTrees?: number;
+}): RunStore;
+//# sourceMappingURL=memory-run-store.d.ts.map

package/dist/runner/src/agents/memory-run-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-run-store.d.ts","sourceRoot":"","sources":["../../../../runner/src/agents/memory-run-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAUV,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAElC,mGAAmG;AACnG,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAE9C,6HAA6H;AAC7H,wBAAgB,sBAAsB,CAAC,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,QAAQ,CA8I5F"}

package/dist/runner/src/agents/run-controller.d.ts

@@ -0,0 +1,208 @@
+/**
+ * agents/run-controller.ts
+ *
+ * The framework-owned lifecycle of `agent.run` runs, independent of the host
+ * that stores them and the driver that executes them.
+ *
+ * ```text
+ *             ┌───────────── approve ─────────────┐
+ * queued ──► running ──► waiting_approval ◄── (a held capability call)
+ *   ▲          │ └────► waiting_children ──┐ (children still live when the turn ends)
+ *   └──────────┴───────── resume ◄─────────┘
+ *              └──► succeeded | failed | cancelled   (cancelled from any live state)
+ * ```
+ *
+ * What it guarantees, whichever host drives it:
+ *
+ * - **Limits.** A run may delegate to a depth of {@link RunLimits.maxDepth}
+ *   (a root run started outside any run is depth 1) and a root run has at most
+ *   {@link RunLimits.maxConcurrentChildren} live descendants. A run whose
+ *   turn ended with live children is `waiting_children` and holds no driver;
+ *   the last child to finish resumes it with a host message.
+ * - **Serialization.** Runs of one `standing` instance execute one at a time
+ *   (a queue, so memory writes never interleave); other instances and `role`
+ *   instances run concurrently.
+ * - **Idempotent start.** A start with the same `(callerSessionId, callId)`
+ *   answers the run the first one created.
+ * - **Persisted approvals.** A held capability call (`requestApproval`) or a
+ *   held start parks the run in `waiting_approval`, its turn ends, and the
+ *   approval row survives a restart. Deciding claims the row with a
+ *   compare-and-set, so the stored operation executes at most once, with the
+ *   `operationId` it was parked under; its result is persisted before the
+ *   session is resumed with `{operationId, status, result}`. A decision on a
+ *   consumed or expired approval, or on one whose stored args no longer hash
+ *   to `argsHash`, is `approval_invalid`; so is re-requesting a call with
+ *   changed args.
+ * - **Cancel** stops the run and every descendant; their pending approvals expire.
+ *
+ * The controller imports nothing of a host: storage is the injected
+ * {@link RunStore}, execution the injected {@link RunLauncher}, policy the
+ * injected `authorize`, and the held operation runs through the injected
+ * `execute`. Run state changes go to the store's event log and `onEvent`;
+ * `subagent` protocol events go to `emit`.
+ */
+import type { AgentRun, AgentRunEventRecord, AgentRunFailure, AgentRunReport, Logger, RunHostMessage, RunStore, SubagentEvent } from "@skaile/workspaces/types";
+import type { AgentIo } from "@skaile/workspaces/types/manifests";
+/** Who acts. Built by the host from its own authentication, never from a model payload. */
+export interface RunActor {
+    /** User or service id; recorded as `AgentRun.requestedBy` on a start. */
+    id: string;
+    /**
+     * The session the call comes from. When set, the run must belong to this
+     * session's delegation tree (the session, or a run it started, dispatched
+     * it); an agent never reaches a run outside its own tree. Absent for a
+     * host-level actor (a REST route): only `authorize` gates it.
+     */
+    sessionId?: string;
+}
+export type RunAction = "start" | "read" | "cancel" | "decide" | "resume";
+/** What the controller needs to know about an instance a run addresses. */
+export interface RunInstanceInfo {
+    id: string;
+    lifecycle: "standing" | "role";
+    description?: string;
+    revisionHash?: string;
+    io?: AgentIo;
+    status: "ready" | "unavailable";
+    error?: string;
+}
+/** The delegation and concurrency bounds. */
+export interface RunLimits {
+    /** Deepest run chain; a root run started outside any run is depth 1. Default 2. */
+    maxDepth: number;
+    /** Live descendants one root run may have. Default 4. */
+    maxConcurrentChildren: number;
+}
+export declare const DEFAULT_RUN_LIMITS: RunLimits;
+export interface StartRunRequest {
+    instanceId: string;
+    /** Revision the caller saw; a different current revision is `revision_changed`. */
+    revisionHash?: string;
+    input?: unknown;
+    budget?: {
+        max_turns?: number;
+        max_tokens?: number;
+    };
+    /** Capability-dispatch call id; with the actor's session the idempotency key of the start. */
+    callId?: string;
+    /** `required` parks the run in `waiting_approval` until `decideApproval`. */
+    approval?: "required" | "none";
+}
+/** What one turn of a run's session is told to do. */
+export type RunTurn = {
+    kind: "start";
+    input: unknown;
+} | {
+    kind: "resume";
+    messages: RunHostMessage[];
+};
+/** How a turn ended. A run that is `waiting_approval` or `cancelled` after its turn ignores the outcome. */
+export type RunTurnOutcome = {
+    kind: "completed";
+    output?: unknown;
+} | {
+    kind: "failed";
+    error: AgentRunFailure;
+};
+/** The session a launcher built for one turn. */
+export interface RunDriverHandle {
+    /** Name of the driver the run executes on (`AgentRun.harness`). */
+    harness: string;
+    /** Run the turn to its end. Must settle promptly once the launch `signal` aborts. */
+    turn(turn: RunTurn): Promise<RunTurnOutcome>;
+    abort(reason?: unknown): void;
+    /** Release the session's process. Called after every turn: a suspended run holds no driver. */
+    dispose(): Promise<void>;
+}
+/** Answer of {@link RunLaunchContext.requestApproval} to the session's capability call. */
+export type RunOperationApproval = {
+    status: "pending_approval";
+    approvalId: string;
+    operationId: string;
+} | {
+    status: "approved" | "denied" | "expired";
+    approvalId: string;
+    operationId: string;
+    result?: unknown;
+    error?: AgentRunFailure;
+};
+export interface RunLaunchContext {
+    run: AgentRun;
+    /** `true` when the run's native session (`run.sessionId`) already exists and is continued. */
+    resuming: boolean;
+    /** The identity calls from this run's session carry (`{ id: run.requestedBy, sessionId: run.sessionId }`). */
+    actor: RunActor;
+    /** Aborts when the run is cancelled. */
+    signal: AbortSignal;
+    /**
+     * For the session's capability bridge: hold a `requiresApproval` call
+     * instead of executing it. Hand the answer to the model as the call's
+     * result; the run's turn ends and the controller resumes it after the decision.
+     */
+    requestApproval: (call: {
+        callId?: string;
+        capability: string;
+        args: unknown;
+    }) => Promise<RunOperationApproval>;
+}
+/** Builds the session for one turn of a run. */
+export type RunLauncher = (ctx: RunLaunchContext) => Promise<RunDriverHandle>;
+/** One held operation, handed to `execute` when its approval is granted. */
+export interface ApprovedOperation {
+    runId: string;
+    /** Stable across redelivery: execute the effect under this id so a host can deduplicate. */
+    operationId: string;
+    capability: string;
+    args: unknown;
+    /** The run's own identity, as the capability call would have carried it. */
+    actor: RunActor;
+}
+export interface RunControllerDeps {
+    store: RunStore;
+    launch: RunLauncher;
+    /** Host policy. Throw to refuse; the controller reports `not_authorized`. */
+    authorize: (actor: RunActor, run: AgentRun, action: RunAction) => void | Promise<void>;
+    /** The instance a run addresses; `undefined` = unknown. */
+    getInstance: (instanceId: string) => RunInstanceInfo | undefined | Promise<RunInstanceInfo | undefined>;
+    /** Execute an approved operation (the capability call the run was held on). Its return value is persisted as the result. */
+    execute: (operation: ApprovedOperation) => Promise<unknown>;
+    workspaceId: string;
+    limits?: Partial<RunLimits>;
+    /** `subagent` protocol events (started when a run is created, finished when it ends). */
+    emit?: (event: SubagentEvent) => void;
+    /** Called after each event was appended to the store's log; broadcast from here. */
+    onEvent?: (record: AgentRunEventRecord) => void;
+    /** Id of a run's native session; default `<workspaceId>:run:<runId>`. */
+    sessionIdFor?: (runId: string) => string;
+    log?: Logger;
+}
+/** A refused or impossible request. `code` is stable and reaches the model and the host unchanged. */
+export declare class AgentRunError extends Error {
+    readonly code: string;
+    readonly issues?: string[] | undefined;
+    constructor(code: string, message: string, issues?: string[] | undefined);
+}
+export interface RunController {
+    /** Create a run and queue it (or hold it behind an approval). Answers at once; see {@link waitForRun}. */
+    startRun(request: StartRunRequest, actor: RunActor): Promise<AgentRunReport>;
+    getRun(runId: string, actor: RunActor): Promise<AgentRun>;
+    getRunReport(runId: string, actor: RunActor): Promise<AgentRunReport>;
+    /** Resolve when the run ended or needs a decision (`waiting_approval`). */
+    waitForRun(runId: string, actor: RunActor): Promise<AgentRunReport>;
+    /** Cancel the run and all its descendants. */
+    cancelRun(runId: string, actor: RunActor): Promise<AgentRunReport>;
+    decideApproval(approvalId: string, decision: "approve" | "deny", actor: RunActor): Promise<AgentRunReport>;
+    /** Continue a run no driver of this process holds: re-queue it, or finish a delivery a restart cut short. */
+    resumeRun(runId: string, actor: RunActor): Promise<AgentRunReport>;
+    /** See {@link RunLaunchContext.requestApproval}. Trusted: the host's session bridge calls it, not the model. */
+    requestApproval(runId: string, call: {
+        callId?: string;
+        capability: string;
+        args: unknown;
+    }): Promise<RunOperationApproval>;
+    /** Cancel every run still live in this process and wait for their sessions to wind down. */
+    dispose(): Promise<void>;
+}
+/** Build a run controller over an injected store, launcher and authorizer. */
+export declare function createRunController(deps: RunControllerDeps): RunController;
+//# sourceMappingURL=run-controller.d.ts.map