u-foo 2.5.15 → 3.0.1

package/src/code/commands.js

@@ -8,6 +8,7 @@ const UCODE_COMMAND_REGISTRY = [
   { cmd: "/help", desc: "Show available commands", order: 10 },
   { cmd: "/status", desc: "Show session / usage status", order: 20 },
   { cmd: "/model", desc: "Show or switch the active model", order: 25 },
+  { cmd: "/plan", desc: "Show plan progress or set plan mode", order: 27 },
   { cmd: "/ubus", desc: "Check pending bus messages", order: 30 },
   { cmd: "/resume", desc: "Resume a saved session", order: 40 },
   { cmd: "/skills", desc: "List or show skills", order: 50 },
@@ -23,6 +24,20 @@ const UCODE_COMMAND_TREE = {
     hasArguments: true,
     optionalArguments: true,
   },
+  "/plan": {
+    desc: "Show plan progress or set plan mode",
+    hasArguments: true,
+    optionalArguments: true,
+    children: {
+      on: { desc: "Enable plan mode", order: 1 },
+      off: { desc: "Disable plan mode", order: 2 },
+      show: { desc: "Show plan band and status", order: 3 },
+      hide: { desc: "Hide plan band", order: 4 },
+      focus: { desc: "Expand plan band with task detail", order: 5 },
+      debug: { desc: "Show raw graph debug band", order: 6 },
+      clear: { desc: "Clear plan graph (stay in mode)", order: 7 },
+    },
+  },
   "/ubus": { desc: "Check pending bus messages" },
   "/resume": { desc: "Resume a saved session", hasArguments: true },
   "/skills": {
@@ -45,6 +60,7 @@ function listUcodeCommandsForHelp() {
     "  /ubus",
     "  /status",
     "  /model [model-id]",
+    "  /plan [on|off|show|hide|focus|debug|clear]",
     "  /skills [list]",
     "  /skills show <name>",
     "  /bg <task>",

package/src/code/context/assembler.js

@@ -1,6 +1,5 @@
 "use strict";
 
-const { isContextV2Enabled } = require("./featureFlag");
 const {
   loadTranscript,
   transcriptEventsToMessages,
@@ -33,6 +32,8 @@ const {
   pruneWorkingSetByRetention,
 } = require("./workingSet");
 const { renderExecutionSegmentContext } = require("./executionSegment");
+const { renderPlanModeContext } = require("./planMode");
+const { drainAgentMailboxForTurn } = require("../runtime/agentWakeup");
 
 const DEFAULT_TRANSCRIPT_WINDOW = 12;
 const DEFAULT_RECENT_TOOL_EVENTS = 4;
@@ -47,7 +48,6 @@ function defaultContextPolicy(env = process.env) {
   return {
     transcriptWindow: resolveTranscriptWindow(env),
     commitInterval: resolveCommitInterval(env),
-    v2: isContextV2Enabled(env),
   };
 }
 
@@ -342,11 +342,11 @@ function buildModelMessagesFromTranscript(transcriptEvents = [], session = {}, w
 }
 
 function buildRecentMessages(transcriptEvents = [], windowSize = DEFAULT_TRANSCRIPT_WINDOW, session = null) {
-  if (session && isContextV2Enabled()) {
+  if (session) {
     return buildModelMessagesFromTranscript(transcriptEvents, session, windowSize);
   }
   const recent = eventsSliceWindow(transcriptEvents, windowSize);
-  return recent.map((event) => eventToModelMessage(event, { preferArtifact: isContextV2Enabled() })).filter(Boolean);
+  return recent.map((event) => eventToModelMessage(event, { preferArtifact: true })).filter(Boolean);
 }
 
 function eventsSliceWindow(events = [], windowSize = DEFAULT_TRANSCRIPT_WINDOW) {
@@ -397,6 +397,16 @@ function assembleModelContext(session = {}, request = {}, env = process.env) {
     ].filter(Boolean).join("\n\n"),
     turnDynamic: [
       request.turnDynamic || "",
+      (() => {
+        try {
+          const { MAX_CONCURRENT_WRITE_LEASES } = require("../runtime/workspaceLease");
+          return `Current max concurrent writing TaskRuns: ${MAX_CONCURRENT_WRITE_LEASES}`;
+        } catch {
+          return "";
+        }
+      })(),
+      renderPlanModeContext(session.executionState),
+      drainAgentMailboxForTurn(session.executionState).text,
       renderProjectSnapshotContext(session.projectSnapshot),
       renderWorkingSetContext(session.workingSet, session),
       renderExecutionSegmentContext(session.executionState),
@@ -541,7 +551,7 @@ function syncMessagesToTranscript(session = {}, messages = [], workspaceRoot = p
     : null;
   if (baseline == null) {
     const existingMessages = transcriptEventsToMessages(prior, {
-      preferArtifact: isContextV2Enabled(),
+      preferArtifact: true,
     });
     baseline = matchTranscriptBaseline(existingMessages, full);
   }
@@ -549,7 +559,7 @@ function syncMessagesToTranscript(session = {}, messages = [], workspaceRoot = p
 
   if (full.length <= baseline) {
     session.nlMessages = transcriptEventsToMessages(session.transcriptEvents, {
-      preferArtifact: isContextV2Enabled(),
+      preferArtifact: true,
     });
     return session.transcriptEvents || prior;
   }
@@ -560,15 +570,10 @@ function syncMessagesToTranscript(session = {}, messages = [], workspaceRoot = p
       ? session.executionState.currentSegmentId
       : "",
   };
-  if (isContextV2Enabled()) {
-    appendTranscriptMessagesForStorage(workspaceRoot, sessionId, delta, extra);
-  } else {
-    const { appendTranscriptMessages } = require("./transcript");
-    appendTranscriptMessages(workspaceRoot, sessionId, delta, extra);
-  }
+  appendTranscriptMessagesForStorage(workspaceRoot, sessionId, delta, extra);
   session.transcriptEvents = loadTranscript(workspaceRoot, sessionId).events;
   session.nlMessages = transcriptEventsToMessages(session.transcriptEvents, {
-    preferArtifact: isContextV2Enabled(),
+    preferArtifact: true,
   });
   session.summary = buildRollingSummary(session.transcriptEvents, session.summary, session);
   return session.transcriptEvents;

package/src/code/context/executionSegment.js

@@ -1,17 +1,38 @@
 "use strict";
 
 const { randomUUID } = require("crypto");
+const {
+  executePlanGraph,
+  planGraphFromExecutionSegment,
+  compilePlanGraph,
+} = require("./planGraph");
 
 function emptyExecutionState() {
+  // Durable execution control plane. Field ownership: see
+  // src/code/protocol/ownership.js (STATE_OWNERSHIP / DURABLE_FIELDS).
   return {
     currentSegmentId: "",
     mode: "single_action",
+    planMode: false,
+    planModeSource: "",
+    // R5 orthognal fields (dual-written with planMode during migration)
+    planningPolicy: "direct_allowed",
+    executionOwner: { kind: "none", id: "" },
     steps: {},
     modifiedFiles: [],
     lastExitCodes: [],
     approvals: [],
     retries: {},
     segments: [],
+    pendingUserPrompts: [],
+    planGraph: require("./planGraphService").emptyPlanGraphState(),
+    graphs: {},
+    taskRuns: require("../runtime/taskRun").emptyTaskRunStore(),
+    agentMailbox: require("../runtime/loopMailbox").emptyMailbox(),
+    taskMailboxes: {},
+    workspaceLease: require("../runtime/workspaceLease").emptyWorkspaceLease(),
+    planUi: { bandMode: "auto" },
+    pendingUserInteraction: null,
   };
 }
 
@@ -93,19 +114,29 @@ function shouldStopSegment(executionState = null, {
 }
 
 function renderExecutionSegmentContext(executionState = null) {
-  if (!executionState || !executionState.currentSegmentId) return "";
-  const lines = [
-    "Current Execution Segment:",
-    `- Segment: ${executionState.currentSegmentId}`,
-    `- Mode: ${executionState.mode || "single_action"}`,
-  ];
-  const steps = executionState.steps && typeof executionState.steps === "object"
-    ? Object.entries(executionState.steps)
-    : [];
-  if (steps.length > 0) {
-    lines.push("Step status:");
-    for (const [id, info] of steps) {
-      lines.push(`- ${id}: ${info.status}${info.error ? ` (${info.error})` : ""}`);
+  if (!executionState || typeof executionState !== "object") return "";
+  const lines = [];
+  if (executionState.planMode) {
+    // Detailed plan-mode instructions come from renderPlanModeContext.
+    lines.push("Execution mode: plan_mode");
+  }
+  if (!executionState.currentSegmentId && !(executionState.planGraph && executionState.planGraph.graphId)) {
+    return lines.join("\n");
+  }
+  if (executionState.currentSegmentId) {
+    lines.push(
+      "Current Execution Segment:",
+      `- Segment: ${executionState.currentSegmentId}`,
+      `- Mode: ${executionState.mode || "single_action"}`,
+    );
+    const steps = executionState.steps && typeof executionState.steps === "object"
+      ? Object.entries(executionState.steps)
+      : [];
+    if (steps.length > 0) {
+      lines.push("Step status:");
+      for (const [id, info] of steps) {
+        lines.push(`- ${id}: ${info.status}${info.error ? ` (${info.error})` : ""}`);
+      }
     }
   }
   return lines.join("\n");
@@ -118,21 +149,9 @@ function parseExecutionSegment(sideEffects = null) {
   return null;
 }
 
-const DEFAULT_MAX_SEGMENT_STEPS = 4;
+const DEFAULT_MAX_SEGMENT_STEPS = 16;
 const SIDE_EFFECT_TOOLS = new Set(["write", "edit"]);
 
-function resolveStepArgs(args = {}, stepOutputs = new Map()) {
-  const next = args && typeof args === "object" ? { ...args } : {};
-  const argsJson = JSON.stringify(next);
-  for (const [depId, depValue] of stepOutputs.entries()) {
-    const token = `\${${depId}.matches}`;
-    if (argsJson.includes(token) && depValue && depValue.matches) {
-      next.matches = depValue.matches;
-    }
-  }
-  return next;
-}
-
 function isSideEffectTool(tool = "") {
   return SIDE_EFFECT_TOOLS.has(String(tool || "").trim().toLowerCase());
 }
@@ -146,9 +165,14 @@ function formatSegmentResultMessage(result = {}) {
     stoppedAt: result.stoppedAt || "",
     steps: Array.isArray(result.results) ? result.results : [],
     error: result.error || "",
+    plan: result.summary || null,
   });
 }
 
+/**
+ * Execute a legacy execution_segment via the unified plan graph engine.
+ * Preserves the previous return shape used by agent/nativeRunner.
+ */
 function executeExecutionSegment({
   segment = {},
   executionState = null,
@@ -162,113 +186,69 @@ function executeExecutionSegment({
   const cappedSegment = { ...normalized, steps: cappedSteps };
   const { state: startedState, segmentId } = startExecutionSegment(executionState, cappedSegment);
   let state = startedState;
-  const stepOutputs = new Map();
-  const results = [];
-  const checkpointAfter = new Set(
-    Array.isArray(cappedSegment.checkpoint && cappedSegment.checkpoint.after)
-      ? cappedSegment.checkpoint.after.map(String)
-      : [],
-  );
-  let stoppedAt = "";
-  let fatalError = "";
 
-  for (const step of cappedSteps) {
-    const deps = Array.isArray(step.dependsOn) ? step.dependsOn : [];
-    for (const dep of deps) {
-      if (!stepOutputs.has(dep)) {
+  const plan = planGraphFromExecutionSegment(cappedSegment);
+  plan.id = segmentId;
+
+  const graphResult = executePlanGraph(plan, {
+    maxNodeRuns: Math.max(1, Math.floor(maxSteps)) * 2,
+    runStep: ({ stepId, tool, args }) => {
+      if (typeof onStepStart === "function") {
+        try {
+          onStepStart({ stepId, tool, args });
+        } catch {
+          // ignore
+        }
+      }
+      const result = runStep({ stepId, tool, args }) || { ok: false, error: "step failed" };
+      if (typeof onStepComplete === "function") {
+        try {
+          onStepComplete({ stepId, tool, args, result });
+        } catch {
+          // ignore
+        }
+      }
+      if (result && result.ok !== false) {
         state = recordStepResult(state, {
-          stepId: step.id,
+          stepId,
+          status: "success",
+          artifactId: result.artifactId || "",
+          exitCode: Number.isFinite(result.code) ? result.code : null,
+        });
+      } else {
+        state = recordStepResult(state, {
+          stepId,
           status: "failed",
-          error: `missing dependency ${dep}`,
+          error: String((result && result.error) || "step failed"),
         });
-        fatalError = `segment dependency missing: ${dep}`;
-        state = completeExecutionSegment(state, { status: "failed", error: fatalError });
-        return {
-          ok: false,
-          segmentId,
-          objective: cappedSegment.objective,
-          executionState: state,
-          results,
-          error: fatalError,
-          stoppedAt: "dependency",
-        };
       }
-    }
-
-    const args = resolveStepArgs(step.args, stepOutputs);
-    if (typeof onStepStart === "function") {
-      try {
-        onStepStart({ stepId: step.id, tool: step.tool, args });
-      } catch {
-        // ignore
-      }
-    }
-
-    const result = runStep({ stepId: step.id, tool: step.tool, args }) || { ok: false, error: "step failed" };
-    const stepRecord = {
-      stepId: step.id,
-      tool: step.tool,
-      ok: result.ok !== false,
-      artifactId: result.artifactId || "",
-      error: result.error || "",
-    };
-    results.push(stepRecord);
-
-    if (result.ok === false) {
-      state = recordStepResult(state, {
-        stepId: step.id,
-        status: "failed",
-        error: String(result.error || "step failed"),
-      });
-      fatalError = String(result.error || "segment step failed");
-      state = completeExecutionSegment(state, { status: "failed", error: fatalError });
-      return {
-        ok: false,
-        segmentId,
-        objective: cappedSegment.objective,
-        executionState: state,
-        results,
-        error: fatalError,
-        stoppedAt: "error",
-      };
-    }
-
-    stepOutputs.set(step.id, result);
-    state = recordStepResult(state, {
-      stepId: step.id,
-      status: "success",
-      artifactId: result.artifactId || "",
-      exitCode: Number.isFinite(result.code) ? result.code : null,
-    });
+      return result;
+    },
+  });
 
-    if (typeof onStepComplete === "function") {
-      try {
-        onStepComplete({ stepId: step.id, tool: step.tool, args, result });
-      } catch {
-        // ignore
-      }
-    }
+  const results = Array.isArray(graphResult.results) ? graphResult.results : [];
+  const stoppedAt = String(graphResult.stoppedAt || "");
+  const fatalError = graphResult.ok === false
+    ? String(graphResult.error || "segment failed")
+    : "";
 
-    if (checkpointAfter.has(step.id)) {
-      stoppedAt = "checkpoint";
-      break;
-    }
-    if (isSideEffectTool(step.tool)) {
-      stoppedAt = "side_effect";
-      break;
-    }
-  }
+  let finalStatus = "success";
+  if (fatalError) finalStatus = "failed";
+  else if (stoppedAt === "checkpoint" || stoppedAt === "waiting_llm") finalStatus = "checkpoint";
+  else if (stoppedAt === "side_effect") finalStatus = "success";
 
-  const finalStatus = stoppedAt === "checkpoint" ? "checkpoint" : "success";
-  state = completeExecutionSegment(state, { status: finalStatus });
+  state = completeExecutionSegment(state, { status: finalStatus, error: fatalError });
   return {
-    ok: true,
+    ok: graphResult.ok !== false,
     segmentId,
     objective: cappedSegment.objective,
     executionState: state,
     results,
-    error: "",
+    error: fatalError,
     stoppedAt,
+    waitingFor: graphResult.waitingFor || null,
+    summary: graphResult.summary || null,
+    compile: graphResult.compile || null,
   };
 }
 
@@ -311,4 +291,7 @@ module.exports = {
   executeExecutionSegment,
   formatSegmentResultMessage,
   isSideEffectTool,
+  planGraphFromExecutionSegment,
+  compilePlanGraph,
+  executePlanGraph,
 };

package/src/code/context/index.js

@@ -1,7 +1,6 @@
 "use strict";
 
 module.exports = {
-  ...require("./featureFlag"),
   ...require("./transcript"),
   ...require("./transcriptSync"),
   ...require("./artifacts"),
@@ -14,5 +13,16 @@ module.exports = {
   ...require("./stateCommit"),
   ...require("./workingSet"),
   ...require("./executionSegment"),
+  ...require("./planGraph"),
+  ...require("./planGraphService"),
+  ...require("./toolRuntime"),
+  ...require("./planMode"),
+  ...require("./planProjection"),
+  ...require("./userNudge"),
+  ...require("./userInteraction"),
   ...require("./assembler"),
 };
+
+// Runtime TaskLoop surface (avoid name clashes by nesting under .runtime if needed by callers)
+module.exports.runtime = require("../runtime");
+