@delegance/claude-autopilot 7.11.0-pre.2 → 7.11.0-pre.3

package/dist/src/cli/runs-watch-renderer.js

@@ -232,6 +232,43 @@ export function renderEventLine(ev, runningTotal, opts) {
         case 'replay.override': {
             return `${ts} ${colorize(verb, 'magenta', opts.ansi)} ${ev.phase}  reason=${ev.reason}`;
         }
+        // v7.11.0 concurrent subagent dispatch events. Detailed renderers will
+        // land in PR 6 (#193) when the watch UI exposes the per-task pane.
+        // For now, render a single-line summary so existing `runs watch`
+        // sessions don't silently skip these events.
+        case 'task.started': {
+            return `${ts} ${colorize(verb, 'cyan', opts.ansi)} ${ev.task_id} branch=${ev.branch}`;
+        }
+        case 'task.budget_reserved': {
+            return `${ts} ${colorize(verb, 'cyan', opts.ansi)} ${ev.task_id} reserved=${fmtUSD(ev.reserved_usd)}`;
+        }
+        case 'task.budget_increased_reservation': {
+            return `${ts} ${colorize(verb, 'cyan', opts.ansi)} ${ev.task_id} ${fmtUSD(ev.prior_reserved_usd)}→${fmtUSD(ev.new_reserved_usd)}  ${ev.reason}`;
+        }
+        case 'task.budget_released': {
+            return `${ts} ${colorize(verb, 'cyan', opts.ansi)} ${ev.task_id} actual=${fmtUSD(ev.actual_cost_usd)}  delta=${fmtUSD(ev.delta_vs_reservation_usd)}`;
+        }
+        case 'task.completed': {
+            return `${ts} ${colorize(verb, 'green', opts.ansi)} ${ev.task_id} status=${ev.exit_status} commits=${ev.commit_shas.length}`;
+        }
+        case 'task.failed': {
+            return `${ts} ${colorize(verb, 'red', opts.ansi)} ${ev.task_id} type=${ev.error_type}  ${ev.error_message}`;
+        }
+        case 'task.merged': {
+            return `${ts} ${colorize(verb, 'green', opts.ansi)} ${ev.task_id}`;
+        }
+        case 'task.merge_conflict': {
+            return `${ts} ${colorize(verb, 'red', opts.ansi)} ${ev.task_id} paths=${ev.conflicting_paths.length}`;
+        }
+        case 'task.merge_aborted': {
+            return `${ts} ${colorize(verb, 'red', opts.ansi)} ${ev.task_id} reason=${ev.reason}`;
+        }
+        case 'task.timeout': {
+            return `${ts} ${colorize(verb, 'yellow', opts.ansi)} ${ev.task_id} ${ev.timeout_ms}ms signal=${ev.killed_signal}`;
+        }
+        case 'task.budget_halt': {
+            return `${ts} ${colorize(verb, 'red', opts.ansi)} ${ev.task_id} remaining=${fmtUSD(ev.budget_remaining_usd)} needed=${fmtUSD(ev.preflight_estimate_usd)}`;
+        }
         default: {
             // Exhaustiveness guard. New event variants must be added here so a
             // future RunEvent extension forces a compile error rather than

package/dist/src/core/run-state/events.js

@@ -406,6 +406,24 @@ function applyEvent(state, ev) {
             // events.ndjson directly to compute actualSoFar — replay does not
             // need to track budget decisions for state-correctness purposes.
             break;
+        case 'task.started':
+        case 'task.budget_reserved':
+        case 'task.budget_increased_reservation':
+        case 'task.budget_released':
+        case 'task.completed':
+        case 'task.failed':
+        case 'task.merged':
+        case 'task.merge_conflict':
+        case 'task.merge_aborted':
+        case 'task.timeout':
+        case 'task.budget_halt':
+            // v7.11.0 concurrent-dispatch task events. State for these lives in
+            // the dispatch layer (budget-reservation ledger + scheduler), NOT in
+            // the per-phase RunState snapshot — phases remain the coarse-grained
+            // unit for the run-state engine. Replay is handled by
+            // `budgetReservation.replayFromEvents()` for cost reconstruction and
+            // by the scheduler's resume path for task-level state.
+            break;
         case 'phase.start': {
             state.status = 'running';
             state.currentPhaseIdx = ev.phaseIdx;

package/dist/src/core/run-state/types.d.ts

@@ -251,9 +251,135 @@ export interface ReplayOverrideEvent extends RunEventBase {
     /** Refs the underlying refusal cited (echoed for triage). */
     refsConsulted: ExternalRef[];
 }
+/** Subagent dispatch — emitted AFTER `task.budget_reserved` succeeds and the
+ *  worktree is created. Carries the immutable `base_sha` so resume / merge
+ *  can verify ancestry against an unforgeable reference. */
+export interface TaskStartedEvent extends RunEventBase {
+    event: 'task.started';
+    task_id: string;
+    worktree_path: string;
+    branch: string;
+    base_sha: string;
+    subagent_id: string;
+    /** ISO timestamp the subagent process was spawned. */
+    dispatched_at: string;
+    preflight_cost_estimate_usd: number;
+}
+/** Budget reservation — emitted atomically with the (replay → check → append
+ *  → fsync) critical section under the writer's exclusive lock. Two
+ *  concurrent callers cannot both pass the budget check. */
+export interface TaskBudgetReservedEvent extends RunEventBase {
+    event: 'task.budget_reserved';
+    task_id: string;
+    reserved_usd: number;
+    /** `perRunUSD - reserved_total` AFTER this reservation lands. May be 0,
+     *  never negative (would have failed the check). */
+    run_budget_remaining_after_reservation_usd: number;
+}
+/** Mid-execution reservation bump — emitted when telemetry from the subagent
+ *  shows actual cost is approaching the reservation. Re-checks `perRunUSD`
+ *  under the writer lock; halts the run if exceeded. */
+export interface TaskBudgetIncreasedReservationEvent extends RunEventBase {
+    event: 'task.budget_increased_reservation';
+    task_id: string;
+    prior_reserved_usd: number;
+    new_reserved_usd: number;
+    reason: string;
+}
+/** Reservation closed — emitted on task completion OR failure. The
+ *  `delta_vs_reservation_usd` (positive = under, negative = over) lets
+ *  cost-analytics consumers spot estimate drift. */
+export interface TaskBudgetReleasedEvent extends RunEventBase {
+    event: 'task.budget_released';
+    task_id: string;
+    actual_cost_usd: number;
+    delta_vs_reservation_usd: number;
+}
+/** Successful subagent exit with commits on the task branch. The
+ *  `task_branch_tip_sha` is the IMMUTABLE authoritative ref for all
+ *  subsequent merge / resume operations — `task_branch_name` is for
+ *  diagnostics only (branch can be tampered with). */
+export interface TaskCompletedEvent extends RunEventBase {
+    event: 'task.completed';
+    task_id: string;
+    base_sha: string;
+    task_branch_tip_sha: string;
+    task_branch_name: string;
+    /** Ordered list of commit SHAs `base_sha..tip_sha` (oldest first, from
+     *  `git rev-list --reverse`). Empty array implies `task.failed` should
+     *  have been emitted with `error_type: 'no_commits'` instead. */
+    commit_shas: string[];
+    completed_at: string;
+    actual_cost_usd: number;
+    exit_status: 'success' | 'failure';
+}
+/** Subagent terminal failure. `error_type` is the resume classifier — see
+ *  spec "Resume semantics" for the classification table. */
+export interface TaskFailedEvent extends RunEventBase {
+    event: 'task.failed';
+    task_id: string;
+    error_message: string;
+    error_type: 'timeout' | 'no_commits' | 'ancestry_violation' | 'budget_exceeded' | 'crash' | 'other';
+    failed_at: string;
+    actual_cost_usd: number;
+}
+/** Cherry-pick chain landed on the integration worktree. The
+ *  `feature_branch_sha_after_merge` is recorded so the next merge can
+ *  verify preconditions (HEAD matches the last `task.merged`). */
+export interface TaskMergedEvent extends RunEventBase {
+    event: 'task.merged';
+    task_id: string;
+    feature_branch_sha_after_merge: string;
+    merged_at: string;
+}
+/** Cherry-pick conflict captured BEFORE `cherry-pick --abort` runs.
+ *  Diagnostics are also persisted to `conflict_report_path`
+ *  (`.claude/run-state/<run-ulid>/conflicts/<task-id>.md`). */
+export interface TaskMergeConflictEvent extends RunEventBase {
+    event: 'task.merge_conflict';
+    task_id: string;
+    conflicting_paths: string[];
+    /** Output of `git ls-files -u` — index stages 1/2/3 for each conflicted
+     *  path. Free-form lines preserved verbatim. */
+    index_stages: string[];
+    /** Output of `git status --porcelain`. */
+    porcelain: string;
+    conflict_report_path: string;
+}
+/** Merge precondition violation — dirty tree, wrong HEAD, in-progress
+ *  cherry-pick / rebase, or ancestry violation at merge time. Halts the
+ *  run; user must resolve before resume. */
+export interface TaskMergeAbortedEvent extends RunEventBase {
+    event: 'task.merge_aborted';
+    task_id: string;
+    reason: string;
+    precondition_violated: string;
+    occurred_at: string;
+}
+/** Subagent exceeded `perSubagentTimeoutMs`. Informational — the resume
+ *  classifier requires a paired `task.failed` event with
+ *  `error_type: 'timeout'` for terminal classification. */
+export interface TaskTimeoutEvent extends RunEventBase {
+    event: 'task.timeout';
+    task_id: string;
+    timeout_ms: number;
+    /** `SIGTERM` or `SIGKILL` — set to `SIGKILL` when the 30s grace after
+     *  SIGTERM elapsed without process exit. */
+    killed_signal: 'SIGTERM' | 'SIGKILL';
+}
+/** Pre-dispatch budget halt — emitted when `reserve()` finds remaining
+ *  budget insufficient for the new task's preflight estimate. The task
+ *  never dispatches; the scheduler halts the run with this event as the
+ *  terminal record. */
+export interface TaskBudgetHaltEvent extends RunEventBase {
+    event: 'task.budget_halt';
+    task_id: string;
+    budget_remaining_usd: number;
+    preflight_estimate_usd: number;
+}
 /** Discriminated union of every event variant. Add new variants here and
  *  the code that switches over `event` will type-error at compile time. */
-export type RunEvent = RunStartEvent | RunCompleteEvent | RunWarningEvent | RunRecoveryEvent | PhaseStartEvent | PhaseSuccessEvent | PhaseFailedEvent | PhaseAbortedEvent | PhaseCostEvent | PhaseExternalRefEvent | PhaseNeedsHumanEvent | LockTakeoverEvent | IndexRebuiltEvent | BudgetCheckEvent | ReplayOverrideEvent;
+export type RunEvent = RunStartEvent | RunCompleteEvent | RunWarningEvent | RunRecoveryEvent | PhaseStartEvent | PhaseSuccessEvent | PhaseFailedEvent | PhaseAbortedEvent | PhaseCostEvent | PhaseExternalRefEvent | PhaseNeedsHumanEvent | LockTakeoverEvent | IndexRebuiltEvent | BudgetCheckEvent | ReplayOverrideEvent | TaskStartedEvent | TaskBudgetReservedEvent | TaskBudgetIncreasedReservationEvent | TaskBudgetReleasedEvent | TaskCompletedEvent | TaskFailedEvent | TaskMergedEvent | TaskMergeConflictEvent | TaskMergeAbortedEvent | TaskTimeoutEvent | TaskBudgetHaltEvent;
 /** Distributive Omit so the discriminated-union shape is preserved when we
  *  strip the fields the appender fills in. Plain `Omit<RunEvent, ...>`
  *  collapses the union into a single intersection and loses variant-specific

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delegance/claude-autopilot",
-  "version": "7.11.0-pre.2",
+  "version": "7.11.0-pre.3",
   "type": "module",
   "publishConfig": {
     "tag": "next"