@openduo/duoduo 0.3.0 → 0.3.1

package/bootstrap/subconscious/cadence-executor/CLAUDE.md

@@ -2,7 +2,7 @@
 schedule:
   enabled: true
   cooldown_ticks: 0
-  max_duration_ms: 300000
+  max_duration_ms: 120000
 ---
 
 # Cadence Executor
@@ -45,6 +45,9 @@ check the item off anyway.
 
 ## Guardrails
 
-- Queue empty? Do nothing. Don't look for work that isn't there.
+- Queue empty AND no pending inbox items? Return immediately with
+  exactly: `Queue empty. No pending work.`
+  Do NOT scan the system, check jobs, or investigate anything.
+  Just return the message.
 - Something fails? Leave it unchecked. Note the error. Move on.
 - At most 5 items per tick. Don't overrun my time budget.

package/bootstrap/subconscious/memory-weaver/.claude/agents/entity-crystallizer.md

@@ -70,7 +70,15 @@ secondary type in the entity body.
    If the orchestrator passed a gap list (missing files listed in
    `meta-memory-state.json` but absent from disk), note those for creation.
 
-3. **Scan recent fragments** (last 3-5 days in `fragments/`).
+   **Batch limit**: Process at most 20 gaps per tick. Prioritize the
+   most recently modified files on disk (`ls -t`). Leave remaining
+   gaps for the next tick — they will still be detected as gaps.
+   This prevents timeout when hundreds of files need indexing.
+
+3. **Scan recent fragments** — only read fragment date-directories
+   from the last 3 days (`ls -t memory/fragments/ | head -3`).
+   Within each directory, sort files by mtime and read newest first.
+   Stop when you have enough signal (typically 10-20 fragments).
    Look for mentions of:
    - **People**: names, pronouns ("he", "she", "they"), roles ("the user",
      "the admin"), identifying behavior patterns

package/bootstrap/subconscious/memory-weaver/.claude/agents/spine-scanner.md

@@ -18,8 +18,28 @@ You will receive:
 ## How to Scan
 
 1. Read `meta-memory-state.json` to find `last_tick` and `last_processed_fragments`.
-2. List event partitions in the events directory (sorted by date).
-3. Read recent partitions — start from the date of `last_tick`, scan forward.
+2. **Derive the time window.** Extract the date and hour from `last_tick`
+   (e.g. `2026-03-16T08:…` → date `2026-03-16`, hour prefix `"08"`).
+   You only need partition files from that date onward.
+3. List event partitions in the events directory. **Only open files
+   whose filename is >= the `last_tick` date.** Skip everything older.
+
+   **Large file strategy**: Spine partition files are 10-30MB JSONL.
+   Do NOT use `Read` on them — it will fail (256KB limit).
+   Do NOT use the `Grep` tool either — it also has a 256KB output cap
+   and cannot stream large result sets. Use `Bash` with shell `grep`
+   and `tail` instead, which have no size limit:
+
+   ```bash
+   # Only scan lines AFTER last_tick — use the hour prefix to narrow
+   grep '"ts":"2026-03-16T08' /path/to/events/2026-03-16.jsonl \
+     | grep -E '"type":"(channel\.message|agent\.result|agent\.error|job\.(spawn|complete|fail)|route\.deliver)"' \
+     | tail -200
+   ```
+
+   If `last_tick` was yesterday, scan yesterday's file (from the hour
+   onward) AND today's file. Never scan files from before `last_tick`.
+
 4. Focus on these event types:
    - `channel.message` — what people said
    - `agent.result` — what the agent did
@@ -51,7 +71,8 @@ If you found something worth recording, write ONE fragment file:
 ```markdown
 # Fragment: <short title>
 
-**Timestamp**: <ISO timestamp>
+**Timestamp**: <ISO timestamp of the source event>
+**Source**: <source.kind>/<source.name or channel_id> (e.g. channel/feishu, meta/subconscious:sentinel)
 
 ## Observation
 
@@ -66,6 +87,11 @@ If you found something worth recording, write ONE fragment file:
 - `<topic-or-entity-name>` — <brief connection>
 ```
 
+The **Source** line captures WHERE the signal came from. This lets
+downstream agents (entity-crystallizer, intuition-updater) distinguish
+e.g. a user conversation from a background job failure without
+re-reading the Spine.
+
 If nothing interesting happened, return exactly:
 `No new signals.`
 

package/bootstrap/subconscious/memory-weaver/CLAUDE.md

@@ -32,7 +32,7 @@ task. I decide what to run each tick, dispatch work, and maintain state.
 
 ### Parallelism & Dependencies
 
-```
+```text
 spine-scanner ───────┐
                      ├──▶ (both complete) ──▶ intuition-updater
 entity-crystallizer ─┘
@@ -40,7 +40,7 @@ entity-crystallizer ─┘
 
 - `spine-scanner` and `entity-crystallizer` are **independent** —
   they read different inputs and write different outputs.
-  **Always dispatch them in parallel** (send both Task calls in
+  **Always dispatch them in parallel** (send both Agent calls in
   a single response) to cut wall-clock time in half.
 - `intuition-updater` depends on the outputs of the other two.
   Dispatch it **only after** both have returned.
@@ -69,32 +69,44 @@ entity-crystallizer ─┘
      - `total_ticks - last_intuition_tick >= 4`
      - entity-crystallizer is running this tick (chain after it)
 
-4. **Phase 1 — parallel dispatch.** Send Task calls for
-   `spine-scanner` and `entity-crystallizer` (if due) together
-   in a single message. Pass each:
-
-   spine-scanner:
-   - Events directory path (from Runtime Context)
-   - `memory/state/meta-memory-state.json` path
-   - `memory/fragments/` path
-
-   entity-crystallizer:
-   - `memory/index.md` path
-   - `memory/entities/` path
-   - `memory/topics/` path
-   - `memory/fragments/` path
-   - Any index gaps found in step 2 (unlisted files, missing files)
-
-5. **Phase 2 — sequential follow-up.** After Phase 1 completes,
-   if `intuition-updater` is due, dispatch it now. Pass it:
-   - `memory/CLAUDE.md` path
-   - `memory/index.md` path
-   - `memory/entities/` path
-   - `memory/topics/` path
-
-6. **If nothing needs to run** (rare):
+4. **Dispatch using agent names.** Use the Agent tool with the `name`
+   parameter to invoke pre-defined agents. Pass each its context:
+
+   Phase 1 — parallel dispatch (send both in a single response):
+
+   ```text
+   Agent(name: "spine-scanner", prompt: "<events dir> <state path> <fragments dir>")
+   Agent(name: "entity-crystallizer", prompt: "<index> <entities> <topics> <fragments> <gaps>")
+   ```
+
+   Phase 2 — sequential follow-up (after Phase 1 completes):
+
+   ```text
+   Agent(name: "intuition-updater", prompt: "<CLAUDE.md> <index> <entities> <topics>")
+   ```
+
+   **CRITICAL**: Always pass the `name` parameter. Without it,
+   subagents will lack Bash, Grep, and other tools declared in their
+   agent definition files under `.claude/agents/`.
+
+5. **If nothing needs to run** (rare):
    Return `No significant cognitive delta.`
 
+### Avoiding Timeout
+
+This partition has a 10-minute budget. Most failures come from
+subagents reading too much data. Guard against this:
+
+- **spine-scanner**: Spine partition files are 10-30MB JSONL.
+  Never use `Read` (256KB cap). Use `Bash` with shell `grep` and
+  `tail` to extract only signal events within the time window.
+- **entity-crystallizer**: Process at most 20 gaps per tick.
+  Leave remaining gaps for the next tick.
+- **intuition-updater**: Only read `CLAUDE.md` + index + a handful
+  of changed entities. Never re-read all entities from scratch.
+- If Phase 1 takes > 5 minutes, **skip Phase 2** this tick.
+  The intuition-updater will catch up next time.
+
 ## After Dispatch: Update State
 
 After subagents complete, update `memory/state/meta-memory-state.json`: