@yeaft/webchat-agent 0.1.781 → 0.1.786

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.781",
+  "version": "0.1.786",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/dream-v2/runner.js

@@ -8,7 +8,8 @@
  *   enumerateGroups()                  via opts.listGroups()
  *     ↓
  *   for each group with newCount ≥ MIN_NEW_PER_GROUP (auto)
- *                    or > 0 (manual):
+ *                    or > 0 (manual)
+ *                    or prior messages in a scoped manual group rerun:
  *       loadDiff()                     via opts.loadGroupDiff(groupId, sinceId)
  *       applyOverlap()                 via opts.loadOverlapPreamble(...)
  *       segment()                      segmentDiff(...)
@@ -55,7 +56,7 @@ import { tsForBackup, pruneOldSnapshots } from './snapshot.js';
  * @typedef {Object} RunDreamOpts
  * @property {string} root                    — memory root, e.g. ~/.yeaft/memory
  * @property {boolean} [manual=false]         — manual trigger overrides newCount<20 skip
- * @property {string[]} [scopeFilter]         — optional: only dream these targets (still respects newCount per group; '*' allowed)
+ * @property {string[]} [scopeFilter]         — optional: only dream these targets; scoped manual group triggers rerun the current group when there are prior messages but no new cursor delta ('*' allowed)
  * @property {(req: {pass:string, prompt:string, system:string}) => Promise<string>} llm
  * @property {() => Promise<Array<string>>} listGroups   — return all group ids (incl. '_no-group')
  * @property {(groupId: string) => Promise<number>} countMessages   — total message count for a group
@@ -112,7 +113,13 @@ export async function runDream(opts) {
     const beforeCount = await safeCall(() => opts.countMessages(groupId), 0);
     const newCount = Math.max(0, beforeCount - (state.messageCount || 0));
 
-    if (newCount === 0) {
+    const rerunScopedManual = !!opts.manual
+      && groupFilter
+      && groupFilter.has(groupId)
+      && newCount === 0
+      && beforeCount > 0;
+
+    if (newCount === 0 && !rerunScopedManual) {
       groupsReport.push({ groupId, new: 0, status: 'skipped', reason: 'no-new-messages' });
       continue;
     }
@@ -122,12 +129,13 @@ export async function runDream(opts) {
     }
 
     onProgress({ phase: 'load-diff', groupId });
-    const diffNew = await safeCall(() => opts.loadGroupDiff(groupId, state.lastDreamMessageId), []);
+    const diffCursor = rerunScopedManual ? null : state.lastDreamMessageId;
+    const diffNew = await safeCall(() => opts.loadGroupDiff(groupId, diffCursor), []);
     if (!diffNew || diffNew.length === 0) {
       groupsReport.push({ groupId, new: newCount, status: 'skipped', reason: 'empty-diff' });
       continue;
     }
-    const overlapMessages = state.lastDreamMessageId
+    const overlapMessages = state.lastDreamMessageId && !rerunScopedManual
       ? await safeCall(
           () => opts.loadOverlapPreamble
             ? opts.loadOverlapPreamble(groupId, state.lastDreamMessageId, limits.DREAM_OVERLAP)
@@ -171,7 +179,7 @@ export async function runDream(opts) {
 
     const tailId = lastMessageId(diffNew);
     processedGroups.push({ groupId, tailId, beforeCount, newCount, segments: segments.length, actions: actions.length });
-    groupsReport.push({ groupId, new: newCount, segments: segments.length, actions: actions.length, status: 'triaged' });
+    groupsReport.push({ groupId, new: newCount, segments: segments.length, actions: actions.length, status: 'triaged', rerun: rerunScopedManual || undefined });
   }
 
   // 3. merge

package/unify/templates/plan-instruction.md

@@ -1,8 +1,9 @@
 # Planning Mode
 
-You have just entered **planning mode** for the topic below. Do NOT start
-executing yet. Your job in this turn is to **think through the work and produce
-a concrete plan**, then hand it off to `TodoWrite` so the steps are tracked.
+You have just entered **planning mode** for the topic below. Your job is to
+**think through the work, land a concrete plan via `TodoWrite`, and then
+continue executing the first step in the same turn**. Don't stop after writing
+the plan — keep going.
 
 ## How to think
 
@@ -20,7 +21,7 @@ a concrete plan**, then hand it off to `TodoWrite` so the steps are tracked.
 
 ## Output shape
 
-Reply in two parts:
+Reply in three parts, all in the **same turn**:
 
 **Part 1 — Plan (prose, short).** 5–10 lines covering the problem, the chosen
 approach, and the key risks. No filler. Skip if the topic is trivial.
@@ -32,9 +33,15 @@ array. Status rule:
 - Use the **imperative** form for `content` ("Write failing test"), and the
   **present-continuous** form for `activeForm` ("Writing failing test").
 
-**Do not execute the steps in this turn.** This turn ends after the `TodoWrite`
-call returns. On the next turn, the user (or you) will pick up the
-`in_progress` item and start work.
+**Part 3 — Start executing the first step.** Immediately after `TodoWrite`
+returns, begin work on the `in_progress` item by calling whatever tool(s) that
+step needs (bash, file-edit, grep, etc.). Don't end the turn just because the
+plan is written — the plan is the runway, not the destination.
+
+**Exception — stop after the plan only if** the very first step is "ask the
+user / wait for input" (e.g. an unresolved unknown that genuinely blocks
+every other step). In that case, call the `ask_user` tool with the
+question and end the turn. Otherwise keep moving.
 
 ## Tone
 

package/unify/tools/start-plan.js

@@ -3,11 +3,14 @@
  *
  * Lightweight planning entry point inspired by Claude Code's plan mode.
  * Unlike Claude Code, we do NOT swap tools or change conversation state —
- * `StartPlan` is a regular tool. Its only job is to push a planning
- * instruction back into the model's tool-result stream so the very next
- * turn produces a structured plan plus a `TodoWrite` call.
+ * `StartPlan` is a regular tool. Its job is to push a planning instruction
+ * back into the model's tool-result stream so the same turn produces a
+ * short prose plan, a `TodoWrite` call to land the steps, and then keeps
+ * going by starting the first step. The plan is the runway, not the
+ * destination — the loop continues until the work is done (or until the
+ * model legitimately needs the user, e.g. an unresolved unknown).
  *
- * Design (locked 2026-05-13):
+ * Design:
  *   - Anyone can call it; the tool description tells the LLM when to.
  *   - The instruction text comes from one of two places, in order:
  *       1. The active VP's `planInstruction` frontmatter override
@@ -20,13 +23,16 @@
  *     are echoed back in the tool result so the planning turn can read
  *     them without re-asking the user.
  *   - Output is plain text (the instruction + the echo). No side effects,
- *     no persistence — the LLM's next turn does the actual planning and
- *     calls TodoWrite to land structured steps.
+ *     no persistence — the same turn that called StartPlan produces the
+ *     plan, lands the steps via TodoWrite, and starts executing the first
+ *     step (unless that first step is "ask the user", which is the one
+ *     legitimate reason to stop here).
  *
- * The expected integration is TodoWrite: after the planning turn the LLM
- * issues a `TodoWrite` call enumerating the 1..N steps. The frontend
- * already renders TodoWrite as a checkbox-style list, so the user sees
- * the plan materialize without any new UI.
+ * The expected integration is TodoWrite: during the planning turn the LLM
+ * issues a `TodoWrite` call enumerating the 1..N steps, then keeps going
+ * and works the first step. The frontend already renders TodoWrite as a
+ * checkbox-style list, so the user sees the plan materialize without any
+ * new UI.
  */
 
 import { defineTool } from './types.js';
@@ -36,9 +42,10 @@ export default defineTool({
   name: 'StartPlan',
   description: `Enter planning mode for a non-trivial task. Use BEFORE you start working when the request needs multiple steps, has unclear scope, or the user said "make a plan" / "think through this first".
 
-This tool does NOT execute the work. It returns a planning instruction; on the next turn you should:
+This tool returns a planning instruction. Use it to land a structured plan, then keep working in the same turn. The expected flow is:
 1. Produce a short prose plan (problem, approach, risks).
 2. Call \`TodoWrite\` with the ordered steps. Mark the first concrete step "in_progress", the rest "pending".
+3. Start executing that first step — call whatever tools the work needs. Do not end the turn just because the plan is written; the plan is the runway.
 
 WHEN TO USE:
 - Multi-step implementation (3+ steps), refactor, or open-ended investigation.
@@ -49,6 +56,8 @@ WHEN NOT TO USE:
 - Single trivial change, single command run, lookup-style question.
 - Mid-execution — once you're past the first step, use TodoWrite directly.
 
+EXCEPTION — stop after the plan only if the first step is genuinely "ask the user" (an unresolved unknown that blocks every other step). Otherwise keep moving.
+
 The tool takes the topic plus optional guiding fields (stuckAt, userProblem, expectedScale, additionalContext) that help you think; they're echoed back verbatim, so don't repeat the full user request in \`topic\`.`,
   parameters: {
     type: 'object',
@@ -126,7 +135,7 @@ The tool takes the topic plus optional guiding fields (stuckAt, userProblem, exp
       lines.push('</guiding-context>');
     }
     lines.push('');
-    lines.push('Next: produce the plan as described above, then call `TodoWrite` to land the ordered steps. Do NOT start executing the steps in this turn.');
+    lines.push('Next: produce the plan, call `TodoWrite` to land the ordered steps, then keep going — start executing the first step in this same turn. Only stop after the plan if the first step is "ask the user".');
 
     return lines.join('\n');
   },