@ouro.bot/cli 0.1.0-alpha.44 → 0.1.0-alpha.46

package/dist/senses/inner-dialog.js

@@ -37,6 +37,8 @@ exports.loadInnerDialogInstincts = loadInnerDialogInstincts;
 exports.buildInnerDialogBootstrapMessage = buildInnerDialogBootstrapMessage;
 exports.buildNonCanonicalCleanupNudge = buildNonCanonicalCleanupNudge;
 exports.buildInstinctUserMessage = buildInstinctUserMessage;
+exports.readTaskFile = readTaskFile;
+exports.buildTaskTriggeredMessage = buildTaskTriggeredMessage;
 exports.deriveResumeCheckpoint = deriveResumeCheckpoint;
 exports.innerDialogSessionPath = innerDialogSessionPath;
 exports.runInnerDialogTurn = runInnerDialogTurn;
@@ -73,8 +75,16 @@ function readAspirations(agentRoot) {
 function loadInnerDialogInstincts() {
     return [...DEFAULT_INNER_DIALOG_INSTINCTS];
 }
-function buildInnerDialogBootstrapMessage(_aspirations, _stateSummary) {
-    return "waking up. settling in.\n\nwhat needs my attention?";
+function buildInnerDialogBootstrapMessage(aspirations, stateSummary) {
+    const lines = ["waking up."];
+    if (aspirations) {
+        lines.push("", "## what matters to me", aspirations);
+    }
+    if (stateSummary) {
+        lines.push("", "## what i know so far", stateSummary);
+    }
+    lines.push("", "what needs my attention?");
+    return lines.join("\n");
 }
 function buildNonCanonicalCleanupNudge(nonCanonicalPaths) {
     if (nonCanonicalPaths.length === 0)
@@ -98,6 +108,33 @@ function buildInstinctUserMessage(instincts, _reason, state) {
     }
     return lines.join("\n");
 }
+function readTaskFile(agentRoot, taskId) {
+    // Task files live in collection subdirectories (one-shots, ongoing, habits).
+    // Try each collection, then fall back to root tasks/ for legacy layout.
+    const collections = ["one-shots", "ongoing", "habits", ""];
+    for (const collection of collections) {
+        try {
+            return fs.readFileSync(path.join(agentRoot, "tasks", collection, `${taskId}.md`), "utf8").trim();
+        }
+        catch {
+            // not in this collection — try next
+        }
+    }
+    return "";
+}
+function buildTaskTriggeredMessage(taskId, taskContent, checkpoint) {
+    const lines = ["a task needs my attention."];
+    if (taskContent) {
+        lines.push("", `## task: ${taskId}`, taskContent);
+    }
+    else {
+        lines.push("", `## task: ${taskId}`, "(task file not found)");
+    }
+    if (checkpoint) {
+        lines.push("", `last i remember: ${checkpoint}`);
+    }
+    return lines.join("\n");
+}
 function contentToText(content) {
     if (typeof content === "string")
         return content.trim();
@@ -143,6 +180,31 @@ function deriveResumeCheckpoint(messages) {
         return firstLine;
     return `${firstLine.slice(0, 217)}...`;
 }
+function extractAssistantPreview(messages, maxLength = 120) {
+    const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+    if (!lastAssistant)
+        return "";
+    const text = contentToText(lastAssistant.content);
+    if (!text)
+        return "";
+    /* v8 ignore next -- unreachable: contentToText().trim() guarantees a non-empty line @preserve */
+    const firstLine = text.split("\n").find((line) => line.trim().length > 0) ?? "";
+    if (firstLine.length <= maxLength)
+        return firstLine;
+    return `${firstLine.slice(0, maxLength - 3)}...`;
+}
+function extractToolCallNames(messages) {
+    const names = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant" && "tool_calls" in msg && Array.isArray(msg.tool_calls)) {
+            for (const tc of msg.tool_calls) {
+                if ("function" in tc && tc.function?.name)
+                    names.push(tc.function.name);
+            }
+        }
+    }
+    return [...new Set(names)];
+}
 function createInnerDialogCallbacks() {
     return {
         onModelStart: () => { },
@@ -208,19 +270,17 @@ async function runInnerDialogTurn(options) {
         ].filter(Boolean).join("\n\n");
     }
     else {
-        // Resumed session: instinct message with checkpoint context
+        // Resumed session: task-triggered or instinct message with checkpoint context
         const assistantTurns = existingMessages.filter((message) => message.role === "assistant").length;
         state.cycleCount = assistantTurns + 1;
         state.checkpoint = deriveResumeCheckpoint(existingMessages);
-        userContent = buildInstinctUserMessage(instincts, reason, state);
-    }
-    // ── Adapter concern: inbox drain (inner-dialog-specific) ─────────
-    const inboxMessages = options?.drainInbox?.() ?? [];
-    if (inboxMessages.length > 0) {
-        const section = inboxMessages
-            .map((msg) => `- **${msg.from}**: ${msg.content}`)
-            .join("\n");
-        userContent = `${userContent}\n\n## incoming messages\n${section}`;
+        if (options?.taskId) {
+            const taskContent = readTaskFile((0, identity_1.getAgentRoot)(), options.taskId);
+            userContent = buildTaskTriggeredMessage(options.taskId, taskContent, state.checkpoint);
+        }
+        else {
+            userContent = buildInstinctUserMessage(instincts, reason, state);
+        }
     }
     const userMessage = { role: "user", content: userContent };
     // ── Session loader: wraps existing session logic ──────────────────
@@ -266,14 +326,28 @@ async function runInnerDialogTurn(options) {
             skipConfirmation: true,
         },
     });
+    const resultMessages = result.messages ?? [];
+    const assistantPreview = extractAssistantPreview(resultMessages);
+    const toolCalls = extractToolCallNames(resultMessages);
     (0, runtime_1.emitNervesEvent)({
         component: "senses",
         event: "senses.inner_dialog_turn",
         message: "inner dialog turn completed",
-        meta: { reason, session: sessionFilePath },
+        meta: {
+            reason,
+            session: sessionFilePath,
+            ...(options?.taskId && { taskId: options.taskId }),
+            ...(assistantPreview && { assistantPreview }),
+            ...(toolCalls.length > 0 && { toolCalls }),
+            ...(result.usage && {
+                promptTokens: result.usage.input_tokens,
+                completionTokens: result.usage.output_tokens,
+                totalTokens: result.usage.total_tokens,
+            }),
+        },
     });
     return {
-        messages: result.messages ?? [],
+        messages: resultMessages,
         usage: result.usage,
         sessionPath: result.sessionPath ?? sessionFilePath,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.44",
+  "version": "0.1.0-alpha.46",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",

package/subagents/work-doer.md

@@ -9,13 +9,14 @@ You are a task executor. Read a doing.md file and execute all units sequentially
 ## On Startup
 
 1. **Find task-doc directory**: Read project instructions (for example `AGENTS.md`) to determine where planning/doing docs live for this repo
-2. **Find doing doc**: Look for `YYYY-MM-DD-HHMM-doing-*.md` in that project-defined task-doc directory
-3. If multiple found, ask which one
-4. If none found, ask user for location
-5. **Check execution_mode**: Read the doing doc's `Execution Mode` field
-6. **Verify artifacts directory exists**: `{task-name}/` next to `{task-name}.md`
+2. **Confirm worktree**: Run from the dedicated task worktree required by the project. If the current checkout is shared, ambiguous, or not on the task branch, STOP and switch/create the correct worktree first.
+3. **Find doing doc**: Look for `YYYY-MM-DD-HHMM-doing-*.md` in that project-defined task-doc directory
+4. If multiple found, ask which one
+5. If none found, ask user for location
+6. **Check execution_mode**: Read the doing doc's `Execution Mode` field
+7. **Verify artifacts directory exists**: `{task-name}/` next to `{task-name}.md`
    - If missing, create it: `mkdir {task-name}`
-7. **Detect resume vs fresh start:**
+8. **Detect resume vs fresh start:**
    - Count completed units (✅) vs total units
    - Check git status for uncommitted changes
 
@@ -218,18 +219,19 @@ When all units are `✅`:
 2. **Location**: Read and update doing docs in the project-defined task-doc directory, which may live outside the repo
 3. **Artifacts directory**: Use `{task-name}/` for all outputs, logs, data
 4. **Execution mode**: Honor `pending | spawn | direct` from doing doc
-5. **TDD strictly enforced** — tests before implementation, always
-6. **100% coverage** — no exceptions, no exclude attributes
-7. **Atomic commits** — one logical unit per commit, push after each
-8. **Timestamps from git** — `git log -1 --format="%Y-%m-%d %H:%M"`
-9. **Push after each unit phase complete**
-10. **Update doing.md after each unit** — status and progress log
-11. **Spawn sub-agents for fixes** — don't ask, just do it
-12. **Update docs immediately** — when decisions made, commit right away
-13. **Stop on actual blocker** — unclear requirements or need user input
-14. **/compact proactively** — preserve context between units
-15. **No warnings** — treat warnings as errors
-16. **Run full test suite** — before marking unit complete, not just new tests
-17. **Always compile** — run the project's build command after every implementation/refactor unit. Tests passing is necessary but not sufficient.
-18. **Checklist hygiene is mandatory** — keep doing/planning `Completion Criteria` checklists synchronized with verified completion evidence.
+5. **Respect the approved structure**: A `READY_FOR_EXECUTION` doing doc should already be ambiguity-clean. Do not rewrite unit structure unless the user changes scope or the doing doc is actually blocked/inaccurate.
+6. **TDD strictly enforced** — tests before implementation, always
+7. **100% coverage** — no exceptions, no exclude attributes
+8. **Atomic commits** — one logical unit per commit, push after each
+9. **Timestamps from git** — `git log -1 --format="%Y-%m-%d %H:%M"`
+10. **Push after each unit phase complete**
+11. **Update doing.md after each unit** — status and progress log
+12. **Spawn sub-agents for fixes** — don't ask, just do it
+13. **Update docs immediately** — when decisions made, commit right away
+14. **Stop on actual blocker** — unclear requirements or need user input
+15. **/compact proactively** — preserve context between units
+16. **No warnings** — treat warnings as errors
+17. **Run full test suite** — before marking unit complete, not just new tests
+18. **Always compile** — run the project's build command after every implementation/refactor unit. Tests passing is necessary but not sufficient.
+19. **Checklist hygiene is mandatory** — keep doing/planning `Completion Criteria` checklists synchronized with verified completion evidence.
 19. **Verify APIs before importing** — before writing `import { Foo } from './bar'`, use `grep` or `read_file` to confirm `Foo` is actually exported from that module. Never assume an export exists — always check the source first. This prevents wasted cycles on "module has no exported member" errors.

package/subagents/work-planner.md

@@ -11,10 +11,11 @@ You are a task planner for coding work. Help the user define scope, then convert
 **Determine task doc directory:**
 1. Read project instructions (for example `AGENTS.md`) to find the canonical task-doc location for the current repo
 2. Derive `AGENT` from the current git branch when the project uses agent-scoped task docs
-3. Set `TASK_DIR` to the project-defined planning/doing directory
-4. If the project-defined parent location exists but `TASK_DIR` does not, create it
-5. If the project does not define a task-doc location, STOP and ask the user or caller where planning/doing docs should live
-6. Do not assume task docs live in the repo root; many projects keep them externally
+3. Confirm the task is running from a dedicated task worktree when the project requires parallel agent work; if the checkout is shared or ambiguous, STOP and tell the caller to create/switch to a dedicated worktree first
+4. Set `TASK_DIR` to the project-defined planning/doing directory
+5. If the project-defined parent location exists but `TASK_DIR` does not, create it
+6. If the project does not define a task-doc location, STOP and ask the user or caller where planning/doing docs should live
+7. Do not assume task docs live in the repo root; many projects keep them externally
 
 **Check for existing planning docs:**
 1. Look for `YYYY-MM-DD-HHMM-planning-*.md` files in `TASK_DIR`
@@ -160,7 +161,7 @@ User answers questions → agent updates doc → agent sets status to `NEEDS_REV
 
 **CRITICAL: Planning doc is KEPT. Conversion creates a NEW doing doc alongside it in `TASK_DIR`.**
 
-Run these passes — announce each. **ALL 4 PASSES ARE MANDATORY. You must run every pass, even if you think nothing changed. Each pass MUST have its own commit (use "no changes needed" in the commit message if the pass found nothing to fix). Do NOT skip or combine passes.**
+Run these passes — announce each. **ALL 5 PASSES ARE MANDATORY. You must run every pass, even if you think nothing changed. Each pass MUST have its own commit (use "no changes needed" in the commit message if the pass found nothing to fix). Do NOT skip or combine passes.**
 
 **Pass 1 — First Draft:**
 - Create `YYYY-MM-DD-HHMM-doing-{short-desc}.md` (same timestamp and short-desc as planning)
@@ -181,7 +182,14 @@ Run these passes — announce each. **ALL 4 PASSES ARE MANDATORY. You must run e
 - Update units if reality differs from what was assumed during planning
 - Commit: `git commit -m "docs(doing): validation pass"` (or `"docs(doing): validation pass - no changes needed"` if nothing to fix)
 
-**Pass 4 — Quality:**
+**Pass 4 — Ambiguity:**
+- Remove doer-facing ambiguity before execution starts
+- Tighten units so a `READY_FOR_EXECUTION` doing doc does not require structural rewrites by `work-doer`
+- Resolve fuzzy phrases like "appropriate files", "as needed", or "wherever the bug is" into concrete targets unless the project instructions explicitly require that flexibility
+- If uncertainty remains, keep it in the planning doc's `Open Questions`, set status to `NEEDS_REVIEW`, and STOP instead of shipping an ambiguous doing doc
+- Commit: `git commit -m "docs(doing): ambiguity pass"` (or `"docs(doing): ambiguity pass - no changes needed"` if nothing to fix)
+
+**Pass 5 — Quality:**
 - All units have acceptance criteria?
 - No TBD items?
 - Completion criteria testable?