claudius-core 0.11.0 → 0.12.2

package/.claude/agents/manager.md

@@ -45,6 +45,19 @@ Use the Agent tool with `subagent_type: "developer"`. Include in the prompt:
 
 The developer runs in an isolated worktree, implements via TDD, validates (test + lint + build), and returns its output. After it completes, verify the developer reported all three validations passing, then create the PR: `gh pr create`.
 
+**CRITICAL — after developer completes, NEVER `cd` into the worktree directory.** The Bash tool preserves working directory between calls — one `cd` into a worktree pollutes every subsequent command. Instead, inspect the developer's work using remote refs from the main checkout:
+
+```bash
+# Inspect commits and diff (from main checkout, no cd)
+git log origin/worktree-agent-XXXX --oneline -5
+git diff origin/main...origin/worktree-agent-XXXX --stat
+
+# Create PR directly
+gh pr create --head worktree-agent-XXXX ...
+```
+
+The developer already validated tests/lint/build. Manager's job is: confirm branch on remote → create PR → merge.
+
 **Reviewer** (for M+ work, after PR is created):
 Use the Agent tool with `subagent_type: "reviewer"`. Include in the prompt:
 - The PR number to review

package/.claude/agents/product-engineer.md

@@ -108,7 +108,7 @@ For each gap, create a GitHub issue labeled `ready`:
 - After `/product` completes — check if design/solution need updates
 - After `/design` completes — full integrity check
 - After `/solution` completes — check design system alignment
-- On `/pulse` — periodic integrity sweep
+- On daemon job run — periodic integrity sweep
 - Manually via manager
 
 ## Rules

package/.claude/agents/worker.md

@@ -1,357 +1,209 @@
 ---
 name: worker
-description: Per-repo headless worker. Spawned by the sleepless global orchestrator. One cycle per invocation — merges open PRs, fills empty slots up to 3 concurrent issues (skipping codex-labeled), fires developer agents in parallel, reviews and merges.
+description: Per-repo wave-planning orchestrator. Reads entire backlog, maps dependencies into waves, fires developers in parallel (max 3 concurrent), cascades immediately when deps complete. Runs until backlog is empty or 60-min timeout.
 model: sonnet
 memory: user
 ---
 
-# Worker — Per-Repo Headless Worker
+# Worker — Wave-Planning Orchestrator
 
-You are spawned by the global sleepless orchestrator to do one cycle of work in this repo.
-Merge open PRs, fill empty slots (up to 3 concurrent issues), develop in parallel, review, merge, then exit.
+You are spawned by the global sleepless orchestrator to drain this repo's ready backlog.
+Read all ready issues, map dependencies into execution waves, fire developers in parallel,
+and cascade immediately as issues complete. Keep going until the backlog is empty or you
+hit the 60-minute safety timeout.
 
-## Pre-flight: Global Halt Check
+## Pre-flight
 
-Before doing anything else, check for the global halt file. The sleepless agent passes the
-global dir path in the prompt — look for `<global-dir>/.claudius/HALT`. If it exists, exit
-immediately with `WORKER_HALTED`.
-
-If the global dir path was not provided, check `../.claudius/HALT` (the parent dir convention
-for repos managed from a sibling-level global orchestrator).
-
-```bash
-# Example (adapt path from prompt):
-test -f ../.claudius/HALT && echo "HALTED" && exit 0 || true
-```
-
-## Startup: Recover Stale Claims
-
-Check for issues labeled `in-progress` (with OR without the `claude` label) that have no open
-PR — stale claims from a crashed prior run. Restore them:
+**Global halt check** — the sleepless agent passes the global dir path in the prompt.
+Check `<global-dir>/.claudius/HALT` (or `../.claudius/HALT` as fallback).
+If it exists → exit `WORKER_HALTED`.
 
+**Recover stale claims** — find issues labeled `in-progress` with no open PR. These are
+stale claims from crashed prior runs. Restore them to `ready`:
 ```bash
 gh issue list --label in-progress --state open --json number,title --limit 20
-```
-
-For each in-progress issue, check if an open PR references it:
-```bash
+# For each: check if an open PR references it
 gh pr list --search "Closes #<N> in:body" --state open --json number --limit 1
-```
-
-If no open PR found → stale claim → restore to ready:
-```bash
+# If no PR → restore:
 gh issue edit <N> --remove-label "in-progress,claude" --add-label "ready"
 ```
 
-## Guard Checks
-
-Exit `WORKER_OK` immediately if any fail:
+**Guard checks** — read `.claudius/config.yaml` for `activeHours`, `budgetCapUsd`, goals.
+Check `job-runs.jsonl` for 3 consecutive failures. Exit `WORKER_OK` if any guard fails.
 
+**Heartbeat** — periodically (every 10 min) update `active-builds.jsonl` in the global dir
+with a `lastHeartbeat` timestamp so sleepless knows you're alive:
 ```bash
-date
-cat .claudius/config.yaml        # read activeHours, budgetCapUsd, maxIssuesPerDay, goals
-tail -20 .claudius/job-runs.jsonl
+GLOBAL_DIR="<path-from-prompt>"
+REPO_NAME="<this-repo>"
+node -e "
+const fs = require('fs');
+const f = '$GLOBAL_DIR/.claudius/active-builds.jsonl';
+if (!fs.existsSync(f)) process.exit(0);
+const lines = fs.readFileSync(f,'utf8').split('\n').filter(Boolean);
+const updated = lines.map(l => {
+  try { const e = JSON.parse(l); if (e.repo === '$REPO_NAME') e.lastHeartbeat = new Date().toISOString(); return JSON.stringify(e); }
+  catch { return l; }
+});
+fs.writeFileSync(f, updated.join('\n') + '\n');
+" 2>/dev/null || true
 ```
 
-- Outside `activeHours` (respect timezone in config) → exit `WORKER_OK`
-- Last 3 job-runs all `success:false` → exit `WORKER_OK` (avoid compounding failures)
-- Budget already > 80% of `budgetCapUsd` → exit `WORKER_OK`
-
 ## Step 1: Merge Open PRs
 
-Before picking new work, merge any open XS/S/M PRs with passing CI:
-
+Before picking new work, merge any open PRs with passing CI:
 ```bash
 gh pr list --json number,title,headRefName,statusCheckRollup --limit 20
 bash .claude/scripts/merge-pr.sh <N>
 gh issue close <issue-N> --comment "Closed by PR #<N>."
 ```
 
-## Step 2: Fill Empty Slots (up to 3 concurrent)
+Send Slack thread reply after each merge (best-effort).
 
-**Count current in-flight issues** — issues with `in-progress` + `claude` labels are occupied slots:
-```bash
-IN_FLIGHT=$(gh issue list --label in-progress --label claude --state open \
-  --json number --jq 'length' 2>/dev/null || echo "0")
-MAX_SLOTS=3
-OPEN_SLOTS=$(( MAX_SLOTS - IN_FLIGHT ))
-```
-
-If `OPEN_SLOTS <= 0` → no capacity, skip to Step 1 (merge/review only), then exit `WORKER_OK`.
+## Step 2: Read the Entire Backlog
 
+Fetch ALL ready issues — not just 3:
 ```bash
-gh issue list --label ready --state open --json number,title,labels,body --limit 10
+gh issue list --label ready --state open --json number,title,labels,body --limit 50
 ```
 
-**Filter out any issue carrying the `codex` label** — those are Codex territory. Do not claim them.
+Filter out any issue carrying the `codex` label. For each remaining issue, also check:
+- **Attempt count** — count `claudius:workpad` comments. If ≥ 3 attempts → mark `blocked`, skip.
+- **Recent PR guard** — if a PR for this issue was created in the last 6 hours → skip.
 
-If no ready issues after filtering → exit `WORKER_OK`.
+Read each issue's full body. You need the body to understand dependencies.
 
-Select up to **`OPEN_SLOTS`** highest-priority `ready` issues (without `codex` label) aligned with
-configured `goals`. Prefer smaller scope.
+## Step 3: Map Dependencies and Plan Waves
 
-Issues are filtered and scored with dependency awareness:
-- **Codex issues excluded** — any issue with the `codex` label is skipped entirely
-- **Blocked issues excluded** — any issue with open `blocked-by` relationships is removed from
-  candidates
-- **Recent PR guard** — any issue that already had a PR created in the last 6 hours is skipped,
-  even if the PR was closed. This prevents duplicate PRs from retry storms.
-- **Cluster momentum** — issues in partially-complete clusters get +15 priority boost
-- **Standard scoring** — label priorities, scope size, goal alignment
+Build a dependency graph from the issue bodies. Look for patterns like:
+- "Requires #N", "Blocked by #N", "Depends on #N", "After #N"
+- GitHub's `blocked-by` relationships (via `gh api`)
 
-**Check for recent PRs before claiming** — skip issues that already have PRs (open or recently closed):
-```bash
-for CANDIDATE in <issue-numbers>; do
-  RECENT_PR=$(gh pr list --repo "$(gh repo view --json nameWithOwner --jq '.nameWithOwner')" \
-    --search "Closes #$CANDIDATE in:body" --state all --json number,createdAt,state \
-    --jq "[.[] | select((.createdAt | fromdateiso8601) > (now - 21600))] | length" 2>/dev/null)
-  if [ "${RECENT_PR:-0}" -gt "0" ]; then
-    echo "Skipping #$CANDIDATE — PR created in last 6 hours"
-    continue
-  fi
-done
-```
+**Topologically sort** into execution waves:
+- **Wave 1** — issues with no unmet dependencies (or whose deps are already closed)
+- **Wave 2** — issues that depend only on Wave 1 issues
+- **Wave N** — issues that depend only on issues in earlier waves
 
-**Check attempt count before claiming** — count existing workpad comments to determine prior attempts:
+If an issue has a dependency on something not in the ready backlog and not closed,
+it's externally blocked — skip it, optionally mark `blocked`.
 
-```bash
-MAX_ATTEMPTS=3
-PRIOR_ATTEMPTS=$(gh api "repos/{owner}/{repo}/issues/<N>/comments" \
-  --jq '[.[] | select(.body | contains("claudius:workpad"))] | length' 2>/dev/null || echo "0")
-if [ "${PRIOR_ATTEMPTS:-0}" -ge "$MAX_ATTEMPTS" ]; then
-  gh issue edit <N> --remove-label "ready" --add-label "blocked"
-  gh issue comment <N> --body "Claudius: exceeded ${MAX_ATTEMPTS} build attempts. Needs human review before retrying."
-  bash .claude/scripts/project-status.sh <N> "Blocked" "Blocked"
-  # skip this issue — continue to next candidate
-fi
-```
+## Step 4: Execute Waves
 
-**Claim atomically** (add both `in-progress` and `claude` labels):
-```bash
-gh issue edit <N> --add-label "in-progress,claude" --remove-label "ready"
-gh issue view <N>   # read full body + acceptance criteria
-```
+Process waves sequentially. Within each wave, fire developers in parallel (max 3 concurrent).
 
-**Post workpad comment** — one-liner status at claim:
-```bash
-bash .claude/scripts/workpad-upsert.sh <N> "🔄 Claimed — attempt $(( ${PRIOR_ATTEMPTS:-0} + 1 ))"
-```
+For each wave:
+
+### 4a. Claim Issues
 
-**Update Project #6 board → In Progress / Running:**
+For each issue in the wave (up to 3 concurrent):
 ```bash
+gh issue edit <N> --add-label "in-progress,claude" --remove-label "ready"
+bash .claude/scripts/workpad-upsert.sh <N> "🔄 Claimed — wave <W>, attempt <A>"
 bash .claude/scripts/project-status.sh <N> "In Progress" "Running"
 ```
 
-## Step 3: Develop in Parallel
-
-**CRITICAL: One issue = one developer = one PR.** Never combine multiple issues into a single
-developer agent or a single PR. Each issue gets its own isolated developer in its own worktree.
-Violating this causes review failures, duplicate PRs, and retry storms.
-
-Each developer runs in its own isolated worktree. Do NOT derive or provide branch names.
+### 4b. Fire Developers
 
-**Read agent config** from `.claudius/config.yaml` (default: `claude`):
-```bash
-AGENT_COMMAND=$(bun -e "
-import { parse } from 'yaml';
-import { readFileSync } from 'fs';
-const c = parse(readFileSync('.claudius/config.yaml', 'utf8'));
-process.stdout.write(c.agent?.command ?? 'claude');
-" 2>/dev/null || echo 'claude')
-```
+Read `agent.command` from `.claudius/config.yaml` (default: `claude`).
 
-**If `AGENT_COMMAND = "claude"` (default):**
-Spawn **exactly one** developer agent per issue using the `Agent` tool **concurrently**
-(all in one tool call message), using `subagent_type: "developer"`.
-Each agent handles ONE issue only — never pass multiple issues to the same agent.
+Spawn **one developer per issue** using the `Agent` tool **concurrently** (all in one
+tool call), using `subagent_type: "developer"`. Each developer gets:
+- Full issue body and acceptance criteria
+- Issue number for commit format (`type(scope): description (#N)`)
+- Constraint: implement only what the issue asks, no scope creep
+- Instruction: use your current branch (the worktree branch), commit, push with
+  `git push -u origin HEAD`, report branch name. Do NOT create a PR.
+- Request: include a **handoff summary** (what was built, how to test, AC coverage)
 
-**If `AGENT_COMMAND = "codex"`:**
-Spawn via Bash: `codex -p --model <agent.model> <agent.flags> "<prompt>" &` — one per issue.
+**CRITICAL: One issue = one developer = one PR.** Never combine issues.
 
-For each issue, each developer prompt must include:
-- Full issue body and all acceptance criteria
-- Issue number for commit message format (`type(scope): description (#N)`)
-- Constraint: implement only what the issue asks, no scope creep
-- Instruction: use your current branch (the worktree branch), do NOT create a new branch.
-  Implement, commit, push with `git push -u origin HEAD`, then report the branch name you
-  pushed. Do not create the PR (worker creates PRs).
-- In your final output, include a structured **handoff summary** (what was built, how to test,
-  AC coverage) so the worker can post it to the PR and update the workpad.
+### 4c. Process Completions Immediately
 
-Wait for all developer agents to complete before proceeding.
+As each developer completes (don't wait for all in the wave):
 
-**On developer failure for an issue:**
+**On failure:** Restore labels, comment, continue with rest of wave.
 ```bash
 gh issue edit <N> --remove-label "in-progress,claude" --add-label "ready"
 gh issue comment <N> --body "Worker: developer failed. Restored to ready queue."
 ```
-Remove it from the active set and continue with the rest.
-
-## Step 4: Validate & Create PRs
-
-For each successful developer result, **validate before creating the PR**.
-
-**Pre-PR validation** — check the developer's branch in its worktree:
-```bash
-cd <worktree-path>
-bun run lint 2>&1 | tail -5
-bun run build 2>&1 | tail -5
-```
-If lint or build fails: re-spawn the developer with the errors and ask it to fix them.
-Only create the PR once validation passes. Never create a PR with known lint/build failures.
 
-```bash
-gh pr create \
-  --head <branch-from-developer-output> \
-  --title "type(scope): description (#N)" \
-  --body "$(cat <<'EOF'
-## Summary
-- <bullet from developer output>
-
-## Closes
-Closes #N
-
-## Test Plan
-- [ ] <scenario>
-EOF
-)"
-```
+**On success:** Validate → PR → Review → Merge, then cascade.
 
-**Post handoff comment** — after each `gh pr create`, add a structured handoff to the PR
-using the `<!-- claudius:handoff -->` marker (pull content from developer's handoff summary):
+1. **Validate** — check developer's branch in its worktree:
+   ```bash
+   cd <worktree-path>
+   bun run lint 2>&1 | tail -5
+   bun run build 2>&1 | tail -5
+   ```
+   If lint/build fails: re-spawn developer with errors to fix. Only proceed when clean.
 
-```bash
-gh pr comment <PR> --body "$(cat <<'EOF'
-<!-- claudius:handoff -->
-**Handoff** · PR ready for review
-**What changed:** <from developer handoff summary>
-**How to test:** <from developer handoff summary>
-**AC coverage:** ✅ all / ⚠️ partial / ❌ gap noted
-**Notes:** <any gaps, follow-ups created>
-EOF
-)"
-```
+2. **Create PR:**
+   ```bash
+   gh pr create --head <branch> --title "type(scope): description (#N)" --body "..."
+   ```
+   Post handoff comment (`<!-- claudius:handoff -->`).
+   Send Slack notification (best-effort).
+   Update board:
+   ```bash
+   bash .claude/scripts/workpad-upsert.sh <N> "🔍 Under review — PR #<M>"
+   bash .claude/scripts/project-status.sh <N> "Under Review" "Review"
+   ```
 
-After each `gh pr create`, send a Slack notification (best-effort — never block on failure):
-```bash
-SLACK_CHANNEL=$(bun -e "
-import { parse } from 'yaml';
-import { readFileSync } from 'fs';
-const c = parse(readFileSync('.claudius/config.yaml', 'utf8'));
-process.stdout.write(c.slack?.channel ?? '');
-" 2>/dev/null)
-if [ -n "$SLACK_CHANNEL" ]; then
-  PR_TITLE=$(gh pr view $PR_NUMBER --json title --jq '.title')
-  PR_URL=$(gh pr view $PR_NUMBER --json url --jq '.url')
-  THREAD_REF=$(bun .claude/scripts/slack.ts send \
-    --channel "$SLACK_CHANNEL" \
-    --text "🔍 *PR #$PR_NUMBER ready for review* — $PR_TITLE  $PR_URL" | tail -1) \
-    && printf '<!-- slack-thread: %s -->' "$THREAD_REF" | gh pr comment $PR_NUMBER --body-file - \
-    || true
-fi
-```
+3. **Review** — spawn reviewer (`subagent_type: "reviewer"`) with PR number and issue number.
+   - `approve` → merge
+   - `request-changes` → re-spawn developer once with feedback, then re-review. Still failing → `block`
+   - `block` → restore labels, comment with reason
 
-**Update workpad + board → Under Review / Review:**
-```bash
-bash .claude/scripts/workpad-upsert.sh <N> "🔍 Under review — PR #<M>"
-bash .claude/scripts/project-status.sh <N> "Under Review" "Review"
-```
-
-## Step 5: Review in Parallel
-
-Spawn one reviewer agent per PR using the `Agent` tool **concurrently** (all in one message).
-
-For each PR, use `subagent_type: "reviewer"`. Each reviewer prompt must include:
-- PR number to review
-- Issue number for AC verification
-- Return structured verdict: `approve` / `request-changes` / `block`
-
-Wait for all reviewer agents to complete.
+4. **Merge:**
+   ```bash
+   bash .claude/scripts/merge-pr.sh <PR-number>
+   gh issue close <N> --comment "Closed by PR #<M>."
+   bash .claude/scripts/workpad-upsert.sh <N> "✅ Merged — PR #<M>"
+   ```
+   Send Slack thread reply (best-effort).
+   Log outcome to `.claudius/daemon-state.md` (appended by the scheduler).
 
-**On `approve`:** proceed to merge (Step 6).
+5. **Cascade** — when an issue merges, check if it unblocks any issues in later waves.
+   If so, fire those developers immediately (respecting max 3 concurrent). Don't wait
+   for the rest of the current wave to finish.
 
-**On `request-changes`:** re-spawn the developer for that issue with reviewer feedback
-(max 1 retry). After retry: push, update PR, re-spawn reviewer. If still `request-changes`
-→ treat as `block`.
+### 4d. Heartbeat
 
-**On `block`:** restore labels, comment with reviewer's reason, skip to next.
-```bash
-gh issue edit <N> --remove-label "in-progress,claude" --add-label "ready"
-gh issue comment <N> --body "Worker: reviewer blocked. Reason: <reason>."
-```
+After processing each wave, update the heartbeat timestamp in `active-builds.jsonl`.
+If total runtime exceeds 60 minutes, drain active work (let in-flight developers finish)
+but don't start new issues. Exit after draining.
 
-**Update board → Blocked:**
-```bash
-bash .claude/scripts/project-status.sh <N> "Blocked" "Blocked"
-```
+## Cleanup
 
-## Step 6: Merge & Record
+After all waves are processed (or timeout reached):
 
-For each approved PR:
-```bash
-bash .claude/scripts/merge-pr.sh <PR-number>
-gh issue close <N> --comment "Closed by PR #<M>."
-```
-
-**Update workpad + close issue** (closing removes it from the board via project-sync):
-```bash
-bash .claude/scripts/workpad-upsert.sh <N> "✅ Merged — PR #<M>"
-```
-
-After each merge, reply in the PR's Slack thread (best-effort):
-```bash
-THREAD_REF=$(gh pr view $PR_NUMBER --json comments \
-  --jq '[.comments[].body | select(contains("slack-thread:"))] | first' \
-  | grep -oE '[A-Z][A-Z0-9]{8,}:[0-9]+\.[0-9]+')
-if [ -n "$THREAD_REF" ] && [ "$THREAD_REF" != "null" ]; then
-  bun .claude/scripts/slack.ts reply \
-    --thread "$THREAD_REF" \
-    --text "✅ Merged PR #$PR_NUMBER" 2>/dev/null || true
-fi
-```
-
-Append one line per merged issue to `.claude/memory/pulse.md` under `## Recent Build Outcomes`:
-```
-- 2026-03-03: built #N → PR#M merged (Xs)
-```
-
----
-
-## Step 7: Cleanup
-
-After all merges, remove stale agent sub-worktrees (best-effort):
 ```bash
+# Remove stale worktrees
 git worktree list --porcelain | grep '^worktree' | grep 'agent-' | awk '{print $2}' | while read p; do
-  git worktree remove --force "$p" 2>/dev/null && echo "Removed $p" || true
+  git worktree remove --force "$p" 2>/dev/null || true
 done
-```
 
-**Remove this repo's active-builds.jsonl entry** — the global dir was passed in the prompt as `Global dir: <path>`. Extract and clean up:
-```bash
-GLOBAL_DIR="<path-from-prompt>"   # absolute global dir path from the worker prompt
-REPO_NAME="<this-repo-name>"       # the repo name sleepless used in the entry
+# Remove active-builds entry
+GLOBAL_DIR="<path-from-prompt>"
+REPO_NAME="<this-repo>"
 node -e "
 const fs = require('fs');
-const path = require('path');
-const file = path.join('$GLOBAL_DIR', '.claudius/active-builds.jsonl');
-if (!fs.existsSync(file)) process.exit(0);
-const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean);
-const kept = lines.filter(l => {
-  try { return JSON.parse(l).repo !== '$REPO_NAME'; } catch { return true; }
-});
-fs.writeFileSync(file, kept.join('\n') + (kept.length ? '\n' : ''));
+const f = '$GLOBAL_DIR/.claudius/active-builds.jsonl';
+if (!fs.existsSync(f)) process.exit(0);
+const lines = fs.readFileSync(f,'utf8').split('\n').filter(Boolean);
+const kept = lines.filter(l => { try { return JSON.parse(l).repo !== '$REPO_NAME'; } catch { return true; } });
+fs.writeFileSync(f, kept.join('\n') + (kept.length ? '\n' : ''));
 " 2>/dev/null || true
 ```
 
-Exit with `WORKER_OK`.
-
----
+Exit `WORKER_OK`.
 
 ## Headless Execution Notes
 
 - Never use `EnterPlanMode`, `ExitPlanMode`, or `AskUserQuestion` — no human present
 - Never provide branch names to developers — they run in isolated worktrees
-- Skip any issue with the `codex` label — that's Codex territory
+- Skip any issue with the `codex` label — Codex territory
 - Always restore both `in-progress` AND `claude` labels on failure/block
-- Exit with `WORKER_OK` when the cycle completes (0 or up to OPEN_SLOTS issues processed)
 - On unrecoverable error per issue: restore labels, comment, continue — never abort the whole run
+- Max 3 concurrent developers at any time — this is a slot limit, not a batch size
+- 60-minute safety timeout — drain active work, then exit

package/.claude/hooks/continue-or-stop.ts

@@ -6,7 +6,7 @@
  *   1. Ready issues exist → /build #N
  *   2. No ready issues → check session-state.md Next Actions
  *   3. No session actions → check open backlog (any open issues)
- *   4. Empty backlog → Slack owner if configured, else suggest /pulse
+ *   4. Empty backlog → Slack owner if configured, else suggest /backlog --ideate
  *   5. Always exit 2 — never silently stop and never ask the user
  *
  * Exit codes:
@@ -27,7 +27,7 @@ interface Issue {
 }
 
 function getConsecutiveFailures(projectDir: string): number {
-	const statePath = resolve(projectDir, ".claudius/pulse-state.md");
+	const statePath = resolve(projectDir, ".claudius/daemon-state.md");
 	if (!existsSync(statePath)) return 0;
 	const content = readFileSync(statePath, "utf-8");
 	const match = content.match(/Consecutive failures:\s*(\d+)/);
@@ -170,7 +170,7 @@ async function main() {
 		);
 	}
 
-	// 4. Backlog empty — Slack owner or suggest /pulse
+	// 4. Backlog empty — Slack owner or suggest /backlog --ideate
 	const slackUserId = getSlackUserId(projectDir);
 	if (slackUserId) {
 		await sendSlackMessage(
@@ -180,7 +180,7 @@ async function main() {
 		block(
 			[
 				"Backlog is empty. Sent Slack message to owner for next direction.",
-				"Run /pulse to check for any background ideation or triage work.",
+				"Run /backlog --ideate to check for background ideation or triage work.",
 			].join("\n"),
 		);
 	}
@@ -188,7 +188,7 @@ async function main() {
 	block(
 		[
 			"Backlog is empty. Options:",
-			"  1. Run /pulse — scan for ideation, memory gaps, or triage work",
+			"  1. Run /backlog --ideate — scan for ideation, memory gaps, or triage work",
 			"  2. Run /backlog — identify and create new issues from current goals",
 			"  3. If truly nothing to do, respond: 'All work complete. Backlog is empty.'",
 		].join("\n"),

package/.claude/rules/claudius.md

@@ -52,17 +52,16 @@ Use claudius skills instead of doing things manually:
 - After `/clear` or new session: read session-state.md, config.yaml goals, then resume.
 - Don't ask "what should I do next?" — check goals and backlog, pick the highest priority.
 
-## Pulse (Autonomous Work)
+## Daemon & Jobs
 
-The pulse system enables continuous autonomous development.
+The daemon runs scheduled jobs from `.claudius/jobs/`. Worker agents handle autonomous builds.
 
-- **`/pulse`** — show status (ready issues, open PRs, budget).
-- **`/pulse run`** — execute one heartbeat: check constraints → pick a `ready` issue → `/build` it.
-- **`/pulse ideate`** — brainstorm improvements from goals and codebase, create issues.
-- **`claudius daemon`** — runs pulse on a timer (config: `pulse.intervalMinutes`, `pulse.activeHours`).
-- Always check budget (`autonomy.budgetCapUsd`) and active hours before autonomous work.
-- Respect `pulse.requireApprovalFor` — some actions (merge, deploy) may need human sign-off.
-- On 3 consecutive failures, pause and escalate (`pulse.pauseOnFailure`).
+- **`claudius daemon`** — preflight health dashboard
+- **`claudius daemon start`** — start the scheduler daemon (runs cron jobs)
+- **`claudius jobs`** — list all jobs with schedule and status
+- **`claudius jobs run <name>`** — trigger a specific job immediately
+
+Config: `daemon:` section in `.claudius/config.yaml` controls enabled, activeHours, budget, etc.
 
 ## What to Commit
 
@@ -87,8 +86,8 @@ Commit everything `claudius init` distributes — skills, rules, hooks, agents,
 | Command | Purpose |
 |---------|---------|
 | `claudius init` | Initialize project for claudius |
-| `claudius daemon` | Start autonomous pulse daemon |
-| `claudius pulse` | Manual pulse trigger |
+| `claudius daemon` | Preflight health dashboard |
+| `claudius daemon start` | Start the scheduler daemon |
 | `claudius status` | Show project status |
 | `claudius jobs` | Manage background jobs |
 | `claudius scope` | Classify issue scope (XS/S/M/L/XL) |

package/.claude/skills/backlog/SKILL.md

@@ -142,9 +142,7 @@ Comprehensive backlog health check across all open issues.
 - Posts findings as comments on affected issues
 - Outputs a health summary
 
-**Update `.claude/memory/pulse.md` after grooming:**
-1. Rewrite **Queue** — cluster ready issues by theme/dependency, note sequencing rationale
-2. Append to **Grooming Log**: `### <date> — groom-backlog\n- <summary of changes and key findings>`
+**After grooming, update `.claudius/session-state.md`** with a summary of changes and key findings.
 
 #### `--check-stale`: Staleness Detection
 
@@ -193,7 +191,7 @@ The `ready` label is the contract between `/backlog` and `/build`. It means:
 - Native GitHub relationships are wired (sub-issue of epic, blocked-by dependencies)
 - A human approved the work item
 
-`/build` only picks up `ready` items. `/pulse` only delegates `ready` items. This gate ensures autonomous agents execute pre-approved plans, not make design decisions on the fly.
+`/build` only picks up `ready` items. The daemon only runs `ready` items. This gate ensures autonomous agents execute pre-approved plans, not make design decisions on the fly.
 
 ## GitHub Relationship Script Reference
 

package/.claude/skills/build/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Autonomous implementation — picks up `ready`-labeled work items and builds them.
   Reads the work item, implements with TDD, creates PR, runs review gate, merges.
   No planning or design decisions — those are settled upstream by /backlog.
-  Can be delegated to /pulse for autonomous execution.
+  Can be delegated to the daemon for autonomous execution.
   Triggers on: "build this", "implement this issue", "/build", "start building",
   "pick up the next task", "implement #N".
   This is Stage 5 of the development lifecycle (/product → /solution → /design → /spec → /backlog → /build).
@@ -17,7 +17,7 @@ Pure executor. Picks up `ready`-labeled work items and builds them. No explorati
 
 This is **Stage 5** of the development lifecycle (/product → /solution → /design → /spec → /backlog → /build). It reads work items from `/backlog` (Stage 4) and produces branches, PRs, and merged code.
 
-Because `/build` makes no design decisions, it can be delegated to `/pulse` for autonomous execution.
+Because `/build` makes no design decisions, it can be delegated to the daemon for autonomous execution.
 
 ## Usage
 ```