chainlesschain 0.45.67 → 0.45.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.45.67",
+  "version": "0.45.70",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {

package/src/gateways/ws/message-dispatcher.js

@@ -66,6 +66,15 @@ export function createWsMessageDispatcher(server) {
         "patch-apply": () => server._handlePatchApply(id, ws, message),
         "patch-reject": () => server._handlePatchReject(id, ws, message),
         "patch-summary": () => server._handlePatchSummary(id, ws, message),
+        "task-graph-create": () =>
+          server._handleTaskGraphCreate(id, ws, message),
+        "task-graph-add-node": () =>
+          server._handleTaskGraphAddNode(id, ws, message),
+        "task-graph-update-node": () =>
+          server._handleTaskGraphUpdateNode(id, ws, message),
+        "task-graph-advance": () =>
+          server._handleTaskGraphAdvance(id, ws, message),
+        "task-graph-state": () => server._handleTaskGraphState(id, ws, message),
       };
 
       const handler = routes[type];

package/src/gateways/ws/session-protocol.js

@@ -1164,6 +1164,373 @@ export function handlePatchSummary(server, id, ws, message) {
   );
 }
 
+/**
+ * Helper: emit a task-graph.* envelope through the session's interaction
+ * adapter (same fan-out pattern as _emitPatchEvent).
+ */
+function _emitTaskGraphEvent(server, session, type, payload, ws) {
+  const envelope = createCodingAgentEvent(
+    type,
+    { ...(payload || {}), sessionId: session.id },
+    {
+      sessionId: session.id,
+      source: "cli-runtime",
+    },
+  );
+
+  const interaction = session && session.interaction;
+  if (interaction && typeof interaction.emit === "function") {
+    try {
+      interaction.emit(type, envelope.payload);
+      return;
+    } catch (_err) {
+      // Fall through to ws send below.
+    }
+  }
+
+  if (ws) {
+    server._send(ws, envelope);
+  }
+}
+
+/**
+ * Create a session-scoped task graph.
+ *
+ * Message shape:
+ *   { type: "task-graph-create", id, sessionId, title?, nodes: [...] }
+ */
+export function handleTaskGraphCreate(server, id, ws, message) {
+  const { sessionId } = message || {};
+
+  if (!server.sessionManager) {
+    server._send(
+      ws,
+      envelopeError(id, "NO_SESSION_SUPPORT", "Session support not configured"),
+    );
+    return;
+  }
+
+  const session = server.sessionManager.getSession(sessionId);
+  if (!session) {
+    server._send(
+      ws,
+      envelopeError(
+        id,
+        "SESSION_NOT_FOUND",
+        `Session not found: ${sessionId}`,
+        sessionId,
+      ),
+    );
+    return;
+  }
+
+  if (!Array.isArray(message.nodes)) {
+    server._send(
+      ws,
+      envelopeError(
+        id,
+        "INVALID_PAYLOAD",
+        "task-graph-create requires a nodes array",
+        sessionId,
+      ),
+    );
+    return;
+  }
+
+  const graph = server.sessionManager.createTaskGraph(sessionId, {
+    graphId: message.graphId,
+    title: message.title,
+    description: message.description,
+    nodes: message.nodes,
+  });
+
+  server._send(
+    ws,
+    envelopeResponse(
+      CODING_AGENT_EVENT_TYPES.TASK_GRAPH_CREATED,
+      id,
+      { sessionId, graph },
+      sessionId,
+    ),
+  );
+
+  _emitTaskGraphEvent(
+    server,
+    session,
+    CODING_AGENT_EVENT_TYPES.TASK_GRAPH_CREATED,
+    { graph },
+    ws,
+  );
+}
+
+/**
+ * Add a node to an existing task graph.
+ *
+ * Message shape:
+ *   { type: "task-graph-add-node", id, sessionId, node: { id, title, dependsOn? } }
+ */
+export function handleTaskGraphAddNode(server, id, ws, message) {
+  const { sessionId } = message || {};
+
+  if (!server.sessionManager) {
+    server._send(
+      ws,
+      envelopeError(id, "NO_SESSION_SUPPORT", "Session support not configured"),
+    );
+    return;
+  }
+
+  const session = server.sessionManager.getSession(sessionId);
+  if (!session) {
+    server._send(
+      ws,
+      envelopeError(
+        id,
+        "SESSION_NOT_FOUND",
+        `Session not found: ${sessionId}`,
+        sessionId,
+      ),
+    );
+    return;
+  }
+
+  const node = message.node || null;
+  if (!node || !node.id) {
+    server._send(
+      ws,
+      envelopeError(
+        id,
+        "INVALID_PAYLOAD",
+        "task-graph-add-node requires node.id",
+        sessionId,
+      ),
+    );
+    return;
+  }
+
+  const graph = server.sessionManager.addTaskNode(sessionId, node);
+  if (!graph) {
+    server._send(
+      ws,
+      envelopeError(
+        id,
+        "TASK_GRAPH_ADD_FAILED",
+        "Unable to add node (no graph, or duplicate id)",
+        sessionId,
+      ),
+    );
+    return;
+  }
+
+  server._send(
+    ws,
+    envelopeResponse(
+      CODING_AGENT_EVENT_TYPES.TASK_GRAPH_NODE_ADDED,
+      id,
+      { sessionId, graph, nodeId: node.id },
+      sessionId,
+    ),
+  );
+
+  _emitTaskGraphEvent(
+    server,
+    session,
+    CODING_AGENT_EVENT_TYPES.TASK_GRAPH_NODE_ADDED,
+    { graph, nodeId: node.id },
+    ws,
+  );
+}
+
+/**
+ * Update a task graph node (status, result, error, metadata).
+ *
+ * Message shape:
+ *   { type: "task-graph-update-node", id, sessionId, nodeId, updates: { status?, result?, error? } }
+ */
+export function handleTaskGraphUpdateNode(server, id, ws, message) {
+  const { sessionId, nodeId } = message || {};
+
+  if (!server.sessionManager) {
+    server._send(
+      ws,
+      envelopeError(id, "NO_SESSION_SUPPORT", "Session support not configured"),
+    );
+    return;
+  }
+
+  const session = server.sessionManager.getSession(sessionId);
+  if (!session) {
+    server._send(
+      ws,
+      envelopeError(
+        id,
+        "SESSION_NOT_FOUND",
+        `Session not found: ${sessionId}`,
+        sessionId,
+      ),
+    );
+    return;
+  }
+
+  if (!nodeId) {
+    server._send(
+      ws,
+      envelopeError(id, "INVALID_PAYLOAD", "nodeId is required", sessionId),
+    );
+    return;
+  }
+
+  const graph = server.sessionManager.updateTaskNode(
+    sessionId,
+    nodeId,
+    message.updates || {},
+  );
+
+  if (!graph) {
+    server._send(
+      ws,
+      envelopeError(
+        id,
+        "TASK_GRAPH_NODE_NOT_FOUND",
+        `Task node not found: ${nodeId}`,
+        sessionId,
+      ),
+    );
+    return;
+  }
+
+  const node = graph.nodes[nodeId];
+  let eventType = CODING_AGENT_EVENT_TYPES.TASK_GRAPH_NODE_UPDATED;
+  if (node && node.status === "completed") {
+    eventType = CODING_AGENT_EVENT_TYPES.TASK_GRAPH_NODE_COMPLETED;
+  } else if (node && node.status === "failed") {
+    eventType = CODING_AGENT_EVENT_TYPES.TASK_GRAPH_NODE_FAILED;
+  }
+
+  server._send(
+    ws,
+    envelopeResponse(eventType, id, { sessionId, graph, nodeId }, sessionId),
+  );
+
+  _emitTaskGraphEvent(server, session, eventType, { graph, nodeId }, ws);
+
+  if (graph.status === "completed" || graph.status === "failed") {
+    _emitTaskGraphEvent(
+      server,
+      session,
+      CODING_AGENT_EVENT_TYPES.TASK_GRAPH_COMPLETED,
+      { graph },
+      ws,
+    );
+  }
+}
+
+/**
+ * Advance the task graph: promote any pending node whose deps are satisfied.
+ *
+ * Message shape: { type: "task-graph-advance", id, sessionId }
+ */
+export function handleTaskGraphAdvance(server, id, ws, message) {
+  const { sessionId } = message || {};
+
+  if (!server.sessionManager) {
+    server._send(
+      ws,
+      envelopeError(id, "NO_SESSION_SUPPORT", "Session support not configured"),
+    );
+    return;
+  }
+
+  const session = server.sessionManager.getSession(sessionId);
+  if (!session) {
+    server._send(
+      ws,
+      envelopeError(
+        id,
+        "SESSION_NOT_FOUND",
+        `Session not found: ${sessionId}`,
+        sessionId,
+      ),
+    );
+    return;
+  }
+
+  const result = server.sessionManager.advanceTaskGraph(sessionId);
+  if (!result) {
+    server._send(
+      ws,
+      envelopeError(
+        id,
+        "TASK_GRAPH_NOT_FOUND",
+        "No task graph on session",
+        sessionId,
+      ),
+    );
+    return;
+  }
+
+  server._send(
+    ws,
+    envelopeResponse(
+      CODING_AGENT_EVENT_TYPES.TASK_GRAPH_ADVANCED,
+      id,
+      { sessionId, graph: result.graph, becameReady: result.becameReady },
+      sessionId,
+    ),
+  );
+
+  _emitTaskGraphEvent(
+    server,
+    session,
+    CODING_AGENT_EVENT_TYPES.TASK_GRAPH_ADVANCED,
+    { graph: result.graph, becameReady: result.becameReady },
+    ws,
+  );
+}
+
+/**
+ * Fetch the current task graph state.
+ *
+ * Message shape: { type: "task-graph-state", id, sessionId }
+ */
+export function handleTaskGraphState(server, id, ws, message) {
+  const { sessionId } = message || {};
+
+  if (!server.sessionManager) {
+    server._send(
+      ws,
+      envelopeError(id, "NO_SESSION_SUPPORT", "Session support not configured"),
+    );
+    return;
+  }
+
+  const session = server.sessionManager.getSession(sessionId);
+  if (!session) {
+    server._send(
+      ws,
+      envelopeError(
+        id,
+        "SESSION_NOT_FOUND",
+        `Session not found: ${sessionId}`,
+        sessionId,
+      ),
+    );
+    return;
+  }
+
+  const graph = server.sessionManager.getTaskGraph(sessionId);
+
+  server._send(
+    ws,
+    envelopeResponse(
+      CODING_AGENT_EVENT_TYPES.TASK_GRAPH_STATE,
+      id,
+      { sessionId, graph },
+      sessionId,
+    ),
+  );
+}
+
 export function handleHostToolResult(server, id, ws, message) {
   const { sessionId, requestId, success, result, error, toolName } = message;
 

package/src/lib/ws-server.js

@@ -41,6 +41,11 @@ import {
   handlePatchApply,
   handlePatchReject,
   handlePatchSummary,
+  handleTaskGraphCreate,
+  handleTaskGraphAddNode,
+  handleTaskGraphUpdateNode,
+  handleTaskGraphAdvance,
+  handleTaskGraphState,
 } from "../gateways/ws/session-protocol.js";
 import {
   handleSlashCommand,
@@ -679,6 +684,31 @@ export class ChainlessChainWSServer extends EventEmitter {
     return handlePatchSummary(this, id, ws, message);
   }
 
+  /** @private */
+  _handleTaskGraphCreate(id, ws, message) {
+    return handleTaskGraphCreate(this, id, ws, message);
+  }
+
+  /** @private */
+  _handleTaskGraphAddNode(id, ws, message) {
+    return handleTaskGraphAddNode(this, id, ws, message);
+  }
+
+  /** @private */
+  _handleTaskGraphUpdateNode(id, ws, message) {
+    return handleTaskGraphUpdateNode(this, id, ws, message);
+  }
+
+  /** @private */
+  _handleTaskGraphAdvance(id, ws, message) {
+    return handleTaskGraphAdvance(this, id, ws, message);
+  }
+
+  /** @private */
+  _handleTaskGraphState(id, ws, message) {
+    return handleTaskGraphState(this, id, ws, message);
+  }
+
   /** @private — ping/pong heartbeat to detect dead connections */
   async _ensureTaskManager() {
     if (this._taskManager) return this._taskManager;

package/src/lib/ws-session-manager.js

@@ -352,6 +352,7 @@ export class WSSessionManager {
       reviewState: null,
       pendingPatches: new Map(),
       patchHistory: [],
+      taskGraph: null,
       interaction: null, // Set by ws-server after creation
       createdAt: new Date().toISOString(),
       lastActivity: new Date().toISOString(),
@@ -464,6 +465,7 @@ export class WSSessionManager {
         patchHistory: Array.isArray(metadata.patchHistory)
           ? metadata.patchHistory
           : [],
+        taskGraph: this._hydrateTaskGraph(metadata.taskGraph),
         interaction: null,
         createdAt: dbSession.created_at,
         lastActivity: new Date().toISOString(),
@@ -960,6 +962,242 @@ export class WSSessionManager {
     };
   }
 
+  /**
+   * Create or replace the task graph for a session. A graph is a DAG of
+   * `nodes` keyed by id; each node has `{ id, title, status, dependsOn[],
+   * metadata }`. Returns the serialized graph.
+   */
+  createTaskGraph(sessionId, payload = {}) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+
+    const graphId = payload.graphId || `graph-${this._generateId()}`;
+    const now = new Date().toISOString();
+    const nodes = {};
+    const incomingNodes = Array.isArray(payload.nodes) ? payload.nodes : [];
+    for (const raw of incomingNodes) {
+      if (!raw || !raw.id) continue;
+      nodes[raw.id] = this._normalizeTaskNode(raw, now);
+    }
+
+    const graph = {
+      graphId,
+      title: payload.title || null,
+      description: payload.description || null,
+      status: "active",
+      createdAt: now,
+      updatedAt: now,
+      completedAt: null,
+      nodes,
+      order: Object.keys(nodes),
+    };
+
+    session.taskGraph = graph;
+    session.lastActivity = now;
+    this._persistSessionState(sessionId);
+    return this._cloneTaskGraph(graph);
+  }
+
+  /**
+   * Add a node to the existing task graph. Fails if no graph exists or if
+   * the node id already exists.
+   */
+  addTaskNode(sessionId, payload = {}) {
+    const session = this.sessions.get(sessionId);
+    if (!session || !session.taskGraph) return null;
+    if (!payload || !payload.id) return null;
+    const graph = session.taskGraph;
+    if (graph.nodes[payload.id]) return null;
+
+    const now = new Date().toISOString();
+    graph.nodes[payload.id] = this._normalizeTaskNode(payload, now);
+    graph.order = [...(graph.order || []), payload.id];
+    graph.updatedAt = now;
+    session.lastActivity = now;
+    this._persistSessionState(sessionId);
+    return this._cloneTaskGraph(graph);
+  }
+
+  /**
+   * Update a node's status / metadata. Valid statuses: pending, ready,
+   * running, completed, failed, skipped.
+   */
+  updateTaskNode(sessionId, nodeId, updates = {}) {
+    const session = this.sessions.get(sessionId);
+    if (!session || !session.taskGraph) return null;
+    const graph = session.taskGraph;
+    const node = graph.nodes[nodeId];
+    if (!node) return null;
+
+    const now = new Date().toISOString();
+    if (updates.status) {
+      node.status = String(updates.status);
+      if (node.status === "running" && !node.startedAt) {
+        node.startedAt = now;
+      }
+      if (
+        node.status === "completed" ||
+        node.status === "failed" ||
+        node.status === "skipped"
+      ) {
+        node.completedAt = now;
+      }
+    }
+    if (updates.title !== undefined) node.title = updates.title;
+    if (updates.result !== undefined) node.result = updates.result;
+    if (updates.error !== undefined) node.error = updates.error;
+    if (updates.metadata !== undefined) {
+      node.metadata = { ...(node.metadata || {}), ...(updates.metadata || {}) };
+    }
+    node.updatedAt = now;
+    graph.updatedAt = now;
+
+    // Check graph completion
+    const allDone = Object.values(graph.nodes).every((n) =>
+      ["completed", "failed", "skipped"].includes(n.status),
+    );
+    if (allDone) {
+      graph.status = Object.values(graph.nodes).some(
+        (n) => n.status === "failed",
+      )
+        ? "failed"
+        : "completed";
+      graph.completedAt = now;
+    }
+
+    session.lastActivity = now;
+    this._persistSessionState(sessionId);
+    return this._cloneTaskGraph(graph);
+  }
+
+  /**
+   * Advance the task graph: mark any `pending` node whose dependencies are
+   * all `completed` (or `skipped`) as `ready`. Returns the list of node ids
+   * that became ready and the updated graph snapshot.
+   */
+  advanceTaskGraph(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session || !session.taskGraph) return null;
+    const graph = session.taskGraph;
+
+    const becameReady = [];
+    for (const node of Object.values(graph.nodes)) {
+      if (node.status !== "pending") continue;
+      const deps = Array.isArray(node.dependsOn) ? node.dependsOn : [];
+      const blocked = deps.some((depId) => {
+        const dep = graph.nodes[depId];
+        if (!dep) return true;
+        return dep.status !== "completed" && dep.status !== "skipped";
+      });
+      if (!blocked) {
+        node.status = "ready";
+        node.updatedAt = new Date().toISOString();
+        becameReady.push(node.id);
+      }
+    }
+
+    if (becameReady.length > 0) {
+      graph.updatedAt = new Date().toISOString();
+      session.lastActivity = graph.updatedAt;
+      this._persistSessionState(sessionId);
+    }
+
+    return {
+      graph: this._cloneTaskGraph(graph),
+      becameReady,
+    };
+  }
+
+  getTaskGraph(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session || !session.taskGraph) return null;
+    return this._cloneTaskGraph(session.taskGraph);
+  }
+
+  clearTaskGraph(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    session.taskGraph = null;
+    session.lastActivity = new Date().toISOString();
+    this._persistSessionState(sessionId);
+    return true;
+  }
+
+  _normalizeTaskNode(raw, now) {
+    const status = raw.status || "pending";
+    return {
+      id: raw.id,
+      title: raw.title || raw.id,
+      description: raw.description || null,
+      status,
+      dependsOn: Array.isArray(raw.dependsOn)
+        ? raw.dependsOn.filter((x) => typeof x === "string")
+        : [],
+      metadata:
+        raw.metadata && typeof raw.metadata === "object" ? raw.metadata : {},
+      createdAt: raw.createdAt || now,
+      updatedAt: raw.updatedAt || now,
+      startedAt: raw.startedAt || null,
+      completedAt: raw.completedAt || null,
+      result: raw.result || null,
+      error: raw.error || null,
+    };
+  }
+
+  _cloneTaskGraph(graph) {
+    if (!graph) return null;
+    return {
+      graphId: graph.graphId,
+      title: graph.title,
+      description: graph.description,
+      status: graph.status,
+      createdAt: graph.createdAt,
+      updatedAt: graph.updatedAt,
+      completedAt: graph.completedAt,
+      order: Array.isArray(graph.order)
+        ? [...graph.order]
+        : Object.keys(graph.nodes || {}),
+      nodes: Object.fromEntries(
+        Object.entries(graph.nodes || {}).map(([id, node]) => [
+          id,
+          {
+            ...node,
+            dependsOn: [...(node.dependsOn || [])],
+            metadata: { ...(node.metadata || {}) },
+          },
+        ]),
+      ),
+    };
+  }
+
+  _hydrateTaskGraph(data) {
+    if (!data || typeof data !== "object") return null;
+    if (!data.graphId || !data.nodes) return null;
+    const nodes = {};
+    for (const [id, node] of Object.entries(data.nodes)) {
+      nodes[id] = this._normalizeTaskNode(
+        { ...node, id },
+        node.createdAt || new Date().toISOString(),
+      );
+    }
+    return {
+      graphId: data.graphId,
+      title: data.title || null,
+      description: data.description || null,
+      status: data.status || "active",
+      createdAt: data.createdAt || new Date().toISOString(),
+      updatedAt: data.updatedAt || new Date().toISOString(),
+      completedAt: data.completedAt || null,
+      order: Array.isArray(data.order) ? data.order : Object.keys(nodes),
+      nodes,
+    };
+  }
+
+  _serializeTaskGraph(graph) {
+    if (!graph) return null;
+    return this._cloneTaskGraph(graph);
+  }
+
   /**
    * Persist current messages for a session.
    */
@@ -1046,6 +1284,7 @@ export class WSSessionManager {
       patchHistory: Array.isArray(session.patchHistory)
         ? session.patchHistory
         : [],
+      taskGraph: this._serializeTaskGraph(session.taskGraph),
     };
   }
 

package/src/runtime/coding-agent-events.cjs

@@ -108,6 +108,20 @@ const CODING_AGENT_EVENT_TYPES = Object.freeze({
   PATCH_APPLIED: "patch.applied",
   PATCH_REJECTED: "patch.rejected",
   PATCH_SUMMARY: "patch.summary",
+
+  // Persistent task graph + orchestrator — a session-scoped DAG of tasks
+  // with dependencies. The runtime serializes the graph to session metadata
+  // so it survives CLI restarts; the orchestrator advances the graph by
+  // marking ready nodes as `running` when their dependencies complete.
+  TASK_GRAPH_CREATED: "task-graph.created",
+  TASK_GRAPH_UPDATED: "task-graph.updated",
+  TASK_GRAPH_NODE_ADDED: "task-graph.node.added",
+  TASK_GRAPH_NODE_UPDATED: "task-graph.node.updated",
+  TASK_GRAPH_NODE_COMPLETED: "task-graph.node.completed",
+  TASK_GRAPH_NODE_FAILED: "task-graph.node.failed",
+  TASK_GRAPH_ADVANCED: "task-graph.advanced",
+  TASK_GRAPH_COMPLETED: "task-graph.completed",
+  TASK_GRAPH_STATE: "task-graph.state",
 });
 
 const VALID_TYPE_SET = new Set(Object.values(CODING_AGENT_EVENT_TYPES));