pi-rlm 0.1.0 → 0.1.3

package/src/engine.ts

@@ -47,7 +47,7 @@ export async function runRlmEngine(
   });
 
   try {
-    const root = await runNode({ task: input.task, depth: 0, lineage: [] });
+    const root = await runNode({ task: input.task, depth: 0, lineage: [], parentId: undefined });
 
     const finalOutput = root.result ?? "(no final output)";
 
@@ -90,7 +90,36 @@ export async function runRlmEngine(
     task: string;
     depth: number;
     lineage: string[];
+    parentId: string | undefined;
   }): Promise<RlmNode> {
+    if (state.nodesVisited >= input.maxNodes) {
+      const startedAt = Date.now();
+      const skippedNode: RlmNode = {
+        id: `n${++state.nodeCounter}`,
+        depth: params.depth,
+        task: params.task,
+        status: "cancelled",
+        startedAt,
+        finishedAt: startedAt,
+        error: "maxNodes reached",
+        result: "Node skipped: maxNodes reached",
+        children: []
+      };
+
+      progress?.(
+        `[${skippedNode.id}] skipped (maxNodes reached) ${shortTask(params.task, 72)}`
+      );
+      log("node_skipped", {
+        nodeId: skippedNode.id,
+        parentId: params.parentId ?? null,
+        depth: skippedNode.depth,
+        task: skippedNode.task,
+        reason: "maxNodes reached",
+        nodesVisited: state.nodesVisited
+      });
+      return skippedNode;
+    }
+
     const nodeId = `n${++state.nodeCounter}`;
     state.nodesVisited += 1;
     state.maxDepthSeen = Math.max(state.maxDepthSeen, params.depth);
@@ -107,6 +136,7 @@ export async function runRlmEngine(
     progress?.(`[${node.id}] depth=${params.depth} ${shortTask(params.task, 72)}`);
     log("node_start", {
       nodeId: node.id,
+      parentId: params.parentId ?? null,
       depth: params.depth,
       task: params.task,
       nodesVisited: state.nodesVisited
@@ -116,7 +146,11 @@ export async function runRlmEngine(
       node.status = "cancelled";
       node.error = "Run cancelled";
       node.finishedAt = Date.now();
-      log("node_cancelled", { nodeId: node.id, depth: node.depth });
+      log("node_cancelled", {
+        nodeId: node.id,
+        parentId: params.parentId ?? null,
+        depth: node.depth
+      });
       throw new Error("RLM run cancelled");
     }
 
@@ -127,7 +161,8 @@ export async function runRlmEngine(
       const forcedReason = getForcedSolveReason({
         depth: params.depth,
         normalizedTask: normalized,
-        lineage: params.lineage
+        lineage: params.lineage,
+        remainingNodeBudget
       });
 
       if (forcedReason || input.mode === "solve") {
@@ -138,6 +173,7 @@ export async function runRlmEngine(
         node.finishedAt = Date.now();
         log("node_end", {
           nodeId: node.id,
+          parentId: params.parentId ?? null,
           action: "solve",
           reason,
           chars: node.result.length,
@@ -148,6 +184,7 @@ export async function runRlmEngine(
 
       const decision = await planNode({
         task: params.task,
+        nodeId: node.id,
         depth: params.depth,
         maxDepth: input.maxDepth,
         maxBranching: input.maxBranching,
@@ -165,6 +202,7 @@ export async function runRlmEngine(
         node.finishedAt = Date.now();
         log("node_end", {
           nodeId: node.id,
+          parentId: params.parentId ?? null,
           action: "solve",
           reason: decision.reason,
           chars: node.result.length,
@@ -173,21 +211,33 @@ export async function runRlmEngine(
         return node;
       }
 
-      const subtasks = sanitizeSubtasks(decision.subtasks ?? [], params.task).slice(
+      const requestedSubtasks = sanitizeSubtasks(decision.subtasks ?? [], params.task).slice(
         0,
         input.maxBranching
       );
+      const remainingChildBudget = Math.max(0, input.maxNodes - state.nodesVisited);
+      const subtasks = requestedSubtasks.slice(0, remainingChildBudget);
 
       if (subtasks.length < 2) {
+        const fallbackReason =
+          requestedSubtasks.length < 2
+            ? "planner returned insufficient valid subtasks"
+            : "insufficient remaining node budget for decomposition";
+
+        if (input.mode === "decompose") {
+          throw new Error(`mode=decompose requires valid decomposition: ${fallbackReason}`);
+        }
+
         node.decision = {
           action: "solve",
-          reason: "planner returned insufficient valid subtasks"
+          reason: fallbackReason
         };
         node.result = await solveNode(node, node.decision.reason);
         node.status = "completed";
         node.finishedAt = Date.now();
         log("node_end", {
           nodeId: node.id,
+          parentId: params.parentId ?? null,
           action: "solve",
           reason: node.decision.reason,
           chars: node.result.length,
@@ -199,6 +249,7 @@ export async function runRlmEngine(
       progress?.(`[${node.id}] decomposing into ${subtasks.length} subtasks`);
       log("node_decompose", {
         nodeId: node.id,
+        parentId: params.parentId ?? null,
         subtasks,
         reason: decision.reason
       });
@@ -207,7 +258,8 @@ export async function runRlmEngine(
         return runNode({
           task: subtask,
           depth: params.depth + 1,
-          lineage: [...params.lineage, normalized]
+          lineage: [...params.lineage, normalized],
+          parentId: node.id
         });
       });
 
@@ -216,6 +268,7 @@ export async function runRlmEngine(
       node.finishedAt = Date.now();
       log("node_end", {
         nodeId: node.id,
+        parentId: params.parentId ?? null,
         action: "decompose",
         chars: node.result.length,
         children: node.children.length,
@@ -230,6 +283,7 @@ export async function runRlmEngine(
         node.finishedAt = Date.now();
         log("node_cancelled", {
           nodeId: node.id,
+          parentId: params.parentId ?? null,
           error: message,
           durationMs: node.finishedAt - node.startedAt
         });
@@ -241,6 +295,7 @@ export async function runRlmEngine(
       node.finishedAt = Date.now();
       log("node_error", {
         nodeId: node.id,
+        parentId: params.parentId ?? null,
         error: message,
         durationMs: node.finishedAt - node.startedAt
       });
@@ -252,25 +307,25 @@ export async function runRlmEngine(
 
   async function planNode(args: {
     task: string;
+    nodeId: string;
     depth: number;
     maxDepth: number;
     maxBranching: number;
     remainingNodeBudget: number;
   }): Promise<PlannerDecision> {
     if (input.mode === "decompose") {
-      const forced = await callModel("planner", plannerPrompt(args));
+      const forced = await callModel("planner", plannerPrompt(args), args.nodeId, args.depth);
       const parsedForced = parsePlannerDecision(forced);
       if (parsedForced.action === "decompose") {
         return parsedForced;
       }
-      return {
-        action: "decompose",
-        reason: "mode=decompose requested, but planner output was invalid",
-        subtasks: []
-      };
+
+      throw new Error(
+        `mode=decompose requires planner action=decompose; got ${parsedForced.action} (${parsedForced.reason})`
+      );
     }
 
-    const raw = await callModel("planner", plannerPrompt(args));
+    const raw = await callModel("planner", plannerPrompt(args), args.nodeId, args.depth);
     return parsePlannerDecision(raw);
   }
 
@@ -281,7 +336,7 @@ export async function runRlmEngine(
       maxDepth: input.maxDepth,
       forceReason
     });
-    return callModel("solver", prompt, node.id);
+    return callModel("solver", prompt, node.id, node.depth);
   }
 
   async function synthesizeNode(node: RlmNode): Promise<string> {
@@ -290,10 +345,15 @@ export async function runRlmEngine(
       depth: node.depth,
       children: node.children
     });
-    return callModel("synthesizer", prompt, node.id);
+    return callModel("synthesizer", prompt, node.id, node.depth);
   }
 
-  async function callModel(stage: string, promptText: string, nodeId?: string): Promise<string> {
+  async function callModel(
+    stage: string,
+    promptText: string,
+    nodeId?: string,
+    depth?: number
+  ): Promise<string> {
     if (activeSignal.aborted) {
       throw new Error("RLM run cancelled");
     }
@@ -314,7 +374,12 @@ export async function runRlmEngine(
         model: input.model,
         toolsProfile: input.toolsProfile,
         timeoutMs: input.timeoutMs,
-        signal: activeSignal
+        signal: activeSignal,
+        runId: input.runId,
+        nodeId,
+        depth,
+        stage,
+        tmuxUseCurrentSession: input.tmuxUseCurrentSession
       },
       ctx
     );
@@ -332,6 +397,7 @@ export async function runRlmEngine(
     depth: number;
     normalizedTask: string;
     lineage: string[];
+    remainingNodeBudget: number;
   }): string | undefined {
     if (args.depth >= input.maxDepth) {
       return "maxDepth reached";
@@ -341,6 +407,10 @@ export async function runRlmEngine(
       return "maxNodes reached";
     }
 
+    if (args.remainingNodeBudget < 2) {
+      return "insufficient node budget for decomposition";
+    }
+
     if (args.lineage.includes(args.normalizedTask)) {
       return "cycle detected in task lineage";
     }

package/src/runs.ts

@@ -38,7 +38,7 @@ export class RunStore {
       promise: Promise.resolve(null as unknown as RlmRunResult)
     };
 
-    record.promise = (async () => {
+    const runPromise = (async () => {
       try {
         const result = await executor(id, controller.signal);
         record.status = "completed";
@@ -60,6 +60,10 @@ export class RunStore {
       }
     })();
 
+    // Prevent unhandled-rejection crashes when async callers start a run and don't await it.
+    void runPromise.catch(() => undefined);
+    record.promise = runPromise;
+
     this.records.set(id, record);
     this.prune();
     return record;

package/src/schema.ts

@@ -23,7 +23,12 @@ export const rlmToolParamsSchema = Type.Object({
   maxBranching: Type.Optional(Type.Integer({ minimum: 1, maximum: 8 })),
   concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 8 })),
   timeoutMs: Type.Optional(Type.Integer({ minimum: 1000, maximum: 3600000 })),
-  waitTimeoutMs: Type.Optional(Type.Integer({ minimum: 100, maximum: 3600000 }))
+  waitTimeoutMs: Type.Optional(Type.Integer({ minimum: 100, maximum: 3600000 })),
+  tmuxUseCurrentSession: Type.Optional(
+    Type.Boolean({
+      description: "For backend=tmux, place depth windows/panes in the current tmux session"
+    })
+  )
 });
 
 export type RlmToolParams = Static<typeof rlmToolParamsSchema>;

package/src/types.ts

@@ -19,6 +19,7 @@ export interface StartRunInput {
   maxBranching: number;
   concurrency: number;
   timeoutMs: number;
+  tmuxUseCurrentSession: boolean;
 }
 
 export interface RlmNode {