@elizaos/agent 0.25.8 → 2.0.0-alpha.144

package/packages/typescript/src/features/orchestrator/api/issue-routes.js

@@ -0,0 +1,132 @@
+/**
+ * Issue Route Handlers
+ *
+ * Handles routes for GitHub issue management:
+ * - List issues, create issue
+ * - Get issue, comment on issue, close issue
+ *
+ * @module api/issue-routes
+ */
+import { parseBody, sendError, sendJson } from "./routes.js";
+/**
+ * Handle issue routes (/api/issues/*)
+ * Returns true if the route was handled, false otherwise
+ */
+export async function handleIssueRoutes(req, res, pathname, ctx) {
+    const method = req.method?.toUpperCase();
+    // GET /api/issues?repo=owner/repo&state=open
+    if (method === "GET" && pathname === "/api/issues") {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const url = new URL(req.url || "", `http://${req.headers.host}`);
+            const repo = url.searchParams.get("repo");
+            if (!repo) {
+                sendError(res, "repo query parameter required", 400);
+                return true;
+            }
+            const state = url.searchParams.get("state");
+            const labelsParam = url.searchParams.get("labels");
+            const labels = labelsParam
+                ? labelsParam.split(",").map((s) => s.trim())
+                : undefined;
+            const issues = await ctx.workspaceService.listIssues(repo, {
+                state: state ?? "open",
+                labels,
+            });
+            sendJson(res, issues);
+        }
+        catch (error) {
+            sendError(res, error instanceof Error ? error.message : "Failed to list issues", 500);
+        }
+        return true;
+    }
+    // POST /api/issues
+    if (method === "POST" && pathname === "/api/issues") {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const body = await parseBody(req);
+            const { repo, title, body: issueBody, labels } = body;
+            if (!repo || !title) {
+                sendError(res, "repo and title are required", 400);
+                return true;
+            }
+            const issue = await ctx.workspaceService.createIssue(repo, {
+                title: title,
+                body: issueBody ?? "",
+                labels: labels,
+            });
+            sendJson(res, issue, 201);
+        }
+        catch (error) {
+            sendError(res, error instanceof Error ? error.message : "Failed to create issue", 500);
+        }
+        return true;
+    }
+    // GET /api/issues/:repo/:number (e.g., /api/issues/owner/repo/42)
+    const issueGetMatch = pathname.match(/^\/api\/issues\/([^/]+)\/([^/]+)\/(\d+)$/);
+    if (method === "GET" && issueGetMatch) {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const repo = `${issueGetMatch[1]}/${issueGetMatch[2]}`;
+            const issueNumber = parseInt(issueGetMatch[3], 10);
+            const issue = await ctx.workspaceService.getIssue(repo, issueNumber);
+            sendJson(res, issue);
+        }
+        catch (error) {
+            sendError(res, error instanceof Error ? error.message : "Failed to get issue", 500);
+        }
+        return true;
+    }
+    // POST /api/issues/:repo/:number/comment
+    const commentMatch = pathname.match(/^\/api\/issues\/([^/]+)\/([^/]+)\/(\d+)\/comment$/);
+    if (method === "POST" && commentMatch) {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const repo = `${commentMatch[1]}/${commentMatch[2]}`;
+            const issueNumber = parseInt(commentMatch[3], 10);
+            const body = await parseBody(req);
+            if (!body.body) {
+                sendError(res, "body is required", 400);
+                return true;
+            }
+            const comment = await ctx.workspaceService.addComment(repo, issueNumber, body.body);
+            sendJson(res, comment, 201);
+        }
+        catch (error) {
+            sendError(res, error instanceof Error ? error.message : "Failed to add comment", 500);
+        }
+        return true;
+    }
+    // POST /api/issues/:repo/:number/close
+    const closeMatch = pathname.match(/^\/api\/issues\/([^/]+)\/([^/]+)\/(\d+)\/close$/);
+    if (method === "POST" && closeMatch) {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const repo = `${closeMatch[1]}/${closeMatch[2]}`;
+            const issueNumber = parseInt(closeMatch[3], 10);
+            const issue = await ctx.workspaceService.closeIssue(repo, issueNumber);
+            sendJson(res, issue);
+        }
+        catch (error) {
+            sendError(res, error instanceof Error ? error.message : "Failed to close issue", 500);
+        }
+        return true;
+    }
+    // Route not handled
+    return false;
+}

package/packages/typescript/src/features/orchestrator/api/routes.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Task Agent API Routes — Dispatcher
+ *
+ * Provides shared helpers (parseBody, sendJson, sendError), types, and the
+ * top-level route dispatcher that delegates to domain-specific route modules.
+ *
+ * @module api/routes
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { IAgentRuntime } from "@elizaos/core";
+import type { PTYService } from "../services/pty-service.ts";
+import type { SwarmCoordinator } from "../services/swarm-coordinator.ts";
+import type { CodingWorkspaceService } from "../services/workspace-service.ts";
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface RouteContext {
+    runtime: IAgentRuntime;
+    ptyService: PTYService | null;
+    workspaceService: CodingWorkspaceService | null;
+    coordinator?: SwarmCoordinator;
+}
+export declare const MAX_BODY_SIZE: number;
+export declare function parseBody(req: IncomingMessage): Promise<Record<string, unknown>>;
+export declare function sendJson(res: ServerResponse, data: JsonValue, status?: number): void;
+export declare function sendError(res: ServerResponse, message: string, status?: number): void;
+/**
+ * Handle task-agent routes
+ * Returns true if the route was handled, false otherwise
+ */
+export declare function handleCodingAgentRoutes(req: IncomingMessage, res: ServerResponse, pathname: string, ctx: RouteContext): Promise<boolean>;
+/**
+ * Create route handler with services from runtime
+ */
+export declare function createCodingAgentRouteHandler(runtime: IAgentRuntime, coordinator?: SwarmCoordinator): (req: IncomingMessage, res: ServerResponse, pathname: string) => Promise<boolean>;
+export declare const createTaskAgentRouteHandler: typeof createCodingAgentRouteHandler;
+//# sourceMappingURL=routes.d.ts.map

package/packages/typescript/src/features/orchestrator/api/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/api/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAO/E,MAAM,MAAM,SAAS,GAClB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEhC,MAAM,WAAW,YAAY;IAC5B,OAAO,EAAE,aAAa,CAAC;IACvB,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,gBAAgB,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAChD,WAAW,CAAC,EAAE,gBAAgB,CAAC;CAC/B;AAGD,eAAO,MAAM,aAAa,QAAc,CAAC;AAGzC,wBAAsB,SAAS,CAC9B,GAAG,EAAE,eAAe,GAClB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAsBlC;AAGD,wBAAgB,QAAQ,CACvB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,SAAS,EACf,MAAM,SAAM,GACV,IAAI,CAGN;AAGD,wBAAgB,SAAS,CACxB,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,MAAM,EACf,MAAM,SAAM,GACV,IAAI,CAEN;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAC5C,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,YAAY,GACf,OAAO,CAAC,OAAO,CAAC,CAgClB;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC5C,OAAO,EAAE,aAAa,EACtB,WAAW,CAAC,EAAE,gBAAgB,IAEtB,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,UAAU,MAAM,sBAiBnE;AAED,eAAO,MAAM,2BAA2B,sCAAgC,CAAC"}

package/packages/typescript/src/features/orchestrator/api/routes.js

@@ -0,0 +1,96 @@
+/**
+ * Task Agent API Routes — Dispatcher
+ *
+ * Provides shared helpers (parseBody, sendJson, sendError), types, and the
+ * top-level route dispatcher that delegates to domain-specific route modules.
+ *
+ * @module api/routes
+ */
+import { handleAgentRoutes } from "./agent-routes.js";
+import { handleCoordinatorRoutes } from "./coordinator-routes.js";
+import { handleHookRoutes } from "./hook-routes.js";
+import { handleIssueRoutes } from "./issue-routes.js";
+import { handleWorkspaceRoutes } from "./workspace-routes.js";
+// Max request body size (1 MB)
+export const MAX_BODY_SIZE = 1024 * 1024;
+// Helper to parse JSON body with size limit
+export async function parseBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = "";
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += typeof chunk === "string" ? chunk.length : chunk.byteLength;
+            if (size > MAX_BODY_SIZE) {
+                req.destroy();
+                reject(new Error("Request body too large"));
+                return;
+            }
+            body += chunk;
+        });
+        req.on("end", () => {
+            try {
+                resolve(body ? JSON.parse(body) : {});
+            }
+            catch {
+                reject(new Error("Invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+// Helper to send JSON response
+export function sendJson(res, data, status = 200) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+}
+// Helper to send error
+export function sendError(res, message, status = 400) {
+    sendJson(res, { error: message }, status);
+}
+/**
+ * Handle task-agent routes
+ * Returns true if the route was handled, false otherwise
+ */
+export async function handleCodingAgentRoutes(req, res, pathname, ctx) {
+    const normalizedPathname = pathname.startsWith("/api/task-agents")
+        ? pathname.replace(/^\/api\/task-agents/, "/api/coding-agents")
+        : pathname;
+    // Delegate to hook routes first — hooks need fast responses
+    if (await handleHookRoutes(req, res, normalizedPathname, ctx)) {
+        return true;
+    }
+    // Delegate to coordinator routes (before agent routes — more specific prefix)
+    if (await handleCoordinatorRoutes(req, res, normalizedPathname, ctx)) {
+        return true;
+    }
+    // Delegate to agent routes
+    if (await handleAgentRoutes(req, res, normalizedPathname, ctx)) {
+        return true;
+    }
+    // Delegate to workspace routes
+    if (await handleWorkspaceRoutes(req, res, normalizedPathname, ctx)) {
+        return true;
+    }
+    // Delegate to issue routes
+    if (await handleIssueRoutes(req, res, normalizedPathname, ctx)) {
+        return true;
+    }
+    // Route not handled
+    return false;
+}
+/**
+ * Create route handler with services from runtime
+ */
+export function createCodingAgentRouteHandler(runtime, coordinator) {
+    return (req, res, pathname) => {
+        const ctx = {
+            runtime,
+            ptyService: runtime.getService("PTY_SERVICE"),
+            workspaceService: runtime.getService("CODING_WORKSPACE_SERVICE"),
+            coordinator: coordinator ??
+                runtime.getService("SWARM_COORDINATOR"),
+        };
+        return handleCodingAgentRoutes(req, res, pathname, ctx);
+    };
+}
+export const createTaskAgentRouteHandler = createCodingAgentRouteHandler;

package/packages/typescript/src/features/orchestrator/api/workspace-routes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Workspace Route Handlers
+ *
+ * Handles routes for git workspace management:
+ * - Provision (clone repos, create worktrees)
+ * - Get status, commit, push, create PR, delete
+ *
+ * @module api/workspace-routes
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext } from "./routes.ts";
+/**
+ * Handle workspace routes (/api/workspace/*)
+ * Returns true if the route was handled, false otherwise
+ */
+export declare function handleWorkspaceRoutes(req: IncomingMessage, res: ServerResponse, pathname: string, ctx: RouteContext): Promise<boolean>;
+//# sourceMappingURL=workspace-routes.d.ts.map

package/packages/typescript/src/features/orchestrator/api/workspace-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-routes.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/api/workspace-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAWhD;;;GAGG;AACH,wBAAsB,qBAAqB,CAC1C,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,YAAY,GACf,OAAO,CAAC,OAAO,CAAC,CAkLlB"}

package/packages/typescript/src/features/orchestrator/api/workspace-routes.js

@@ -0,0 +1,149 @@
+/**
+ * Workspace Route Handlers
+ *
+ * Handles routes for git workspace management:
+ * - Provision (clone repos, create worktrees)
+ * - Get status, commit, push, create PR, delete
+ *
+ * @module api/workspace-routes
+ */
+import { parseBody, sendError, sendJson } from "./routes.js";
+/**
+ * Handle workspace routes (/api/workspace/*)
+ * Returns true if the route was handled, false otherwise
+ */
+export async function handleWorkspaceRoutes(req, res, pathname, ctx) {
+    const method = req.method?.toUpperCase();
+    // POST /api/workspace/provision
+    if (method === "POST" && pathname === "/api/workspace/provision") {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const body = await parseBody(req);
+            const { repo, baseBranch, useWorktree, parentWorkspaceId, branchName } = body;
+            const workspace = await ctx.workspaceService.provisionWorkspace({
+                repo: repo,
+                baseBranch: baseBranch,
+                branchName: branchName,
+                useWorktree: useWorktree,
+                parentWorkspaceId: parentWorkspaceId,
+            });
+            sendJson(res, {
+                id: workspace.id,
+                path: workspace.path,
+                branch: workspace.branch,
+                isWorktree: workspace.isWorktree,
+            }, 201);
+        }
+        catch (error) {
+            sendError(res, error instanceof Error
+                ? error.message
+                : "Failed to provision workspace", 500);
+        }
+        return true;
+    }
+    // GET /api/workspace/:id
+    const workspaceMatch = pathname.match(/^\/api\/workspace\/([^/]+)$/);
+    if (method === "GET" && workspaceMatch) {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const workspaceId = workspaceMatch[1];
+            const status = await ctx.workspaceService.getStatus(workspaceId);
+            sendJson(res, status);
+        }
+        catch (error) {
+            sendError(res, error instanceof Error ? error.message : "Failed to get workspace", 500);
+        }
+        return true;
+    }
+    // POST /api/workspace/:id/commit
+    const commitMatch = pathname.match(/^\/api\/workspace\/([^/]+)\/commit$/);
+    if (method === "POST" && commitMatch) {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const workspaceId = commitMatch[1];
+            const body = await parseBody(req);
+            const { message } = body;
+            const result = await ctx.workspaceService.commit(workspaceId, {
+                message: message,
+                all: true,
+            });
+            sendJson(res, result);
+        }
+        catch (error) {
+            sendError(res, error instanceof Error ? error.message : "Failed to commit", 500);
+        }
+        return true;
+    }
+    // POST /api/workspace/:id/push
+    const pushMatch = pathname.match(/^\/api\/workspace\/([^/]+)\/push$/);
+    if (method === "POST" && pushMatch) {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const workspaceId = pushMatch[1];
+            const body = await parseBody(req);
+            const result = await ctx.workspaceService.push(workspaceId, {
+                force: body.force,
+                setUpstream: body.setUpstream,
+            });
+            sendJson(res, result);
+        }
+        catch (error) {
+            sendError(res, error instanceof Error ? error.message : "Failed to push", 500);
+        }
+        return true;
+    }
+    // POST /api/workspace/:id/pr
+    const prMatch = pathname.match(/^\/api\/workspace\/([^/]+)\/pr$/);
+    if (method === "POST" && prMatch) {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const workspaceId = prMatch[1];
+            const body = await parseBody(req);
+            const result = await ctx.workspaceService.createPR(workspaceId, {
+                title: body.title,
+                body: body.body,
+                base: body.baseBranch,
+                draft: body.draft,
+            });
+            sendJson(res, result, 201);
+        }
+        catch (error) {
+            sendError(res, error instanceof Error ? error.message : "Failed to create PR", 500);
+        }
+        return true;
+    }
+    // DELETE /api/workspace/:id
+    const deleteMatch = pathname.match(/^\/api\/workspace\/([^/]+)$/);
+    if (method === "DELETE" && deleteMatch) {
+        if (!ctx.workspaceService) {
+            sendError(res, "Workspace Service not available", 503);
+            return true;
+        }
+        try {
+            const workspaceId = deleteMatch[1];
+            await ctx.workspaceService.removeWorkspace(workspaceId);
+            sendJson(res, { success: true, workspaceId });
+        }
+        catch (error) {
+            sendError(res, error instanceof Error ? error.message : "Failed to remove workspace", 500);
+        }
+        return true;
+    }
+    // Route not handled
+    return false;
+}

package/packages/typescript/src/features/orchestrator/base-plugin.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Task Agent Plugin for Eliza
+ *
+ * Provides orchestration capabilities for CLI-based task agents:
+ * - PTY session management (spawn, control, monitor task agents)
+ * - Git workspace provisioning (clone, branch, PR creation)
+ * - GitHub issue management (create, list, update, close)
+ * - Integration with Claude Code, Codex, Gemini CLI, Aider, Pi, etc.
+ *
+ * @module orchestrator
+ */
+import type { Plugin } from "../../types/index.ts";
+/** Raw plugin object; the shipped entry applies patches in `patch-agent-orchestrator-plugin.ts`. */
+export declare const taskAgentPluginBase: Plugin;
+export declare const codingAgentPluginBase: Plugin;
+export default taskAgentPluginBase;
+/** Internal: unpatched plugin; prefer `createAgentOrchestratorPlugin` from `index.ts`. */
+export declare function createAgentOrchestratorPluginBase(): Plugin;
+//# sourceMappingURL=base-plugin.d.ts.map

package/packages/typescript/src/features/orchestrator/base-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-plugin.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/orchestrator/base-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAuBnD,oGAAoG;AACpG,eAAO,MAAM,mBAAmB,EAAE,MAyCjC,CAAC;AAEF,eAAO,MAAM,qBAAqB,QAAsB,CAAC;AAEzD,eAAe,mBAAmB,CAAC;AAEnC,0FAA0F;AAC1F,wBAAgB,iCAAiC,IAAI,MAAM,CAE1D"}

package/packages/typescript/src/features/orchestrator/base-plugin.js

@@ -0,0 +1,75 @@
+/**
+ * Task Agent Plugin for Eliza
+ *
+ * Provides orchestration capabilities for CLI-based task agents:
+ * - PTY session management (spawn, control, monitor task agents)
+ * - Git workspace provisioning (clone, branch, PR creation)
+ * - GitHub issue management (create, list, update, close)
+ * - Integration with Claude Code, Codex, Gemini CLI, Aider, Pi, etc.
+ *
+ * @module orchestrator
+ */
+import { finalizeWorkspaceAction } from "./actions/finalize-workspace.js";
+import { listAgentsAction } from "./actions/list-agents.js";
+// Actions - Issue management
+import { manageIssuesAction } from "./actions/manage-issues.js";
+// Actions - Workspace management
+import { provisionWorkspaceAction } from "./actions/provision-workspace.js";
+import { sendToAgentAction } from "./actions/send-to-agent.js";
+// Actions - PTY management
+import { spawnAgentAction } from "./actions/spawn-agent.js";
+// Actions - Unified task launcher
+import { startCodingTaskAction } from "./actions/start-coding-task.js";
+import { stopAgentAction } from "./actions/stop-agent.js";
+import { taskControlAction } from "./actions/task-control.js";
+import { taskHistoryAction } from "./actions/task-history.js";
+import { taskShareAction } from "./actions/task-share.js";
+// Providers
+import { codingAgentExamplesProvider } from "./providers/action-examples.js";
+import { activeWorkspaceContextProvider } from "./providers/active-workspace-context.js";
+// Services
+import { PTYService } from "./services/pty-service.js";
+import { CodingWorkspaceService } from "./services/workspace-service.js";
+/** Raw plugin object; the shipped entry applies patches in `patch-agent-orchestrator-plugin.ts`. */
+export const taskAgentPluginBase = {
+    name: "@elizaos/agent-orchestrator",
+    description: "Orchestrate open-ended task agents (Claude Code, Codex, Gemini CLI, Aider, Pi, etc.) via PTY sessions, " +
+        "manage workspaces, track current task status, and keep background work moving while the main agent stays in conversation",
+    // NOTE: init() is NOT reliably called by ElizaOS for workspace plugins.
+    // SwarmCoordinator and auth callback wiring is done in PTYService.start()
+    // which ElizaOS calls reliably via the services lifecycle.
+    // Services manage PTY sessions and git workspaces
+    // biome-ignore lint/suspicious/noExplicitAny: ElizaOS Plugin type expects Service[] but our classes don't extend their base Service
+    services: [PTYService, CodingWorkspaceService],
+    // Actions expose capabilities to the agent
+    actions: [
+        // Unified task launcher (provision + spawn in one step)
+        startCodingTaskAction,
+        // PTY session management (for direct control)
+        spawnAgentAction,
+        sendToAgentAction,
+        stopAgentAction,
+        listAgentsAction,
+        taskHistoryAction,
+        taskControlAction,
+        taskShareAction,
+        // Workspace management
+        provisionWorkspaceAction,
+        finalizeWorkspaceAction,
+        // Issue management
+        manageIssuesAction,
+    ],
+    // No evaluators needed for now
+    evaluators: [],
+    // Providers inject context into the prompt
+    providers: [
+        activeWorkspaceContextProvider, // Live workspace/session state
+        codingAgentExamplesProvider, // Structured action call examples
+    ],
+};
+export const codingAgentPluginBase = taskAgentPluginBase;
+export default taskAgentPluginBase;
+/** Internal: unpatched plugin; prefer `createAgentOrchestratorPlugin` from `index.ts`. */
+export function createAgentOrchestratorPluginBase() {
+    return taskAgentPluginBase;
+}

package/packages/typescript/src/features/orchestrator/claude-jsonl-completion-watcher.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Watches the Claude Code session jsonl for each active PTY session and
+ * emits a synthetic `task_complete` event when the agent produces an
+ * assistant message with `stop_reason === "end_turn"`. This is the
+ * ground-truth completion signal from Claude Code's own session record —
+ * independent of PTY buffer state, TUI ready events, or the stall
+ * classifier's buffer-text heuristics.
+ *
+ * ## Why this exists
+ *
+ * The orchestrator's historical completion detection leaned on PTY-side
+ * heuristics (buffer silence + ready event + stall-classifier LLM), all of
+ * which misfire for long open-ended tasks. Claude Code's own hooks are a
+ * more reliable signal and remain the primary path, but hooks can fail
+ * silently if the user's hook config is broken or a future Claude Code
+ * release changes the contract. The jsonl is a durable, parseable record
+ * of every turn written by the CLI itself — using it as an additional
+ * ground truth makes completion detection robust across those failure
+ * modes.
+ *
+ * ## Dedup contract with the hook path
+ *
+ * pty-service.handleHookEvent emits `task_complete` on the authoritative
+ * hook signal. This watcher emits a synthetic `task_complete` with an
+ * `internal: { source: "jsonl-watcher" }` marker. The orchestrator's
+ * downstream consumers (coordinator's handleTurnComplete, the eliza
+ * task-progress-streamer) already dedupe `task_complete` per session
+ * (`finalSent` in the streamer, `inFlightDecisions` in the coordinator).
+ * Whichever signal fires first wins; the second is a no-op.
+ *
+ * ## Polling vs fs.watch
+ *
+ * This uses polling (1s interval) rather than `fs.watch` because:
+ *   - jsonl files are append-only and small (~KB to MB)
+ *   - polling is portable across linux / macOS file systems
+ *   - fs.watch on linux has known gotchas with multiple writers and with
+ *     files created after the watcher is established
+ *   - the jsonl doesn't exist when the session spawns — we need retry
+ *     logic anyway, which fs.watch doesn't naturally provide
+ *
+ * @module orchestrator/claude-jsonl-completion-watcher
+ */
+import type { IAgentRuntime } from "@elizaos/core";
+/**
+ * Install the jsonl completion watcher on a runtime's PTY service.
+ * Idempotent — repeat calls on the same runtime are no-ops.
+ *
+ * The watcher subscribes to `onSessionEvent` to learn when sessions start
+ * (first event) and stop (`stopped` event), and runs one poller per live
+ * session. Pollers tear themselves down on `stopped` or after firing a
+ * completion event.
+ */
+export declare function installClaudeJsonlCompletionWatcher(runtime: IAgentRuntime, ptyService: unknown): void;
+/**
+ * Locate the newest `.jsonl` file under Claude Code's project directory
+ * for a given workdir. Returns null if the directory or any matching
+ * file does not yet exist (e.g., the session has not produced output).
+ *
+ * "Newest" means most recently modified. Claude Code names session files
+ * with UUIDs, which do NOT sort chronologically — a workspace that has
+ * had multiple sessions will have multiple jsonl files, and picking the
+ * lexicographically last name returns a stale file from an older session
+ * roughly at random. We stat each file and pick the one with the greatest
+ * mtime instead. Files that fail to stat (e.g., deleted between readdir
+ * and stat) are skipped.
+ *
+ * Exported for tests.
+ */
+export declare function findLatestJsonl(workdir: string): Promise<string | null>;
+/**
+ * Scan a claude code session jsonl string tail-first for the latest
+ * assistant message, returning its extracted text plus whether the turn
+ * has finished (`stop_reason === "end_turn"`).
+ *
+ * - Returns `null` if no assistant message exists at all.
+ * - Returns `{ text, isEndTurn: false }` when the latest assistant turn is
+ *   still in progress (`tool_use`, `max_tokens` mid-batch, etc.) — the
+ *   streamer uses this shape to post intermediate text without waiting.
+ * - Returns `{ text, isEndTurn: true }` when the latest assistant turn is
+ *   finished — the watcher uses this to fire a synthetic `task_complete`.
+ *
+ * Exported so both the completion watcher and task-progress-streamer can
+ * share one jsonl parser.
+ */
+export declare function readLatestAssistantEntry(content: string): {
+    text: string;
+    isEndTurn: boolean;
+} | null;
+/**
+ * Convenience wrapper: locate the latest session jsonl for `workdir` and
+ * return the extracted assistant entry, or `null` if no file or no
+ * assistant message exists yet.
+ *
+ * Used by the task-progress-streamer and the completion watcher so they
+ * share one implementation of "read the latest claude assistant turn".
+ */
+export declare function readLatestAssistantFromWorkdir(workdir: string): Promise<{
+    text: string;
+    isEndTurn: boolean;
+} | null>;
+//# sourceMappingURL=claude-jsonl-completion-watcher.d.ts.map

package/packages/typescript/src/features/orchestrator/claude-jsonl-completion-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-jsonl-completion-watcher.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/orchestrator/claude-jsonl-completion-watcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAoBnD;;;;;;;;GAQG;AACH,wBAAgB,mCAAmC,CAClD,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,OAAO,GACjB,IAAI,CA8DN;AA6ED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiC7E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACvC,OAAO,EAAE,MAAM,GACb;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA2B7C;AAED;;;;;;;GAOG;AACH,wBAAsB,8BAA8B,CACnD,OAAO,EAAE,MAAM,GACb,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAAC,CAUtD"}