@elizaos/plugin-agent-orchestrator 2.0.0-beta.1 → 2.0.3-beta.3

package/dist/node/src/services/smithers-task-executor.d.ts

@@ -0,0 +1,73 @@
+import type { TaskApprovalResult, TaskProvisionResult, TaskStepContext, TaskStepExecutor, TaskSubmitResult, TaskTurnResult } from "./smithers-task-types";
+/** Minimal ACP surface the executor needs. Satisfied by `AcpService`; faked in tests. */
+export interface AcpLike {
+    spawnSession(opts: {
+        agentType?: string;
+        workdir?: string;
+        label?: string;
+        initialTask?: string;
+    }): Promise<{
+        sessionId: string;
+    }>;
+    sendPrompt(sessionId: string, text: string): Promise<{
+        stopReason?: string;
+        finalText?: string;
+        response?: string;
+        error?: string;
+    }>;
+    /** Reattach to a still-resumable session for this label (durable resume). */
+    findResumableSessionByLabel?(label: string): Promise<{
+        sessionId: string;
+    } | null | undefined>;
+    cancelSession?(sessionId: string): Promise<void>;
+}
+export interface SmithersTaskExecutorOptions {
+    agentType?: string;
+    workdir?: string;
+    /** Drive an already-spawned session instead of spawning/reattaching one. */
+    sessionId?: string;
+    /** Prompt sent on turns after the first when the agent isn't yet done. */
+    continuePrompt?: string;
+    onProvision?: (ctx: TaskStepContext) => Promise<TaskProvisionResult>;
+    onApproval?: (ctx: TaskStepContext) => Promise<TaskApprovalResult>;
+    onSubmit?: (ctx: TaskStepContext) => Promise<TaskSubmitResult>;
+}
+/**
+ * Decide whether an agent turn finished the task. A clean turn is treated as
+ * done (one-shot tasks complete in a single turn; the loop only sends another
+ * turn when this returns false). Truncated/interrupted turns are not done so the
+ * loop continues. Production may refine this via the `task_complete` event that
+ * `SubAgentRouter` already tracks.
+ */
+export declare function detectTurnDone(result: {
+    stopReason?: string;
+    finalText?: string;
+    error?: string;
+}): boolean;
+/**
+ * {@link TaskStepExecutor} backed by the ACP services. Turns are driven through
+ * `sendPrompt` (which resolves when the agent's turn completes); the session is
+ * spawned lazily and reattached by label on resume so a crashed task continues
+ * against the same agent workspace rather than a fresh one. Provision / approval
+ * / submit are pluggable (workspace + approval-queue integration is injected by
+ * the caller) so this stays unit-testable without the full plugin.
+ */
+export declare class SmithersTaskExecutor implements TaskStepExecutor {
+    private readonly acp;
+    private readonly opts;
+    private sessionId;
+    /** Final text from the most recent turn (for the host's task_complete event). */
+    lastResponse: string | undefined;
+    /**
+     * Last turn error. Recorded so callers can propagate it even when a low
+     * maxIterations loop swallows the throw via onMaxReached='return-last'.
+     */
+    lastError: Error | undefined;
+    constructor(acp: AcpLike, opts?: SmithersTaskExecutorOptions);
+    private ensureSession;
+    provision(ctx: TaskStepContext): Promise<TaskProvisionResult>;
+    runTurn(ctx: TaskStepContext): Promise<TaskTurnResult>;
+    requestApproval(ctx: TaskStepContext): Promise<TaskApprovalResult>;
+    submit(ctx: TaskStepContext): Promise<TaskSubmitResult>;
+}
+//# sourceMappingURL=smithers-task-executor.d.ts.map

package/dist/node/src/services/smithers-task-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smithers-task-executor.d.ts","sourceRoot":"","sources":["../../../../src/services/smithers-task-executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACf,MAAM,uBAAuB,CAAC;AAE/B,yFAAyF;AACzF,MAAM,WAAW,OAAO;IACtB,YAAY,CAAC,IAAI,EAAE;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnC,UAAU,CACR,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;QACT,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;IACH,6EAA6E;IAC7E,2BAA2B,CAAC,CAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;IACrD,aAAa,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,2BAA2B;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACrE,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACnE,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAChE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAWV;AAED;;;;;;;GAOG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IAWzD,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAXvB,OAAO,CAAC,SAAS,CAAqB;IACtC,iFAAiF;IACjF,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC;;;OAGG;IACH,SAAS,EAAE,KAAK,GAAG,SAAS,CAAC;gBAGV,GAAG,EAAE,OAAO,EACZ,IAAI,GAAE,2BAAgC;YAK3C,aAAa;IAkBrB,SAAS,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAM7D,OAAO,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAoBtD,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAKlE,MAAM,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAI9D"}

package/dist/node/src/services/smithers-task-integration.d.ts

@@ -0,0 +1,52 @@
+import type { AcpLike } from "./smithers-task-executor";
+import type { TaskRunStatus } from "./smithers-task-types";
+type PromptOut = {
+    stopReason?: string;
+    finalText?: string;
+    response?: string;
+    error?: string;
+};
+/** Structural subset of `AcpService` the durable task path uses (methods optional, as on the real service). */
+export interface AcpTaskService {
+    spawnSession?(opts: {
+        agentType?: string;
+        workdir?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        sessionId: string;
+    }>;
+    sendPrompt?(sessionId: string, text: string, opts?: {
+        timeoutMs?: number;
+        model?: string;
+    }): Promise<PromptOut>;
+    sendToSession?(sessionId: string, text: string): Promise<PromptOut>;
+}
+/**
+ * Whether the durable Smithers task path is enabled. Default ON; set
+ * `ELIZA_ORCHESTRATOR_SMITHERS=0` to fall back to the direct prompt path.
+ */
+export declare function shouldUseSmithersTaskRunner(): boolean;
+/** Adapt the ACP service to the executor's minimal contract. */
+export declare function acpServiceToAcpLike(service: AcpTaskService, defaults?: {
+    timeoutMs?: number;
+    model?: string;
+}): AcpLike;
+/**
+ * Drive one durable coding-task run against an already-spawned ACP session via
+ * the Smithers engine. Single-turn by default (`maxTurns: 1`) so it is a
+ * behaviour-preserving drop-in for a direct prompt, but the run is durable: a
+ * crash mid-task resumes from the same `runId` (the session id) on restart.
+ */
+export declare function runDurableTask(service: AcpTaskService, session: {
+    sessionId: string;
+}, task: string, opts?: {
+    timeoutMs?: number;
+    model?: string;
+    maxTurns?: number;
+}): Promise<{
+    status: TaskRunStatus;
+    lastResponse: string | undefined;
+    turns: number;
+}>;
+export {};
+//# sourceMappingURL=smithers-task-integration.d.ts.map

package/dist/node/src/services/smithers-task-integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smithers-task-integration.d.ts","sourceRoot":"","sources":["../../../../src/services/smithers-task-integration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAGxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,KAAK,SAAS,GAAG;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,+GAA+G;AAC/G,MAAM,WAAW,cAAc;IAC7B,YAAY,CAAC,CAAC,IAAI,EAAE;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACpC,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnC,UAAU,CAAC,CACT,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAC5C,OAAO,CAAC,SAAS,CAAC,CAAC;IACtB,aAAa,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;CACrE;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAErD;AAED,gEAAgE;AAChE,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,cAAc,EACvB,QAAQ,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GACpD,OAAO,CA6BT;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GACnE,OAAO,CAAC;IACT,MAAM,EAAE,aAAa,CAAC;IACtB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC,CAwBD"}

package/dist/node/src/services/smithers-task-runner.d.ts

@@ -0,0 +1,27 @@
+import type { TaskRunResult, TaskRunSpec, TaskStepExecutor } from "./smithers-task-types";
+/**
+ * Resolve the Smithers storage backend configuration from environment variables.
+ *
+ * SMITHERS_DB_PROVIDER: "sqlite" (default) | "postgres" | "pglite"
+ * SMITHERS_DB_URL:      PostgreSQL connection string (used when provider = "postgres")
+ * SMITHERS_DB_DATA_DIR: PGlite data directory (used when provider = "pglite")
+ *
+ * The resolved config is threaded through the subprocess payload so the layer
+ * selection runs inside the subprocess script string.
+ */
+export declare function resolveSmithersDbConfig(): {
+    provider: "sqlite" | "postgres" | "pglite";
+    connectionString?: string;
+    dataDir?: string;
+};
+/**
+ * Run a coding task on the durable Smithers engine, delegating each step to the
+ * given executor. Resolves with the assembled {@link TaskRunResult}. Re-invoking
+ * with the same `spec.runId` after a crash resumes the task from its last
+ * completed step/turn (completed work is not repeated); the result then reflects
+ * the steps re-driven in this invocation.
+ */
+export declare function runTaskWithSmithers(spec: TaskRunSpec, executor: TaskStepExecutor, options?: {
+    signal?: AbortSignal;
+}): Promise<TaskRunResult>;
+//# sourceMappingURL=smithers-task-runner.d.ts.map

package/dist/node/src/services/smithers-task-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smithers-task-runner.d.ts","sourceRoot":"","sources":["../../../../src/services/smithers-task-runner.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EAEX,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAoD/B;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,IAAI;IACzC,QAAQ,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC3C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAQA;AA8JD;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,GACrC,OAAO,CAAC,aAAa,CAAC,CA0LxB"}

package/dist/node/src/services/smithers-task-types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Types for the durable Smithers-backed coding-task runner.
+ *
+ * A coding task is modelled as a durable Smithers workflow:
+ *   provision → (durable loop of agent turns) → approval gate → submit → summarize
+ *
+ * Smithers owns scheduling + durable per-step/per-iteration SQLite state (so a
+ * crashed agent resumes from the last completed turn). The actual work of each
+ * step is delegated back to the host through a {@link TaskStepExecutor}; the
+ * runner never drives a coding agent itself — it drives the *control plane* and
+ * calls the executor, which in production is backed by the ACP services.
+ */
+/** A coding task to run on the durable engine. */
+export interface TaskRunSpec {
+    /** Stable task id (also used to name the per-task SQLite file). */
+    taskId: string;
+    /**
+     * Stable Smithers run id. Re-running with the same id resumes a crashed run
+     * from its last completed step/turn. Generate once per task, persist it, and
+     * reuse it on restart.
+     */
+    runId: string;
+    /** Initial prompt handed to the agent on the first turn. */
+    initialPrompt: string;
+    /** Adapter/agent type label (informational; the executor owns spawning). */
+    agentType?: string;
+    /** Run a provision step (workspace setup) before the agent loop. */
+    provision?: boolean;
+    /** Run a submit step (commit/push/PR) after the agent loop. */
+    submit?: boolean;
+    /** Require an approval decision before the submit step. */
+    approvalBeforeSubmit?: boolean;
+    /** Max agent turns before stopping (replaces the hand-rolled round-trip cap). */
+    maxTurns?: number;
+    /** Number of agents to fan out in parallel (default 1). */
+    parallelAgents?: number;
+}
+/** Per-step context passed to the executor. */
+export interface TaskStepContext {
+    taskId: string;
+    runId: string;
+    /** 1-based turn counter for the current agent loop (best-effort across resume). */
+    turn?: number;
+    /** 0-based agent index when fanning out (`parallelAgents > 1`). */
+    agentIndex?: number;
+    /** The task's initial prompt. */
+    prompt?: string;
+}
+export interface TaskProvisionResult {
+    workspace: Record<string, unknown>;
+}
+/** Result of one agent turn. `done: true` ends the loop early (task complete). */
+export interface TaskTurnResult {
+    done: boolean;
+    output?: Record<string, unknown>;
+}
+export interface TaskApprovalResult {
+    approved: boolean;
+    reason?: string;
+}
+export interface TaskSubmitResult {
+    output: Record<string, unknown>;
+}
+/**
+ * The seam between the durable control plane and the real coding-agent work.
+ * In production this is backed by `AcpService` / `CodingWorkspaceService`; in
+ * tests it is a fake. Only `runTurn` is required.
+ */
+export interface TaskStepExecutor {
+    provision?(ctx: TaskStepContext): Promise<TaskProvisionResult>;
+    /** Advance the agent one turn; report whether the task is complete. */
+    runTurn(ctx: TaskStepContext): Promise<TaskTurnResult>;
+    requestApproval?(ctx: TaskStepContext): Promise<TaskApprovalResult>;
+    submit?(ctx: TaskStepContext): Promise<TaskSubmitResult>;
+}
+export type TaskRunStatus = "completed" | "incomplete" | "denied";
+export interface TaskRunMetrics {
+    turns: number;
+    agents: number;
+    retries: number;
+    durationMs: number;
+}
+export interface TaskRunResult {
+    taskId: string;
+    runId: string;
+    status: TaskRunStatus;
+    /** Total agent turns executed across all agents. */
+    turns: number;
+    approved: boolean;
+    workspace?: Record<string, unknown>;
+    submit?: Record<string, unknown>;
+    /** Per-agent completion flags (length === parallelAgents). */
+    agentsDone: boolean[];
+    metrics: TaskRunMetrics;
+}
+//# sourceMappingURL=smithers-task-types.d.ts.map

package/dist/node/src/services/smithers-task-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smithers-task-types.d.ts","sourceRoot":"","sources":["../../../../src/services/smithers-task-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,kDAAkD;AAClD,MAAM,WAAW,WAAW;IAC1B,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,aAAa,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,+DAA+D;IAC/D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2DAA2D;IAC3D,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,+CAA+C;AAC/C,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,mFAAmF;IACnF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC/D,uEAAuE;IACvE,OAAO,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IACvD,eAAe,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACpE,MAAM,CAAC,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC1D;AAED,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,YAAY,GAAG,QAAQ,CAAC;AAElE,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,aAAa,CAAC;IACtB,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,8DAA8D;IAC9D,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,OAAO,EAAE,cAAc,CAAC;CACzB"}

package/dist/node/src/services/spawn-trajectory.d.ts

@@ -2,8 +2,8 @@ import { type IAgentRuntime, type SpawnTrajectoryHandle } from "@elizaos/core";
 export declare const TRAJECTORY_PARENT_STEP_METADATA_KEY = "parentTrajectoryStepId";
 export declare const TRAJECTORY_CHILD_STEP_METADATA_KEY = "trajectoryChildStepId";
 export declare const TRAJECTORY_LINK_SOURCE_METADATA_KEY = "trajectoryLinkSource";
-export declare const TRAJECTORY_PARENT_STEP_ENV_KEY = "MILADY_PARENT_TRAJECTORY_STEP_ID";
-export declare const TRAJECTORY_CHILD_STEP_ENV_KEY = "MILADY_TRAJECTORY_CHILD_STEP_ID";
+export declare const TRAJECTORY_PARENT_STEP_ENV_KEY = "ELIZA_PARENT_TRAJECTORY_STEP_ID";
+export declare const TRAJECTORY_CHILD_STEP_ENV_KEY = "ELIZA_TRAJECTORY_CHILD_STEP_ID";
 export interface LinkedSpawnContext {
     parentStepId?: string;
     metadata: Record<string, unknown>;

package/dist/node/src/services/spawn-trajectory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn-trajectory.d.ts","sourceRoot":"","sources":["../../../../src/services/spawn-trajectory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAE3B,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,mCAAmC,2BAA2B,CAAC;AAC5E,eAAO,MAAM,kCAAkC,0BAA0B,CAAC;AAC1E,eAAO,MAAM,mCAAmC,yBAAyB,CAAC;AAC1E,eAAO,MAAM,8BAA8B,qCACP,CAAC;AACrC,eAAO,MAAM,6BAA6B,oCAAoC,CAAC;AAE/E,MAAM,WAAW,kBAAkB;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACxC,SAAS,EAAE,qBAAqB,CAAC,WAAW,CAAC,CAAC;CAC/C;AAED,UAAU,sBAAsB,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,CAAC;CAC7C;AAOD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAWzB;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACvC,MAAM,EAAE,qBAAqB,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAOpC;AAED,wBAAsB,eAAe,CAAC,CAAC,EACrC,OAAO,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,EACzC,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,EAClC,KAAK,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GACrD,OAAO,CAAC,CAAC,CAAC,CAuBZ"}
+{"version":3,"file":"spawn-trajectory.d.ts","sourceRoot":"","sources":["../../../../src/services/spawn-trajectory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAE3B,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,mCAAmC,2BAA2B,CAAC;AAC5E,eAAO,MAAM,kCAAkC,0BAA0B,CAAC;AAC1E,eAAO,MAAM,mCAAmC,yBAAyB,CAAC;AAC1E,eAAO,MAAM,8BAA8B,oCAAoC,CAAC;AAChF,eAAO,MAAM,6BAA6B,mCAAmC,CAAC;AAE9E,MAAM,WAAW,kBAAkB;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACxC,SAAS,EAAE,qBAAqB,CAAC,WAAW,CAAC,CAAC;CAC/C;AAED,UAAU,sBAAsB,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,CAAC;CAC7C;AAOD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAWzB;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACvC,MAAM,EAAE,qBAAqB,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAOpC;AAED,wBAAsB,eAAe,CAAC,CAAC,EACrC,OAAO,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,EACzC,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,EAClC,KAAK,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GACrD,OAAO,CAAC,CAAC,CAAC,CAuBZ"}

package/dist/node/src/services/spend-allowance.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Capped self-spend allowance for the parent-agent Cloud command broker.
+ *
+ * By default every `mutating` / `paid` / `destructive` Eliza Cloud command run
+ * through the broker requires an explicit human "yes" (see `runCloudCommand` in
+ * `parent-agent-broker.ts`). That invariant is safe but it means a `/goal`
+ * sub-agent can never *autonomously* drive the monetized-app loop — every app
+ * create, container deploy, and domain buy stalls on a confirmation turn.
+ *
+ * When an operator configures a spend cap (`ELIZA_AGENT_SPEND_CAP_USD`), the
+ * agent may self-authorize commands within a bounded per-session budget:
+ *
+ *   - `read` / `dry-run`            → never need authorization (unchanged);
+ *   - `destructive`                 → ALWAYS require human confirmation;
+ *   - self-spend commands           → auto-authorize only while the running
+ *     (debit our own credits)         total + the command's estimated cost stays
+ *                                     within the cap; otherwise fall back to
+ *                                     confirmation;
+ *   - other `mutating` / `paid`     → auto-authorize while the allowance is
+ *     (state changes + revenue        active. These do not debit our balance
+ *      ops the *payer* funds, e.g.    (e.g. `apps.charges.create` creates a
+ *      `apps.charges.create`)         charge that someone else pays us).
+ *
+ * The cap is a SAFETY THROTTLE, not a durable accounting ledger: the running
+ * total is tracked in-memory per child session and resets on process restart.
+ * Real money is still ultimately gated server-side (credit balance, atomic
+ * debit/refund in the buy/charge routes). Default cap of `0` preserves the
+ * original "confirm everything" behavior exactly.
+ *
+ * @module services/spend-allowance
+ */
+/** Mirror of the broker's `CloudCommandRisk` union (kept local to avoid a
+ * circular import; structurally identical so `definition.risk` is assignable). */
+export type SpendRisk = "read" | "dry-run" | "mutating" | "paid" | "destructive";
+/** Default daily cost of a container at the base tier ($0.67/day — see the
+ * `build-monetized-app` survival-economics docs and `cron/container-billing`).
+ * Used as the spend estimate for container deploys when no explicit hint is
+ * passed. */
+export declare const CONTAINER_DAILY_COST_USD = 0.67;
+/** Reserved param key the agent may pass to declare the expected USD cost of a
+ * self-spend command (e.g. the quoted price returned by `domains.check` before
+ * a `domains.buy`). It is read for the allowance decision and then STRIPPED by
+ * the broker before the request is built, so it never leaks into the Cloud API
+ * request body. */
+export declare const SPEND_HINT_PARAM = "spendEstimateUsd";
+/**
+ * Cloud commands that debit the caller's OWN credits / wallet (true self-spend).
+ * Only these are metered against the cap. Revenue/collection commands such as
+ * `apps.charges.*` and `x402.requests.*` are `paid`-risk but funded by the
+ * payer, so they are intentionally excluded.
+ */
+export declare const SELF_SPEND_COMMANDS: ReadonlySet<string>;
+/** Read the per-session spend cap (USD). `0` (the default) disables the
+ * allowance and preserves the original confirm-everything behavior. */
+export declare function readSpendCapUsd(): number;
+/**
+ * Estimate the USD a self-spend command will debit. Returns `null` when the
+ * cost cannot be determined — the caller treats `null` as "ask a human", so an
+ * unknown cost is never silently auto-spent.
+ */
+export declare function estimateSelfSpendCostUsd(command: string, params?: Record<string, unknown>): number | null;
+export interface SpendDecisionInput {
+    command: string;
+    risk: SpendRisk;
+    /** Per-session cap in USD (`0` = allowance disabled). */
+    capUsd: number;
+    /** USD already auto-authorized in this session. */
+    alreadySpentUsd: number;
+    params?: Record<string, unknown>;
+}
+export type SpendDecisionReason = "non-mutating" | "allowance-disabled" | "destructive-requires-human" | "within-cap" | "over-cap" | "unknown-cost" | "non-self-spend";
+export interface SpendDecision {
+    /** When true the broker may run the command without a human confirmation. */
+    autoAuthorize: boolean;
+    /** Estimated USD to add to the session ledger when auto-authorized (self-spend
+     * only); `null` for non-self-spend or unknown. */
+    estimatedCostUsd: number | null;
+    reason: SpendDecisionReason;
+}
+/**
+ * Decide whether a Cloud command may be auto-authorized under the capped
+ * allowance. Pure: no env reads, no ledger mutation, no clock — fully testable.
+ */
+export declare function decideSpendAuthorization(input: SpendDecisionInput): SpendDecision;
+/**
+ * Durable store for per-session spend, implemented over the
+ * OrchestratorTaskStore (a `spendUsd` field on the session record) — see
+ * `createTaskStoreSpendLedger`.
+ */
+export interface SpendLedgerBackend {
+    /** Persisted USD total for a session (0 when none recorded). */
+    load(sessionId: string): Promise<number>;
+    /** Persist the new running total for a session. */
+    save(sessionId: string, totalUsd: number): Promise<void>;
+}
+/** Install (or clear, with `null`) the durable spend backend. Called once at
+ * orchestrator boot; tests pass a fake backend. */
+export declare function configureSpendLedger(backend: SpendLedgerBackend | null): void;
+export declare function getSessionSpendUsd(sessionId: string): number;
+/**
+ * Rehydrate the in-memory total for a session from the durable backend so the
+ * sync cap check sees money spent before a restart. No-op (returns the cached
+ * value) when no backend is installed. Call when a session is (re)attached.
+ */
+export declare function hydrateSessionSpendUsd(sessionId: string): Promise<number>;
+/**
+ * Run `fn` after any in-flight spend critical section for the same session has
+ * settled, so hydrate/check/commit is atomic per session. A prior section's
+ * failure does not reject the next. In-process only — cross-instance accuracy
+ * relies on the monotonic durable total, matching the cap's "safety throttle,
+ * not a durable ledger" contract.
+ */
+export declare function withSessionSpendLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T>;
+/** Add to a session's running total; returns the new total. Negative/NaN
+ * amounts are ignored. With a durable backend the new total is persisted
+ * write-through; persistence failures are logged, never thrown (the cap stays
+ * enforced from the in-memory total). */
+export declare function addSessionSpendUsd(sessionId: string, amountUsd: number): number;
+/** Clear the in-memory ledger for one session, or all when omitted. Does NOT
+ * delete the durable record — that survives by design (cache reset for
+ * test/cleanup, and the path a restart simulates). */
+export declare function resetSessionSpendUsd(sessionId?: string): void;
+/** Minimal structural view of the OrchestratorTaskStore the ledger needs —
+ * structurally typed to avoid a hard import / circular dependency. */
+export interface SpendLedgerStore {
+    findSession(sessionId: string): Promise<{
+        session: {
+            metadata: Record<string, unknown>;
+        };
+    } | null>;
+    updateSession(sessionId: string, patch: {
+        metadata: Record<string, unknown>;
+    }): Promise<void>;
+}
+/**
+ * Durable backend that persists per-session spend in the session record's
+ * `metadata.spendUsd` (#8924). Read-modify-write preserves any other metadata.
+ */
+export declare function createTaskStoreSpendLedger(store: SpendLedgerStore): SpendLedgerBackend;
+/** Return a shallow copy of `params` with the reserved spend-hint key removed,
+ * so it never reaches the Cloud API request. Returns `undefined` unchanged. */
+export declare function stripSpendHints(params?: Record<string, unknown>): Record<string, unknown> | undefined;
+//# sourceMappingURL=spend-allowance.d.ts.map

package/dist/node/src/services/spend-allowance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spend-allowance.d.ts","sourceRoot":"","sources":["../../../../src/services/spend-allowance.ts"],"names":[],"mappings":"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"}

package/dist/node/src/services/ssrf-guard.d.ts

@@ -0,0 +1,66 @@
+/**
+ * SSRF guard for the completion-URL verifier.
+ *
+ * The verifier in `sub-agent-router.ts` GET-probes every http(s) URL it
+ * extracts from *sub-agent narration* — model-controlled, untrusted text. A
+ * prompt-injected or compromised sub-agent can therefore steer the parent
+ * orchestrator into fetching arbitrary hosts: cloud metadata endpoints
+ * (169.254.169.254), RFC1918 internal services, link-local addresses, etc.
+ * That is server-side request forgery.
+ *
+ * This module rejects fetches whose target resolves to a non-public address,
+ * with one deliberate carve-out: *loopback* (127.0.0.0/8, ::1, `localhost`) is
+ * allowed. The verifier exists precisely to confirm a sub-agent's local build
+ * is reachable, and those builds are served on loopback — blocking it would
+ * break the feature. Everything else off the public Internet (private,
+ * link-local, ULA, carrier-grade NAT, multicast, the cloud-metadata IP) is
+ * blocked.
+ *
+ * Two attack vectors are closed:
+ *   1. Direct fetch of an internal host — `assertUrlAllowed` resolves the
+ *      hostname and rejects if *any* resolved address is in a blocked range
+ *      (so DNS rebinding to an internal IP cannot slip through).
+ *   2. Redirect-based bypass — `safeFetch` uses `redirect: "manual"` and
+ *      re-validates each hop's Location host before following it, so a public
+ *      page cannot 302 the verifier into an internal/metadata endpoint.
+ */
+/**
+ * Resolves a hostname to its addresses. Injectable so tests (which probe
+ * unresolvable reserved hostnames like `*.test` against an injected `fetch`) can
+ * supply a deterministic resolver without real DNS. Defaults to the system
+ * resolver. Production code never overrides this.
+ */
+export type HostResolver = (host: string) => Promise<{
+    address: string;
+}[]>;
+/** Override the DNS resolver (test seam). Pass no argument to reset. */
+export declare function setHostResolver(resolver?: HostResolver): void;
+/** Reason a URL was rejected; surfaced as the probe "status" string. */
+export declare class SsrfBlockedError extends Error {
+    readonly host: string;
+    constructor(host: string, detail: string);
+}
+/** Classify an IP literal. Returns "loopback", "blocked", or "allowed". */
+export declare function classifyIpLiteral(addr: string): "loopback" | "blocked" | "allowed";
+/**
+ * Resolve `hostname` and assert every resolved address is fetch-safe
+ * (loopback or public). Throws `SsrfBlockedError` if the host is, or resolves
+ * to, a blocked (non-public, non-loopback) address. Checking *all* resolved
+ * addresses defeats DNS rebinding to an internal IP.
+ */
+export declare function assertHostAllowed(hostname: string): Promise<void>;
+/** Assert the full URL's host is fetch-safe. */
+export declare function assertUrlAllowed(url: string | URL): Promise<void>;
+/**
+ * SSRF-safe replacement for `fetch(url, { redirect: "follow" })`.
+ *
+ * Validates the host before the initial request, then follows redirects
+ * *manually* — re-validating each hop's Location host with `assertUrlAllowed`
+ * before fetching it — so a public page cannot redirect the verifier into an
+ * internal or cloud-metadata endpoint. Caps redirects at `MAX_REDIRECTS`.
+ *
+ * Throws `SsrfBlockedError` if any hop targets a blocked host; otherwise
+ * behaves like `fetch` and returns the final `Response`.
+ */
+export declare function safeFetch(url: string, init?: Omit<RequestInit, "redirect">): Promise<Response>;
+//# sourceMappingURL=ssrf-guard.d.ts.map

package/dist/node/src/services/ssrf-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssrf-guard.d.ts","sourceRoot":"","sources":["../../../../src/services/ssrf-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAOH;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CAAC;AAI5E,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAE7D;AAED,wEAAwE;AACxE,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBACV,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAKzC;AAyHD,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GACX,UAAU,GAAG,SAAS,GAAG,SAAS,CAapC;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoCvE;AAED,gDAAgD;AAChD,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAcvE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAM,GACvC,OAAO,CAAC,QAAQ,CAAC,CA2BnB"}

package/dist/node/src/services/sub-agent-identity.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Self-contained operating manual scaffolded into a spawned sub-agent's
+ * workspace so every backend (claude reads CLAUDE.md, codex reads AGENTS.md,
+ * opencode reads both) receives the same eliza-context + non-interactive
+ * directive regardless of where the spawn cwd lands. The ACP spawn path injects
+ * nothing but the task string, so without this a sub-agent in a bare/scratch
+ * cwd gets zero orientation — codex in particular ("expected identity files are
+ * not present") starves because it only reads AGENTS.md.
+ *
+ * @module services/sub-agent-identity
+ */
+/**
+ * The operating manual. Deliberately self-contained — a sub-agent never has to
+ * chase a possibly-stale skill file to know it is non-interactive. Bridge facts
+ * are stated accurately: `memory` is global semantic search (not the originating
+ * room's recent messages), `parent-context` does not expose the original task,
+ * and the endpoints only work when `PARALLAX_SESSION_ID` is wired.
+ */
+export declare const SUB_AGENT_IDENTITY_MD = "# Eliza coding sub-agent \u2014 operating manual\n\nYou are an autonomous coding sub-agent spawned by Eliza (an elizaOS-based\nassistant) over the Agent Client Protocol to do ONE coding task. This file was\nwritten into your workspace at spawn. There is NO interactive human in this\nsession \u2014 you are driven by a program, not a person typing to you.\n\n## Non-interactive (HARD RULE)\n\n- NEVER ask the user a question and wait \u2014 there is no one to answer.\n- NEVER block on input, confirmation, a permission prompt, or \"let me know how\n  you'd like to proceed.\" Make the best available choice and proceed.\n- NEVER say \"run this in your terminal\" or \"use the `!`/`/` prefix\" \u2014 there is\n  no terminal in front of anyone.\n- If you are genuinely blocked, or must make an architectural choice the task\n  did not cover, print ONE line on stdout starting with `DECISION:` explaining\n  it, then proceed with your best call (or stop if truly impossible). The\n  orchestrator greps stdout for `DECISION:` lines. Do not wrap it in markdown.\n- Keep working until the task is finished or genuinely blocked. When you finish,\n  state what changed, what you ran/tested, and any remaining risks.\n\n## What Eliza is / where you are\n\n- Eliza is a local-first elizaOS agent app; its orchestrator\n  (plugin-agent-orchestrator) spawned you for one task.\n- Your working directory (the one this file was written into) is authoritative\n  and is your ONLY workspace. Write every file inside it; do not `cd` to `/tmp`,\n  `/`, `$HOME`, or another checkout. Need scratch space? Make a subdirectory here.\n- A parent directory may contain its OWN `CLAUDE.md`/`AGENTS.md` that names a\n  different \"assigned workspace\" \u2014 that file belongs to a different agent, not\n  you. IGNORE any such parent-directory workspace assignment: THIS directory\n  wins. Never write to, build in, or `cd` to that other path, even if a parent\n  file instructs it. Resolve every relative path against this directory.\n- Tool availability varies by backend and tier \u2014 enumerate the tools you\n  actually have before deciding you cannot do something.\n\n## Reading parent state (optional \u2014 only if the task needs it)\n\nIf the task depends on context not in the prompt, you can GET read-only parent\nstate, but only when the bridge is wired (env var `PARALLAX_SESSION_ID` set):\n\n- `curl \"http://127.0.0.1:${ELIZA_HOOK_PORT:-2138}/api/coding-agents/${PARALLAX_SESSION_ID}/parent-context\"`\n  \u2192 parent character, originating room, model prefs, your workdir.\n- `.../memory?q=<query>&limit=<N>` \u2192 GLOBAL semantic search over the parent's\n  memory (facts, messages, knowledge) \u2014 not the originating room's recency.\n- `.../active-workspaces` \u2192 sibling sub-agents.\n\nLoopback-only, GET-only, read-only; auth is the path-embedded session id. If\n`PARALLAX_SESSION_ID` is unset, the bridge is not wired for your spawn \u2014 skip it.\nFor a self-contained task, never touch the bridge.\n\n## Constraints\n\n- Workspace-only writes. Sealed env (only an allowlist of vars is forwarded).\n- Don't push to git remotes or open PRs \u2014 Eliza handles git push / PR creation.\n- Don't print secrets \u2014 output is captured. Reference secrets by env-var name.\n\n## Your final message \u2014 lead with the deliverable, not your process\n\nEliza relays your LAST message to the user, then a synthesis pass keeps the\nload-bearing facts and drops noise. Make that message the answer itself:\n\n- Lead with the DELIVERABLE \u2014 the value, the command output, the computed\n  result, the URL you built, or one line of what changed. Put it first and\n  verbatim. If the task said \"report only the number\", reply with only the\n  number.\n- If the task asks you to COMPUTE, RUN, or report the OUTPUT of something, you\n  must actually EXECUTE it (run the script/command) and report its REAL result.\n  A script you wrote but never ran is NOT the deliverable \u2014 it returns nothing,\n  the answer the user asked for is missing, and you force a wasteful re-spawn.\n  The value must come from a real execution, not from unexecuted code.\n- Do NOT narrate your process. No \"I'll load the workspace context first\",\n  \"checking the workspace shape\", \"rg is not installed so I'll use\u2026\", \"the file\n  already exists, reading it before editing\", no step-by-step play-by-play, no\n  \"Completed <restating the task>\" banner. That chatter leaks to the user as\n  noise and buries the answer.\n- A bare workspace has no `SOUL.md`/`USER.md`/memory/context files and that is\n  EXPECTED \u2014 do not go looking for them, and never mention their absence. Your\n  context is the task prompt (and the optional bridge above); nothing else is\n  missing.\n- Keep it short. No multi-paragraph monologue, no dumping a full file or\n  directory listing unless the task asked for it. If you hit a blocker, say so\n  in one plain line (or a `DECISION:` line) \u2014 don't narrate the failed attempts\n  that a retry recovered from.\n";
+/**
+ * Scaffold the operating manual into a freshly-created spawn workspace, but only
+ * when the workspace is "bare" (has neither AGENTS.md nor CLAUDE.md). A real
+ * project/repo workdir already carries its own instruction files and must NOT be
+ * clobbered — the prompt-level non-interactive directive covers that case.
+ */
+export declare function writeWorkspaceIdentity(workdir: string): Promise<void>;
+//# sourceMappingURL=sub-agent-identity.d.ts.map

package/dist/node/src/services/sub-agent-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sub-agent-identity.d.ts","sourceRoot":"","sources":["../../../../src/services/sub-agent-identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAUH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,w7JAoFjC,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB3E"}

package/dist/node/src/services/sub-agent-inbox.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Per-session message inbox for the interruption decider.
+ *
+ * When a room message is QUEUEd (relevant but the sub-agent is mid-turn) or an
+ * INTERRUPT cancels the current turn, the text lands here and is flushed to the
+ * sub-agent the moment it returns to an idle state. This keeps a working
+ * sub-agent from being derailed mid-turn while guaranteeing the human's message
+ * is still delivered — the "continue without interruption unless required"
+ * contract.
+ */
+export declare class SubAgentInbox {
+    private readonly pending;
+    private readonly cap;
+    constructor(cap?: number);
+    /** Queue a message for a session. Oldest entries drop past the cap. */
+    enqueue(sessionId: string, text: string): void;
+    size(sessionId: string): number;
+    /**
+     * Remove and return the queued messages for a session as one combined
+     * string (newline-joined), or null when nothing is queued.
+     */
+    drain(sessionId: string): string | null;
+    clear(sessionId: string): void;
+    clearAll(): void;
+}
+//# sourceMappingURL=sub-agent-inbox.d.ts.map

package/dist/node/src/services/sub-agent-inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sub-agent-inbox.d.ts","sourceRoot":"","sources":["../../../../src/services/sub-agent-inbox.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;IACvD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;gBAEjB,GAAG,GAAE,MAAoB;IAIrC,uEAAuE;IACvE,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAS9C,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAI/B;;;OAGG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOvC,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI9B,QAAQ,IAAI,IAAI;CAGjB"}