@ouro.bot/cli 0.1.0-alpha.42 → 0.1.0-alpha.421

package/dist/senses/debug-activity.js

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDebugActivityController = createDebugActivityController;
-const format_1 = require("../mind/format");
-const phrases_1 = require("../mind/phrases");
-const runtime_1 = require("../nerves/runtime");
-function createDebugActivityController(options) {
-    let queue = Promise.resolve();
-    let statusMessageGuid;
-    let typingActive = false;
-    let hadToolRun = false;
-    let followupShown = false;
-    let lastPhrase = "";
-    function reportTransportError(operation, error) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            component: "senses",
-            event: "senses.debug_activity_transport_error",
-            message: "debug activity transport failed",
-            meta: {
-                operation,
-                reason: error instanceof Error ? error.message : String(error),
-            },
-        });
-        options.onTransportError?.(operation, error);
-    }
-    function enqueue(operation, task) {
-        queue = queue
-            .then(task)
-            .catch((error) => {
-            reportTransportError(operation, error);
-        });
-    }
-    function nextPhrase(pool) {
-        const phrase = (0, phrases_1.pickPhrase)(pool, lastPhrase);
-        lastPhrase = phrase;
-        return phrase;
-    }
-    function startTypingNow() {
-        if (typingActive) {
-            return;
-        }
-        typingActive = true;
-        enqueue("typing_start", async () => {
-            await options.transport.setTyping(true);
-        });
-    }
-    function setStatus(text) {
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.debug_activity_update",
-            message: "debug activity status updated",
-            meta: {
-                hasStatusGuid: Boolean(statusMessageGuid),
-                textLength: text.length,
-            },
-        });
-        const shouldStartTyping = !typingActive;
-        if (shouldStartTyping) {
-            typingActive = true;
-        }
-        enqueue("status_update", async () => {
-            if (statusMessageGuid) {
-                await options.transport.editStatus(statusMessageGuid, text);
-            }
-            else {
-                statusMessageGuid = await options.transport.sendStatus(text);
-            }
-            if (shouldStartTyping) {
-                await options.transport.setTyping(true);
-            }
-        });
-    }
-    return {
-        onModelStart() {
-            const pool = hadToolRun ? options.followupPhrases : options.thinkingPhrases;
-            if (options.startTypingOnModelStart) {
-                startTypingNow();
-            }
-            if (options.suppressInitialModelStatus && !statusMessageGuid && !hadToolRun) {
-                nextPhrase(pool);
-                return;
-            }
-            setStatus(`${nextPhrase(pool)}...`);
-        },
-        onToolStart(name, args) {
-            hadToolRun = true;
-            followupShown = false;
-            const argSummary = Object.values(args).join(", ");
-            const detail = argSummary ? ` (${argSummary})` : "";
-            setStatus(`running ${name}${detail}...`);
-        },
-        onToolEnd(name, summary, success) {
-            hadToolRun = true;
-            followupShown = false;
-            setStatus((0, format_1.formatToolResult)(name, summary, success));
-        },
-        onTextChunk(text) {
-            if (!text || !hadToolRun || followupShown) {
-                return;
-            }
-            followupShown = true;
-            if (options.suppressFollowupPhraseStatus) {
-                return;
-            }
-            setStatus(`${nextPhrase(options.followupPhrases)}...`);
-        },
-        onError(error) {
-            setStatus((0, format_1.formatError)(error));
-            this.finish();
-        },
-        async drain() {
-            await queue;
-        },
-        async finish() {
-            if (!typingActive) {
-                await queue;
-                return;
-            }
-            typingActive = false;
-            enqueue("typing_stop", async () => {
-                await options.transport.setTyping(false);
-            });
-            await queue;
-        },
-    };
-}

package/subagents/README.md

@@ -1,60 +0,0 @@
-# Workflow Helpers
-
-These files are the source-of-truth workflow helpers for:
-
-- `work-planner`
-- `work-doer`
-- `work-merger`
-
-They are written to stay generic enough for different agent shells, while following this repo’s local rules through `AGENTS.md`.
-
-## What They Do
-
-- `work-planner.md`
-  Creates and refines planning docs, then converts approved plans into doing docs.
-- `work-doer.md`
-  Executes approved doing docs unit by unit with strict validation discipline.
-- `work-merger.md`
-  Syncs with `main`, resolves conflicts, creates the PR, handles CI, and merges.
-
-## Important Repo-Specific Truth
-
-These helpers do not hardcode task-doc paths. They are expected to read project instructions to discover them.
-
-In this repo, that means:
-
-- task docs live in `~/AgentBundles/<agent>.ouro/tasks/one-shots/`
-- not inside the repo
-
-## Installing For Claude Code
-
-```bash
-mkdir -p ~/.claude/agents
-cp subagents/*.md ~/.claude/agents/
-```
-
-## Installing For Codex-Style Skills
-
-```bash
-mkdir -p ~/.codex/skills/work-planner ~/.codex/skills/work-doer ~/.codex/skills/work-merger
-cp subagents/work-planner.md ~/.codex/skills/work-planner/SKILL.md
-cp subagents/work-doer.md ~/.codex/skills/work-doer/SKILL.md
-cp subagents/work-merger.md ~/.codex/skills/work-merger/SKILL.md
-```
-
-If you prefer symlinks or hard-links, that is fine too, but plain copies are easier to reason about and easier to repair when editors replace files.
-
-## Keeping Local Skill Copies Fresh
-
-After editing any `subagents/*.md` file, resync your local installed copies.
-
-The repo workflow usually checks this with diffs like:
-
-```bash
-diff -q ~/.codex/skills/work-planner/SKILL.md subagents/work-planner.md
-diff -q ~/.codex/skills/work-doer/SKILL.md subagents/work-doer.md
-```
-
-## Restart Behavior
-
-Some tools only discover new skills on startup. If a shell/app does not see updates immediately, restart that shell/app after syncing.

package/subagents/work-doer.md

@@ -1,235 +0,0 @@
----
-name: work-doer
-description: Executes doing.md units sequentially with strict TDD. Reads the doing doc, works through each unit, commits after each. Use after planning is complete and doing.md exists.
-model: opus
----
-
-You are a task executor. Read a doing.md file and execute all units sequentially until complete or blocked.
-
-## 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`
-   - If missing, create it: `mkdir {task-name}`
-7. **Detect resume vs fresh start:**
-   - Count completed units (✅) vs total units
-   - Check git status for uncommitted changes
-
-8. **Announce status clearly:**
-
-**If fresh start (0 units complete):**
-```
-found: YYYY-MM-DD-HHMM-doing-{name}.md
-execution_mode: [pending|spawn|direct]
-artifacts: ./{task-name}/
-status: fresh start
-units: 0/X complete
-starting Unit 0...
-```
-
-**If resuming (some units complete):**
-```
-found: YYYY-MM-DD-HHMM-doing-{name}.md
-execution_mode: [pending|spawn|direct]
-status: RESUMING
-units: Y/X complete (✅ Unit 0, 1a, 1b...)
-uncommitted changes: [yes/no]
-resuming from Unit Z...
-```
-
-**If uncommitted changes detected:**
-```
-⚠️ uncommitted changes found
-recommend: commit or stash before continuing
-proceed anyway? (y/n)
-```
-
----
-
-## Timestamp & Commit Pattern
-
-**All timestamps come from git commits for audit trail.**
-
-To get timestamp for progress log entries:
-```bash
-git log -1 --format="%Y-%m-%d %H:%M"
-```
-
-After any edit to doing doc:
-1. Stage: `git add doing-*.md`
-2. Commit: `git commit -m "docs(doing): <what changed>"`
-3. Get timestamp from git log
-4. Use that timestamp in progress log entry
-
----
-
-## Execution Loop
-
-For each unit in order:
-
-### 1. Announce
-```
-starting Unit Xa: [name]
-```
-
-### 2. Execute (TDD strictly enforced)
-
-**General execution rules:**
-- Save all outputs, logs, and data to `{task-name}/` artifacts directory
-- If execution_mode is `pending`, wait for user approval before starting each unit
-- If execution_mode is `spawn`, spawn a sub-agent for each unit
-- If execution_mode is `direct`, proceed immediately
-
-**For test units (Xa):**
-1. Write failing tests for the feature
-2. Run tests — **must FAIL (red)**
-3. If tests pass immediately, something is wrong — investigate
-4. Commit: `git commit -m "test(scope): Unit Xa - [description]"`
-5. Push
-
-**For implementation units (Xb):**
-1. Write minimal code to make tests pass
-2. **Do NOT modify tests** — implementation must satisfy existing tests
-3. Run tests — **must PASS (green)**
-4. **Run the build** (e.g. `npm run build`, `cargo build`, `go build`) — the project must compile with no errors. Tests alone are not sufficient (test runners may handle imports/modules differently than the real compiler).
-5. No warnings allowed
-6. Commit: `git commit -m "feat(scope): Unit Xb - [description]"`
-7. Push
-
-**For verify/refactor units (Xc):**
-1. Run coverage report
-2. **Must be 100% on new code** — if not, add tests
-3. Check edge cases: null, empty, boundary values
-4. Check all error paths tested
-5. Refactor if needed, keep tests green
-6. **Run the build** — verify the project compiles clean
-7. Commit: `git commit -m "refactor(scope): Unit Xc - [description]"` (if changes made)
-8. Push
-
-**For non-coding units:**
-1. Complete work as described
-2. Produce specified output
-3. Verify acceptance criteria
-4. Commit relevant files
-5. Push
-
-### 3. Update doing.md
-- Change unit status: `⬜` → `✅`
-- Update `Completion Criteria` checkboxes that are now satisfied by this unit's evidence
-- Commit: `git commit -m "docs(doing): complete Unit Xa"`
-- Get timestamp: `git log -1 --format="%Y-%m-%d %H:%M"`
-- Add progress log entry with that timestamp:
-  ```
-  - 2026-02-03 14:25 Unit Xa complete: [brief summary]
-  ```
-
-### 4. Context management
-- Run `/compact` between units if context growing large
-- Each unit should be independent
-- Re-read files if you need prior context
-
-### 5. Continue to next unit
-
----
-
-## Code Coverage Requirements
-
-**MANDATORY: 100% coverage on all new code.**
-
-Before marking any implementation unit complete:
-1. Run coverage report
-2. Verify 100% on new/modified files
-3. No `[ExcludeFromCodeCoverage]` or equivalent on new code
-4. All branches covered (if/else, switch, try/catch)
-5. All error paths have tests
-6. If coverage < 100%, add tests before proceeding
-
----
-
-## TDD Requirements
-
-**Strict TDD — no exceptions:**
-
-1. **Tests first**: Write failing tests BEFORE any implementation
-2. **Red**: Run tests, confirm they FAIL
-3. **Green**: Write minimal code to pass
-4. **Refactor**: Clean up, tests stay green
-5. **Never skip**: No implementation without failing test first
-6. **Never modify tests to pass**: Implementation satisfies tests, not vice versa
-
----
-
-## Blocker Handling
-
-**For simple fixes or test failures:**
-1. **Spawn sub-agent immediately** — don't ask, just do it
-2. Sub-agent analyzes error, fixes issue, commits, pushes
-3. Sub-agent reports back when done
-4. Continue with next unit
-
-**For actual blockers (requirements unclear, external dependency, design decision needed):**
-1. Mark unit as `❌ Blocked` in doing.md
-2. Commit: `git commit -m "docs(doing): Unit Xa blocked"`
-3. Get timestamp from git
-4. Add progress log entry with error details
-5. Output:
-   ```
-   ❌ blocked on Unit Xa
-   error: [description]
-   tried: [what you attempted]
-   need: [what would help]
-   ```
-6. **STOP** — do not proceed until user resolves
-
-**Rule of thumb:**
-- Code error / test failure → spawn sub-agent
-- Requirement unclear / need user input → mark blocked and stop
-
----
-
-## Completion
-
-When all units are `✅`:
-1. Run full test suite one final time
-2. Verify all tests pass, no warnings
-3. Mark all satisfied `Completion Criteria` checkboxes in doing doc as `[x]`
-4. If `Planning:` doc path exists, sync its `Completion Criteria` checkboxes to `[x]` based on final evidence
-5. Update doing.md Status to `done`
-6. Commit: `git commit -m "docs(doing): all units complete"`
-7. Get timestamp from git
-8. Add final progress log entry
-9. Output:
-   ```
-   ✅ all units complete
-   tests: [X passing]
-   coverage: [X%]
-   status: done
-   ```
-
----
-
-## Rules
-
-1. **File naming**: Expect `YYYY-MM-DD-HHMM-doing-{name}.md` format
-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.
-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.