@gonzih/cc-agent 0.2.4 → 0.3.0

package/README.md

@@ -1,5 +1,7 @@
 # cc-agent
 
+[![npm version](https://img.shields.io/npm/v/@gonzih/cc-agent?label=@gonzih/cc-agent)](https://www.npmjs.com/package/@gonzih/cc-agent)
+
 MCP server for spawning Claude Code agents in GitHub repos. Give Claude Code the ability to **branch itself** — clone a repo and kick off a sub-agent to work on it autonomously, with persistent state across MCP restarts.
 
 Built by [@Gonzih](https://github.com/Gonzih).
@@ -16,33 +18,81 @@ CLAUDE_CODE_OAUTH_TOKEN=sk-ant-oat01-...   # OAuth token (recommended)
 ANTHROPIC_API_KEY=sk-ant-api03-...         # API key
 ```
 
-Restart Claude Code. You now have 7 new MCP tools.
+Restart Claude Code. You now have 13 new MCP tools.
 
 ## MCP Tools
 
 | Tool | Description |
 |------|-------------|
 | `spawn_agent` | Clone a repo, optionally create a branch, run Claude Code on a task |
-| `list_jobs` | List all jobs with status, recent tool calls, and exit info |
 | `get_job_status` | Check status of a specific job |
 | `get_job_output` | Stream output lines from a job (supports offset for tailing) |
+| `list_jobs` | List all jobs with status, recent tool calls, and exit info |
 | `cancel_job` | Kill a running job |
 | `send_message` | Write a message to a running agent's stdin mid-task |
+| `cost_summary` | Total USD cost across all jobs, broken down by repo |
 | `get_version` | Return the running cc-agent version |
+| `create_plan` | Spawn a dependency graph of agent jobs in one call |
+| `create_profile` | Save a named spawn config for repeated use with `{{variable}}` templates |
+| `list_profiles` | List all saved profiles |
+| `delete_profile` | Delete a named profile |
+| `spawn_from_profile` | Spawn a job from a saved profile with variable interpolation |
 
 ## spawn_agent parameters
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
-| `repo_url` | string | yes | Git repo to clone (HTTPS) |
+| `repo_url` | string | yes | Git repo to clone (HTTPS or SSH) |
 | `task` | string | yes | Task prompt for Claude Code |
 | `branch` | string | no | Existing branch to check out after clone |
 | `create_branch` | string | no | New branch to create (e.g. `feat/my-feature`) |
 | `claude_token` | string | no | Per-job token override |
 | `continue_session` | boolean | no | Pass `--continue` to resume last Claude session in workdir |
-| `max_budget_usd` | number | no | Spend cap in USD (default: 20). Prevents runaway costs |
+| `max_budget_usd` | number | no | Spend cap in USD (default: 20) |
+| `session_id` | string | no | Session ID from a prior job's `sessionIdAfter` — resumes that session |
+| `depends_on` | string[] | no | Job IDs that must be `done` before this job starts (queued as `pending`) |
+
+## create_plan parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `goal` | string | yes | High-level description of what this plan achieves |
+| `steps` | array | yes | Ordered list of steps to execute |
 
-## Usage example
+Each step in `steps`:
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `id` | string | yes | Logical step ID (used for `depends_on` references within the plan) |
+| `repo_url` | string | yes | Git repo to clone |
+| `task` | string | yes | Task prompt for Claude Code |
+| `create_branch` | string | no | New branch to create before running |
+| `depends_on` | string[] | no | Step IDs from this plan that must complete first |
+
+## create_profile parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `name` | string | yes | Profile name (alphanumeric, dashes, underscores) |
+| `repo_url` | string | yes | Git repo to clone |
+| `task_template` | string | yes | Task template — use `{{varName}}` for substitution |
+| `default_budget_usd` | number | no | Default USD budget for jobs from this profile |
+| `branch` | string | no | Branch to check out after cloning |
+| `description` | string | no | Human-readable profile description |
+
+## spawn_from_profile parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `profile_name` | string | yes | Name of the saved profile to use |
+| `vars` | object | no | Variables to interpolate into the task template |
+| `task_override` | string | no | Use this task instead of the profile template |
+| `branch_override` | string | no | Override the profile's branch |
+| `budget_override` | number | no | Override the profile's default budget |
+
+## Usage examples
+
+### Basic agent
 
 ```
 spawn_agent({
@@ -60,19 +110,114 @@ get_job_output({ job_id: "abc-123", offset: 0 })
 // → { lines: ["[cc-agent] Cloning...", "Reading src/api.ts...", ...], done: false }
 
 send_message({ job_id: "abc-123", message: "Also update the tests." })
-// → { ok: true }
+// → { sent: true }
+
+cost_summary()
+// → { totalJobs: 1, totalCostUsd: 1.23, byRepo: { "https://github.com/...": 1.23 } }
 ```
 
-## Persistent job storage
+### Multi-step plan with dependencies
+
+```
+create_plan({
+  goal: "Refactor auth and update docs",
+  steps: [
+    {
+      id: "refactor",
+      repo_url: "https://github.com/yourorg/app",
+      task: "Refactor auth middleware to use JWT. Open a PR.",
+      create_branch: "feat/jwt-auth"
+    },
+    {
+      id: "docs",
+      repo_url: "https://github.com/yourorg/app",
+      task: "Update README to document the new JWT auth flow.",
+      create_branch: "docs/jwt-auth",
+      depends_on: ["refactor"]
+    }
+  ]
+})
+// → { goal: "...", totalSteps: 2, steps: [{ stepId: "refactor", jobId: "abc-1", status: "cloning" }, { stepId: "docs", jobId: "abc-2", status: "pending" }] }
+```
 
-Job state is persisted to `<cwd>/.cc-agent/` across MCP server restarts:
+### Profiles for repeated tasks
 
-- `.cc-agent/jobs.json` — full job metadata (status, exit code, PID, params)
+```
+// Save once:
+create_profile({
+  name: "fix-issue",
+  repo_url: "https://github.com/yourorg/app",
+  task_template: "Fix issue #{{issue}}: {{title}}. Open a PR when done.",
+  default_budget_usd: 5
+})
+
+// Use many times:
+spawn_from_profile({
+  profile_name: "fix-issue",
+  vars: { issue: "42", title: "Login broken on mobile" }
+})
+```
+
+### Resume a prior session
+
+```
+// Get session ID from a completed job:
+get_job_status({ job_id: "abc-123" })
+// → { ..., session_id_after: "ses_xyz" }
+
+// Resume it:
+spawn_agent({
+  repo_url: "https://github.com/yourorg/app",
+  task: "Continue where you left off — finish the tests.",
+  session_id: "ses_xyz"
+})
+```
+
+## Persistence
+
+cc-agent v0.3.0+ stores all job state in **Redis**, which is auto-provisioned on startup — zero configuration needed.
+
+### Auto-provisioning
+
+On startup, cc-agent tries to connect to Redis at `localhost:6379`. If unavailable:
+
+1. **Docker** — runs `docker run -d --name cc-agent-redis -p 6379:6379 --restart=unless-stopped redis:alpine`
+2. **redis-server** — if `redis-server` is on PATH, spawns it as a daemon
+3. **In-memory fallback** — logs a warning and continues; jobs are not persisted across restarts
+
+Once Redis is available, all job state, output, profiles, and plans survive MCP server restarts and are **shared across all Claude Code sessions** pointing at the same Redis instance.
+
+### Key schema
+
+| Key | Type | TTL | Contents |
+|-----|------|-----|----------|
+| `cca:job:<id>` | String (JSON) | 7 days | Full job record |
+| `cca:jobs:index` | List | — | Job IDs, newest first (capped at 500) |
+| `cca:job:<id>:output` | List | 7 days | Output lines (one entry per line) |
+| `cca:plan:<id>` | String (JSON) | 30 days | Plan record with step→job mapping |
+| `cca:profile:<name>` | String (JSON) | permanent | Profile config |
+| `cca:profiles:index` | Set | permanent | All profile names |
+
+### Disk fallback
+
+When Redis is unavailable, cc-agent falls back to the original disk-based storage:
+
+- `.cc-agent/jobs.json` — job metadata
 - `.cc-agent/jobs/<id>.log` — per-job output log
+- `~/.cc-agent/profiles.json` — profiles
+
+Existing disk profiles are automatically migrated to Redis on first startup with Redis available.
 
-On restart, jobs whose processes are still alive are recovered as `running`. Dead PIDs are marked `failed` automatically. This means **you don't lose job history if the MCP server restarts**.
+## Job statuses
 
-`.cc-agent/` is gitignored automatically.
+| Status | Meaning |
+|--------|---------|
+| `pending` | Waiting for `depends_on` jobs to complete |
+| `cloning` | Cloning the repo |
+| `running` | Claude Code is running |
+| `done` | Completed successfully |
+| `failed` | Exited with an error (check `error` field) |
+| `cancelled` | Cancelled by `cancel_job` |
 
 ## Tool call visibility
 
@@ -127,12 +272,14 @@ npm version patch && npm publish   # if it's a library
 6. Tool calls are captured from the stream-JSON and stored in `tool_calls[]`
 7. On exit: job marked done/failed, workdir cleaned up after 10 minutes
 8. Jobs expire from memory after 1 hour (log file remains on disk)
+9. Pending jobs are promoted automatically every 3 seconds when their dependencies complete
 
 ## Environment variables
 
 | Variable | Description |
 |----------|-------------|
-| `CLAUDE_CODE_OAUTH_TOKEN` | Claude OAuth token (recommended) |
+| `CLAUDE_CODE_TOKEN` | Claude OAuth token or Anthropic API key |
+| `CLAUDE_CODE_OAUTH_TOKEN` | Claude OAuth token (alternative) |
 | `ANTHROPIC_API_KEY` | Anthropic API key (alternative) |
 
 ## Requirements

package/dist/agent.d.ts

@@ -3,20 +3,24 @@ export declare class JobManager {
     private jobs;
     private kills;
     private defaultToken?;
-    private diskLoadedJobs;
+    /** Jobs restored from storage — their output lives in store, not in job.output[]. */
+    private restoredJobs;
     constructor(token?: string);
-    private loadFromDisk;
-    private checkDiskLoadedRunning;
+    /** Must be called after initRedis() at startup. */
+    init(): Promise<void>;
+    private checkRestoredRunning;
     private persistJob;
     private addOutput;
     spawn(opts: SpawnOptions): Promise<string>;
     private run;
+    private tick;
+    private promote;
     getJob(id: string): Job | undefined;
-    getOutput(id: string, offset?: number): {
+    getOutput(id: string, offset?: number): Promise<{
         lines: string[];
         done: boolean;
         toolCalls: string[];
-    };
+    }>;
     list(): JobSummary[];
     sendMessage(id: string, message: string): {
         ok: boolean;

package/dist/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AA+BhE,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,cAAc,CAAqB;gBAE/B,KAAK,CAAC,EAAE,MAAM;IAU1B,OAAO,CAAC,YAAY;IAoDpB,OAAO,CAAC,sBAAsB;IAgB9B,OAAO,CAAC,UAAU;IA+BlB,OAAO,CAAC,SAAS;IAKX,KAAK,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;YA8BlC,GAAG;IA+GjB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS;IAInC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE;IAe1F,IAAI,IAAI,UAAU,EAAE;IAuBpB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;IAWzE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAkB3B,OAAO,CAAC,OAAO;CAahB"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AA4EhE,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,qFAAqF;IACrF,OAAO,CAAC,YAAY,CAAqB;gBAE7B,KAAK,CAAC,EAAE,MAAM;IAW1B,mDAAmD;IAC7C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkC3B,OAAO,CAAC,oBAAoB;IAgB5B,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,SAAS;IAKX,KAAK,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;YAsClC,GAAG;IAwGjB,OAAO,CAAC,IAAI;IAoBZ,OAAO,CAAC,OAAO;IASf,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS;IAI7B,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAazG,IAAI,IAAI,UAAU,EAAE;IAuBpB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;IAWzE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAkB3B,OAAO,CAAC,OAAO;CAahB"}

package/dist/agent.js

@@ -5,9 +5,10 @@ import { join } from "path";
 import { promisify } from "util";
 import { v4 as uuidv4 } from "uuid";
 import { runClaude } from "./claude.js";
-import { ensureStateDirs, loadPersistedJobs, savePersistedJobs, appendLog, readLogSync, isPidAlive, } from "./state.js";
+import { ensureStateDirs, isPidAlive } from "./state.js";
+import { jobStore } from "./store.js";
 const execFileAsync = promisify(execFile);
-const JOB_TTL_MS = 60 * 60 * 1000; // 1 hour — clean up old done jobs
+const JOB_TTL_MS = 60 * 60 * 1000; // 1 hour — clean up old done jobs from memory
 // Claude Sonnet 4.6 pricing (USD per 1M tokens)
 const PRICE_INPUT = 3.00;
 const PRICE_OUTPUT = 15.00;
@@ -21,30 +22,83 @@ function calculateCost(job) {
         1_000_000;
     return Math.round(cost * 10000) / 10000;
 }
+function toRecord(job) {
+    return {
+        id: job.id,
+        status: job.status,
+        repoUrl: job.repoUrl,
+        task: job.task,
+        branch: job.branch,
+        createBranch: job.createBranch,
+        dependsOn: job.dependsOn,
+        startedAt: job.startedAt.toISOString(),
+        finishedAt: job.finishedAt?.toISOString(),
+        exitCode: job.exitCode,
+        error: job.error,
+        pid: job.pid,
+        sessionIdAfter: job.sessionIdAfter,
+        usage: job.usage,
+        totalInputTokens: job.totalInputTokens,
+        totalOutputTokens: job.totalOutputTokens,
+        totalCacheReadTokens: job.totalCacheReadTokens,
+        totalCacheWriteTokens: job.totalCacheWriteTokens,
+        costUsd: job.costUsd,
+        recentTools: job.toolCalls.slice(-10),
+        outputLineCount: job.output.length,
+    };
+}
+function fromRecord(r) {
+    return {
+        id: r.id,
+        repoUrl: r.repoUrl,
+        task: r.task,
+        branch: r.branch,
+        createBranch: r.createBranch,
+        status: r.status,
+        output: [],
+        toolCalls: r.recentTools ?? [],
+        exitCode: r.exitCode,
+        error: r.error,
+        startedAt: new Date(r.startedAt ?? Date.now()),
+        finishedAt: r.finishedAt ? new Date(r.finishedAt) : undefined,
+        pid: r.pid,
+        sessionIdAfter: r.sessionIdAfter,
+        usage: r.usage,
+        totalInputTokens: r.totalInputTokens,
+        totalOutputTokens: r.totalOutputTokens,
+        totalCacheReadTokens: r.totalCacheReadTokens,
+        totalCacheWriteTokens: r.totalCacheWriteTokens,
+        costUsd: r.costUsd,
+        dependsOn: r.dependsOn,
+    };
+}
 export class JobManager {
     jobs = new Map();
     kills = new Map();
     defaultToken;
-    diskLoadedJobs = new Set();
+    /** Jobs restored from storage — their output lives in store, not in job.output[]. */
+    restoredJobs = new Set();
     constructor(token) {
         this.defaultToken = token;
         ensureStateDirs();
-        this.loadFromDisk();
         // Periodic cleanup of old finished jobs
         setInterval(() => this.cleanup(), 5 * 60 * 1000).unref();
-        // Periodic check for disk-loaded running jobs whose PID may have died
-        setInterval(() => this.checkDiskLoadedRunning(), 30 * 1000).unref();
+        // Periodic check for restored running jobs whose PID may have died
+        setInterval(() => this.checkRestoredRunning(), 30 * 1000).unref();
+        // Dependency scheduler — promote pending jobs when deps are done
+        setInterval(() => this.tick(), 3000).unref();
     }
-    loadFromDisk() {
-        const persisted = loadPersistedJobs();
-        const updated = [];
-        for (const p of persisted) {
-            let status = p.status;
-            let error = p.error;
-            let finishedAt = p.finishedAt;
+    /** Must be called after initRedis() at startup. */
+    async init() {
+        const records = await jobStore.loadAll();
+        const updates = [];
+        for (const r of records) {
+            let status = r.status;
+            let error = r.error;
+            let finishedAt = r.finishedAt;
             if (status === "running" || status === "cloning") {
-                if (p.pid && isPidAlive(p.pid)) {
-                    // Still alive — keep as running, output reads from disk log
+                if (r.pid && isPidAlive(r.pid)) {
+                    // Process still alive — keep as running
                 }
                 else {
                     status = "failed";
@@ -52,38 +106,20 @@ export class JobManager {
                     finishedAt = finishedAt ?? new Date().toISOString();
                 }
             }
-            const job = {
-                id: p.id,
-                repoUrl: p.repoUrl,
-                task: p.task,
-                branch: p.branch,
-                createBranch: p.createBranch,
-                status,
-                output: [],
-                toolCalls: [],
-                exitCode: p.exitCode,
-                error,
-                startedAt: new Date(p.startedAt),
-                finishedAt: finishedAt ? new Date(finishedAt) : undefined,
-                pid: p.pid,
-                sessionIdAfter: p.sessionIdAfter,
-                usage: p.usage,
-                totalInputTokens: p.totalInputTokens,
-                totalOutputTokens: p.totalOutputTokens,
-                totalCacheReadTokens: p.totalCacheReadTokens,
-                totalCacheWriteTokens: p.totalCacheWriteTokens,
-                costUsd: p.costUsd,
-            };
+            const job = fromRecord({ ...r, status, error, finishedAt });
             this.jobs.set(job.id, job);
-            this.diskLoadedJobs.add(job.id);
-            updated.push({ ...p, status, error, finishedAt });
+            this.restoredJobs.add(job.id);
+            if (status !== r.status) {
+                updates.push({ ...r, status, error, finishedAt });
+            }
         }
-        if (updated.length > 0) {
-            savePersistedJobs(updated);
+        // Persist any status corrections back to store
+        for (const updated of updates) {
+            jobStore.saveJob(updated).catch(() => { });
         }
     }
-    checkDiskLoadedRunning() {
-        for (const id of this.diskLoadedJobs) {
+    checkRestoredRunning() {
+        for (const id of this.restoredJobs) {
             const job = this.jobs.get(id);
             if (!job)
                 continue;
@@ -93,48 +129,25 @@ export class JobManager {
                     job.finishedAt = new Date();
                     job.error = (job.error ? job.error + "; " : "") + "Process exited after MCP restart";
                     this.persistJob(job);
-                    appendLog(job.id, "[cc-agent] Process no longer alive after MCP restart");
+                    this.addOutput(job, "[cc-agent] Process no longer alive after MCP restart");
                 }
             }
         }
     }
     persistJob(job) {
-        const persisted = loadPersistedJobs();
-        const entry = {
-            id: job.id,
-            status: job.status,
-            repoUrl: job.repoUrl,
-            task: job.task,
-            branch: job.branch,
-            createBranch: job.createBranch,
-            startedAt: job.startedAt.toISOString(),
-            finishedAt: job.finishedAt?.toISOString(),
-            exitCode: job.exitCode,
-            error: job.error,
-            pid: job.pid,
-            sessionIdAfter: job.sessionIdAfter,
-            usage: job.usage,
-            totalInputTokens: job.totalInputTokens,
-            totalOutputTokens: job.totalOutputTokens,
-            totalCacheReadTokens: job.totalCacheReadTokens,
-            totalCacheWriteTokens: job.totalCacheWriteTokens,
-            costUsd: job.costUsd,
-        };
-        const idx = persisted.findIndex((p) => p.id === job.id);
-        if (idx >= 0) {
-            persisted[idx] = entry;
-        }
-        else {
-            persisted.push(entry);
-        }
-        savePersistedJobs(persisted);
+        jobStore.saveJob(toRecord(job)).catch(() => { });
     }
     addOutput(job, line) {
         job.output.push(line);
-        appendLog(job.id, line);
+        jobStore.appendOutput(job.id, line).catch(() => { });
     }
     async spawn(opts) {
         const id = uuidv4();
+        const pendingDeps = opts.dependsOn?.filter((depId) => {
+            const dep = this.jobs.get(depId);
+            return dep?.status !== "done";
+        });
+        const isPending = pendingDeps && pendingDeps.length > 0;
         const job = {
             id,
             repoUrl: opts.repoUrl,
@@ -144,20 +157,23 @@ export class JobManager {
             continueSession: opts.continueSession,
             maxBudgetUsd: opts.maxBudgetUsd ?? 20,
             sessionId: opts.sessionId,
-            status: "cloning",
+            claudeToken: opts.claudeToken,
+            dependsOn: opts.dependsOn,
+            status: isPending ? "pending" : "cloning",
             output: [],
             toolCalls: [],
             startedAt: new Date(),
         };
         this.jobs.set(id, job);
         this.persistJob(job);
-        // Run async — don't await
-        this.run(job, opts.claudeToken ?? this.defaultToken).catch((err) => {
-            job.status = "failed";
-            job.error = String(err);
-            job.finishedAt = new Date();
-            this.persistJob(job);
-        });
+        if (!isPending) {
+            this.run(job, opts.claudeToken ?? this.defaultToken).catch((err) => {
+                job.status = "failed";
+                job.error = String(err);
+                job.finishedAt = new Date();
+                this.persistJob(job);
+            });
+        }
         return id;
     }
     async run(job, token) {
@@ -182,7 +198,6 @@ export class JobManager {
                 this.addOutput(job, `[cc-agent] Created branch: ${branchName}`);
             }
             else if (job.createBranch === "true") {
-                // createBranch=true but no name — generate one from job id
                 const auto = `agent/${job.id.slice(0, 8)}`;
                 await execFileAsync("git", ["checkout", "-b", auto], { cwd: workDir });
                 this.addOutput(job, `[cc-agent] Created branch: ${auto}`);
@@ -197,7 +212,6 @@ export class JobManager {
                     maxBudgetUsd: job.maxBudgetUsd,
                     sessionId: job.sessionId,
                 });
-                // Save PID for cross-restart tracking
                 if (proc.pid != null) {
                     job.pid = proc.pid;
                     this.persistJob(job);
@@ -215,7 +229,6 @@ export class JobManager {
                     job.totalOutputTokens = (job.totalOutputTokens ?? 0) + u.outputTokens;
                     job.totalCacheReadTokens = (job.totalCacheReadTokens ?? 0) + (u.cacheReadTokens ?? 0);
                     job.totalCacheWriteTokens = (job.totalCacheWriteTokens ?? 0) + (u.cacheWriteTokens ?? 0);
-                    // Prefer authoritative cost_usd from CLI result; fall back to calculated
                     job.costUsd = u.costUsd != null ? u.costUsd : calculateCost(job);
                     this.persistJob(job);
                 });
@@ -225,23 +238,18 @@ export class JobManager {
                 });
                 proc.on("tool", (name) => {
                     job.toolCalls.push(name);
-                    // Keep last 50 tool calls to avoid unbounded growth
                     if (job.toolCalls.length > 50)
                         job.toolCalls = job.toolCalls.slice(-50);
                 });
-                proc.on("error", (err) => {
-                    reject(err);
-                });
+                proc.on("error", (err) => { reject(err); });
                 proc.on("exit", (code) => {
                     job.exitCode = code ?? undefined;
                     job.stdinStream = null;
                     this.kills.delete(job.id);
-                    if (code === 0 || code === null) {
+                    if (code === 0 || code === null)
                         resolve();
-                    }
-                    else {
+                    else
                         reject(new Error(`Claude exited with code ${code}`));
-                    }
                 });
             });
             job.status = "done";
@@ -257,26 +265,55 @@ export class JobManager {
         finally {
             job.finishedAt = new Date();
             this.persistJob(job);
-            // Clean up work dir after 10 minutes to allow output inspection
             if (workDir) {
                 setTimeout(() => rm(workDir, { recursive: true, force: true }).catch(() => { }), 10 * 60 * 1000).unref();
             }
         }
     }
+    tick() {
+        for (const [, job] of this.jobs) {
+            if (job.status !== "pending")
+                continue;
+            if (!job.dependsOn?.length) {
+                this.promote(job);
+                continue;
+            }
+            const allDone = job.dependsOn.every((depId) => this.jobs.get(depId)?.status === "done");
+            const anyFailed = job.dependsOn.some((depId) => {
+                const s = this.jobs.get(depId)?.status;
+                return s === "failed" || s === "cancelled";
+            });
+            if (anyFailed) {
+                job.status = "failed";
+                job.error = "Dependency failed";
+                job.finishedAt = new Date();
+                this.persistJob(job);
+            }
+            else if (allDone) {
+                this.promote(job);
+            }
+        }
+    }
+    promote(job) {
+        this.run(job, job.claudeToken ?? this.defaultToken).catch((err) => {
+            job.status = "failed";
+            job.error = String(err);
+            job.finishedAt = new Date();
+            this.persistJob(job);
+        });
+    }
     getJob(id) {
         return this.jobs.get(id);
     }
-    getOutput(id, offset = 0) {
+    async getOutput(id, offset = 0) {
         const job = this.jobs.get(id);
         if (!job) {
-            // Job not in memory (expired or unknown) — try disk log
-            const lines = readLogSync(id, offset);
+            const lines = await jobStore.getOutput(id, offset);
             return { lines, done: true, toolCalls: [] };
         }
         const done = job.status === "done" || job.status === "failed" || job.status === "cancelled";
-        if (this.diskLoadedJobs.has(id)) {
-            // Output lives on disk for jobs recovered after restart
-            return { lines: readLogSync(id, offset), done, toolCalls: job.toolCalls };
+        if (this.restoredJobs.has(id)) {
+            return { lines: await jobStore.getOutput(id, offset), done, toolCalls: job.toolCalls };
         }
         return { lines: job.output.slice(offset), done, toolCalls: job.toolCalls };
     }
@@ -318,7 +355,7 @@ export class JobManager {
         const job = this.jobs.get(id);
         if (!job)
             return false;
-        if (job.status !== "cloning" && job.status !== "running")
+        if (job.status !== "pending" && job.status !== "cloning" && job.status !== "running")
             return false;
         const kill = this.kills.get(id);
         if (kill) {
@@ -338,7 +375,7 @@ export class JobManager {
                 job.finishedAt &&
                 now - job.finishedAt.getTime() > JOB_TTL_MS) {
                 this.jobs.delete(id);
-                this.diskLoadedJobs.delete(id);
+                this.restoredJobs.delete(id);
             }
         }
     }