@turmind/halo 2.1.5 → 2.2.0

package/dist/evo-wrapper.js

@@ -1,12 +1,12 @@
 // ../server/dist/evolution/evo-wrapper.js
-import fs9 from "node:fs";
-import path12 from "node:path";
+import fs11 from "node:fs";
+import path13 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 import { homedir as homedir6 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { parseArgs } from "node:util";
-import { eq, and } from "drizzle-orm";
-import YAML6 from "yaml";
+import { eq as eq3, and as and3, inArray as inArray2 } from "drizzle-orm";
+import YAML7 from "yaml";
 
 // ../server/dist/db/evo-db.js
 import Database from "better-sqlite3";
@@ -29,6 +29,12 @@ function runMigrations(sqlite, migrations) {
     })();
   }
 }
+function addColumnIfMissing(sqlite, table, column, decl) {
+  const cols = sqlite.prepare(`PRAGMA table_info(${table})`).all();
+  if (cols.some((c) => c.name === column))
+    return;
+  sqlite.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${decl}`);
+}
 
 // ../server/dist/db/evo-db.js
 var evolutionRuns = sqliteTable("evolution_runs", {
@@ -48,10 +54,24 @@ var evolutionRuns = sqliteTable("evolution_runs", {
    *  Bumped on each `pending → running` claim. When it crosses the configured
    *  retry budget, the ticker stops re-claiming after timeout/failure. */
   attempts: integer("attempts").notNull().default(0),
+  /** `attempts` when the latest reviewer retry reset the row. The retry
+   *  budget is `attempts - attempts_base`; attempts itself never goes back
+   *  down, so a stale wrapper's claim (ownsRun) can't match a later one. */
+  attemptsBase: integer("attempts_base").notNull().default(0),
   /** When archive job zipped the artifacts and deleted the run dir. Null
    *  while the run is active. Rows with archived_at >= 30 days ago are
    *  candidates for full deletion (zip + db row). */
-  archivedAt: integer("archived_at")
+  archivedAt: integer("archived_at"),
+  /** The draft carries a `## Larger observation` section (patch.md body or
+   *  .skip.md) — set by the wrapper after phase A so the admin list can flag
+   *  and filter it without reading every run dir. */
+  hasObservation: integer("has_observation", { mode: "boolean" }).notNull().default(false),
+  /** Access level of the source session at enqueue ('full' | 'workspace' |
+   *  'readonly'), or 'webhook' for a session that took webhook events. Only
+   *  a full source may be auto-applied (L2/L3): a lesser session's (or an
+   *  outside payload's) conversation must not rewrite prompts without a
+   *  reviewer. Pre-existing rows read null → never auto-applied. */
+  sourceAccess: text("source_access")
 });
 var evolutionApplies = sqliteTable("evolution_applies", {
   id: text("id").primaryKey(),
@@ -66,7 +86,13 @@ var evolutionApplies = sqliteTable("evolution_applies", {
   completedAt: integer("completed_at"),
   failureReason: text("failure_reason"),
   attempts: integer("attempts").notNull().default(0),
-  archivedAt: integer("archived_at")
+  archivedAt: integer("archived_at"),
+  /** 'reviewer' (Approve button) | 'auto' (L2/L3 auto-apply, evolution/auto-apply.ts). */
+  approvedBy: text("approved_by").notNull().default("reviewer"),
+  /** When the source session got the one-line "auto-applied" notice (ticker
+   *  notifyAutoApplied). Null = not yet sent; only auto applies are notified. */
+  notifiedAt: integer("notified_at"),
+  rolledBackAt: integer("rolled_back_at")
 });
 var CREATE_SQL = `
 CREATE TABLE IF NOT EXISTS evolution_runs (
@@ -83,7 +109,10 @@ CREATE TABLE IF NOT EXISTS evolution_runs (
   applied_at      INTEGER,
   failure_reason  TEXT,
   attempts        INTEGER NOT NULL DEFAULT 0,
-  archived_at     INTEGER
+  archived_at     INTEGER,
+  has_observation INTEGER NOT NULL DEFAULT 0,
+  source_access   TEXT,
+  attempts_base   INTEGER NOT NULL DEFAULT 0
 );
 CREATE INDEX IF NOT EXISTS idx_evo_runs_status ON evolution_runs(status, created_at);
 CREATE INDEX IF NOT EXISTS idx_evo_runs_ws ON evolution_runs(workspace_path);
@@ -101,19 +130,39 @@ CREATE TABLE IF NOT EXISTS evolution_applies (
   completed_at    INTEGER,
   failure_reason  TEXT,
   attempts        INTEGER NOT NULL DEFAULT 0,
-  archived_at     INTEGER
+  archived_at     INTEGER,
+  approved_by     TEXT NOT NULL DEFAULT 'reviewer',
+  notified_at     INTEGER,
+  rolled_back_at  INTEGER
 );
 CREATE INDEX IF NOT EXISTS idx_evo_applies_status ON evolution_applies(status, created_at);
 CREATE INDEX IF NOT EXISTS idx_evo_applies_ws ON evolution_applies(workspace_path);
 CREATE INDEX IF NOT EXISTS idx_evo_applies_archived ON evolution_applies(archived_at);
 `;
+var addV1Columns = (s) => {
+  addColumnIfMissing(s, "evolution_applies", "approved_by", "TEXT NOT NULL DEFAULT 'reviewer'");
+  addColumnIfMissing(s, "evolution_applies", "notified_at", "INTEGER");
+  addColumnIfMissing(s, "evolution_applies", "rolled_back_at", "INTEGER");
+  addColumnIfMissing(s, "evolution_runs", "has_observation", "INTEGER NOT NULL DEFAULT 0");
+  addColumnIfMissing(s, "evolution_runs", "source_access", "TEXT");
+};
+var EVO_MIGRATIONS = [
+  addV1Columns,
+  // v2: retry keeps attempts monotonic and records where the round started.
+  // Re-runs v1's adds (idempotent): dev builds stamped user_version 1 before
+  // v1 had all its columns (source_access).
+  (s) => {
+    addV1Columns(s);
+    addColumnIfMissing(s, "evolution_runs", "attempts_base", "INTEGER NOT NULL DEFAULT 0");
+  }
+];
 function createEvoDb(globalDir2) {
   fs.mkdirSync(globalDir2, { recursive: true });
   const dbPath = path.join(globalDir2, "evo.db");
   const sqlite = new Database(dbPath);
   sqlite.pragma("journal_mode = WAL");
   sqlite.exec(CREATE_SQL);
-  runMigrations(sqlite, []);
+  runMigrations(sqlite, EVO_MIGRATIONS);
   return drizzle(sqlite, { schema: { evolutionRuns, evolutionApplies } });
 }
 var _evoDb = null;
@@ -211,8 +260,6 @@ function cleanChildEnv() {
   const env = { ...process.env };
   delete env.HALO_PASSWORD;
   delete env.HALO_JWT_SECRET;
-  delete env.HALO_NODE_RELAY_URL;
-  delete env.HALO_NODE_RELAY_TOKEN;
   delete env.HALO_NODE_TOKEN;
   for (const key of settingsOtelEnvKeys)
     delete env[key];
@@ -856,11 +903,12 @@ function generalSection() {
       // observability (OpenTelemetry). Read once at boot by observability/otel.ts
       // and mapped onto the standard OTEL_* env vars — hence "takes effect on
       // restart" everywhere below. Children don't inherit those settings-derived
-      // vars (child-env.ts), so each cron / evo cli run re-reads settings.
-      { key: "observability.endpoint", type: "string", globalOnly: true, restartRequired: true, description: "OTLP base URL of an OpenTelemetry collector (e.g. http://localhost:4318). Traces, metrics and logs are all exported there over OTLP http/protobuf \u2014 http:// or https://, on the collector's OTLP/HTTP port (4318 by default); gRPC (4317) is not supported. Empty = observability off. Takes effect on server restart; cron / evolution runs use the new value on their next run.", description_zh: "OpenTelemetry collector \u7684 OTLP \u57FA\u7840\u5730\u5740\uFF08\u5982 http://localhost:4318\uFF09\uFF0Ctrace / metrics / \u65E5\u5FD7\u4E09\u7C7B\u4FE1\u53F7\u90FD\u4EE5 OTLP http/protobuf \u53D1\u5230\u8FD9\u91CC\u3002http:// \u6216 https:// \u5747\u53EF\uFF0C\u7AEF\u53E3\u987B\u662F collector \u7684 OTLP/HTTP \u7AEF\u53E3\uFF08\u9ED8\u8BA4 4318\uFF09\uFF0C\u4E0D\u652F\u6301 gRPC\uFF084317\uFF09\u3002\u7559\u7A7A = \u5173\u95ED\u3002\u91CD\u542F\u670D\u52A1\u540E\u751F\u6548\uFF1Bcron / evolution \u4EFB\u52A1\u4E0B\u6B21\u8FD0\u884C\u5373\u7528\u65B0\u503C\u3002", default: "" },
-      { key: "observability.service_name", type: "string", globalOnly: true, restartRequired: true, description: "OTel resource service.name reported for this server. Takes effect on server restart; cron / evolution runs use the new value on their next run.", description_zh: "\u672C\u670D\u52A1\u5728 OTel \u4E2D\u4E0A\u62A5\u7684 service.name\u3002\u91CD\u542F\u670D\u52A1\u540E\u751F\u6548\uFF1Bcron / evolution \u4EFB\u52A1\u4E0B\u6B21\u8FD0\u884C\u5373\u7528\u65B0\u503C\u3002", default: "halo" },
-      { key: "observability.headers", type: "string", secret: true, globalOnly: true, restartRequired: true, description: "Extra headers for every OTLP request, comma-separated k=v (e.g. authorization=Bearer \u2026). Takes effect on server restart; cron / evolution runs use the new value on their next run.", description_zh: "\u9644\u52A0\u5230\u6BCF\u4E2A OTLP \u8BF7\u6C42\u7684 header\uFF0C\u9017\u53F7\u5206\u9694\u7684 k=v\uFF08\u5982 authorization=Bearer \u2026\uFF09\u3002\u91CD\u542F\u670D\u52A1\u540E\u751F\u6548\uFF1Bcron / evolution \u4EFB\u52A1\u4E0B\u6B21\u8FD0\u884C\u5373\u7528\u65B0\u503C\u3002", default: "" },
-      { key: "observability.capture_content", type: "boolean", globalOnly: true, restartRequired: true, description: "Put prompt / completion / tool argument and result text on spans (gen_ai.*.messages etc.). Off = only metadata (model, tokens, latency, tool names). Env OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT (true / false) overrides. Takes effect on server restart; cron / evolution runs use the new value on their next run.", description_zh: "\u662F\u5426\u628A\u63D0\u793A\u8BCD / \u6A21\u578B\u8F93\u51FA / \u5DE5\u5177\u53C2\u6570\u4E0E\u7ED3\u679C\u6B63\u6587\u5199\u5230 span \u4E0A\uFF08gen_ai.*.messages \u7B49\uFF09\u3002\u5173 = \u53EA\u4E0A\u62A5\u5143\u6570\u636E\uFF08\u6A21\u578B\u3001token\u3001\u8017\u65F6\u3001\u5DE5\u5177\u540D\uFF09\u3002\u73AF\u5883\u53D8\u91CF OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT\uFF08true / false\uFF09\u4F18\u5148\u3002\u91CD\u542F\u670D\u52A1\u540E\u751F\u6548\uFF1Bcron / evolution \u4EFB\u52A1\u4E0B\u6B21\u8FD0\u884C\u5373\u7528\u65B0\u503C\u3002", default: "false" },
+      // vars (child-env.ts), so each evo cli run re-reads settings; cron runs in
+      // the server process and follows its boot-time values.
+      { key: "observability.endpoint", type: "string", globalOnly: true, restartRequired: true, description: "OTLP base URL of an OpenTelemetry collector (e.g. http://localhost:4318). Traces, metrics and logs are all exported there over OTLP http/protobuf \u2014 http:// or https://, on the collector's OTLP/HTTP port (4318 by default); gRPC (4317) is not supported. Empty = observability off. Takes effect on server restart (cron runs included \u2014 they run in the server); evolution runs use the new value on their next run.", description_zh: "OpenTelemetry collector \u7684 OTLP \u57FA\u7840\u5730\u5740\uFF08\u5982 http://localhost:4318\uFF09\uFF0Ctrace / metrics / \u65E5\u5FD7\u4E09\u7C7B\u4FE1\u53F7\u90FD\u4EE5 OTLP http/protobuf \u53D1\u5230\u8FD9\u91CC\u3002http:// \u6216 https:// \u5747\u53EF\uFF0C\u7AEF\u53E3\u987B\u662F collector \u7684 OTLP/HTTP \u7AEF\u53E3\uFF08\u9ED8\u8BA4 4318\uFF09\uFF0C\u4E0D\u652F\u6301 gRPC\uFF084317\uFF09\u3002\u7559\u7A7A = \u5173\u95ED\u3002\u91CD\u542F\u670D\u52A1\u540E\u751F\u6548\uFF08cron \u4EFB\u52A1\u5728\u670D\u52A1\u8FDB\u7A0B\u5185\u8FD0\u884C\uFF0C\u540C\u6837\u9700\u91CD\u542F\uFF09\uFF1Bevolution \u4EFB\u52A1\u4E0B\u6B21\u8FD0\u884C\u5373\u7528\u65B0\u503C\u3002", default: "" },
+      { key: "observability.service_name", type: "string", globalOnly: true, restartRequired: true, description: "OTel resource service.name reported for this server. Takes effect on server restart (cron runs included \u2014 they run in the server); evolution runs use the new value on their next run.", description_zh: "\u672C\u670D\u52A1\u5728 OTel \u4E2D\u4E0A\u62A5\u7684 service.name\u3002\u91CD\u542F\u670D\u52A1\u540E\u751F\u6548\uFF08cron \u4EFB\u52A1\u5728\u670D\u52A1\u8FDB\u7A0B\u5185\u8FD0\u884C\uFF0C\u540C\u6837\u9700\u91CD\u542F\uFF09\uFF1Bevolution \u4EFB\u52A1\u4E0B\u6B21\u8FD0\u884C\u5373\u7528\u65B0\u503C\u3002", default: "halo" },
+      { key: "observability.headers", type: "string", secret: true, globalOnly: true, restartRequired: true, description: "Extra headers for every OTLP request, comma-separated k=v (e.g. authorization=Bearer \u2026). Takes effect on server restart (cron runs included \u2014 they run in the server); evolution runs use the new value on their next run.", description_zh: "\u9644\u52A0\u5230\u6BCF\u4E2A OTLP \u8BF7\u6C42\u7684 header\uFF0C\u9017\u53F7\u5206\u9694\u7684 k=v\uFF08\u5982 authorization=Bearer \u2026\uFF09\u3002\u91CD\u542F\u670D\u52A1\u540E\u751F\u6548\uFF08cron \u4EFB\u52A1\u5728\u670D\u52A1\u8FDB\u7A0B\u5185\u8FD0\u884C\uFF0C\u540C\u6837\u9700\u91CD\u542F\uFF09\uFF1Bevolution \u4EFB\u52A1\u4E0B\u6B21\u8FD0\u884C\u5373\u7528\u65B0\u503C\u3002", default: "" },
+      { key: "observability.capture_content", type: "boolean", globalOnly: true, restartRequired: true, description: "Put prompt / completion / tool argument and result text on spans (gen_ai.*.messages etc.). Off = only metadata (model, tokens, latency, tool names). Env OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT (true / false) overrides. Takes effect on server restart (cron runs included \u2014 they run in the server); evolution runs use the new value on their next run.", description_zh: "\u662F\u5426\u628A\u63D0\u793A\u8BCD / \u6A21\u578B\u8F93\u51FA / \u5DE5\u5177\u53C2\u6570\u4E0E\u7ED3\u679C\u6B63\u6587\u5199\u5230 span \u4E0A\uFF08gen_ai.*.messages \u7B49\uFF09\u3002\u5173 = \u53EA\u4E0A\u62A5\u5143\u6570\u636E\uFF08\u6A21\u578B\u3001token\u3001\u8017\u65F6\u3001\u5DE5\u5177\u540D\uFF09\u3002\u73AF\u5883\u53D8\u91CF OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT\uFF08true / false\uFF09\u4F18\u5148\u3002\u91CD\u542F\u670D\u52A1\u540E\u751F\u6548\uFF08cron \u4EFB\u52A1\u5728\u670D\u52A1\u8FDB\u7A0B\u5185\u8FD0\u884C\uFF0C\u540C\u6837\u9700\u91CD\u542F\uFF09\uFF1Bevolution \u4EFB\u52A1\u4E0B\u6B21\u8FD0\u884C\u5373\u7528\u65B0\u503C\u3002", default: "false" },
       // Notebook kernels (jupyter/manager.ts). Global-only: kernels run
       // unsandboxed as the service user, like the terminal. Read per spawn.
       { key: "jupyter.enabled", type: "boolean", globalOnly: true, description: "Allow notebook execution: the ipynb viewer can start kernels through a local Jupyter server (runs as the Halo service user, unsandboxed, like the terminal).", description_zh: "\u5141\u8BB8\u8FD0\u884C notebook\uFF1Aipynb \u67E5\u770B\u5668\u53EF\u901A\u8FC7\u672C\u673A Jupyter server \u542F\u52A8\u5185\u6838\uFF08\u4EE5 Halo \u670D\u52A1\u7528\u6237\u8EAB\u4EFD\u8FD0\u884C\u3001\u4E0D\u8FDB\u6C99\u7BB1\uFF0C\u4E0E\u7EC8\u7AEF\u76F8\u540C\uFF09\u3002", default: "true" },
@@ -872,7 +920,8 @@ function generalSection() {
       // self-evolution (see plans/self-evolution.md). All evo settings are
       // global-only — the worker / ticker live in the server process and
       // would have to reload mid-flight if a workspace could override them.
-      { key: "evolution.level", type: "enum", options: ["L0", "L1"], globalOnly: true, description: "Self-evolution capability ladder. L0: manual only \u2014 drafts via /evo, manual approve/reject. L1: L0 plus automatic drafting on pre-compact. (Queued runs always execute regardless of level; the level only gates how they get enqueued.)", description_zh: "\u81EA\u6211\u8FDB\u5316\u7B49\u7EA7\u3002L0\uFF1A\u4EC5\u624B\u52A8\u2014\u2014\u901A\u8FC7 /evo \u8D77\u8349\uFF0C\u624B\u52A8 approve/reject\u3002L1\uFF1A\u5728 L0 \u57FA\u7840\u4E0A\uFF0C\u538B\u7F29\u524D\uFF08pre-compact\uFF09\u81EA\u52A8\u8D77\u8349\u3002\uFF08\u5DF2\u6392\u961F\u7684 run \u59CB\u7EC8\u6267\u884C\uFF0Clevel \u53EA\u51B3\u5B9A\u5982\u4F55\u5165\u961F\u3002\uFF09", default: "L0" },
+      { key: "evolution.level", type: "enum", options: ["L0", "L1", "L2", "L3"], globalOnly: true, description: "Self-evolution capability ladder. L0: manual only \u2014 drafts via /evo, manual approve/reject. L1: L0 plus automatic drafting on pre-compact. L2: L1 plus auto-applying prompt-only changes that score above evolution.auto_apply_threshold. L3: L2 plus auto-applying capability changes (agent.yaml tools / model, skill invocation). Auto-applied changes still pass the regression check and can be rolled back from the Evolution tab. Queued runs always execute regardless of level.", description_zh: "\u81EA\u6211\u8FDB\u5316\u7B49\u7EA7\u3002L0\uFF1A\u4EC5\u624B\u52A8\u2014\u2014\u901A\u8FC7 /evo \u8D77\u8349\uFF0C\u624B\u52A8 approve/reject\u3002L1\uFF1A\u5728 L0 \u57FA\u7840\u4E0A\uFF0C\u538B\u7F29\u524D\uFF08pre-compact\uFF09\u81EA\u52A8\u8D77\u8349\u3002L2\uFF1A\u5728 L1 \u57FA\u7840\u4E0A\uFF0C\u5BF9\u8BC4\u5206\u8D85\u8FC7 evolution.auto_apply_threshold \u7684\u7EAF\u63D0\u793A\u8BCD\u6539\u52A8\u81EA\u52A8\u5E94\u7528\u3002L3\uFF1A\u5728 L2 \u57FA\u7840\u4E0A\uFF0C\u5BF9\u80FD\u529B\u7C7B\u6539\u52A8\uFF08agent.yaml \u7684\u5DE5\u5177/\u6A21\u578B\u3001skill \u8C03\u7528\u65B9\u5F0F\uFF09\u4E5F\u81EA\u52A8\u5E94\u7528\u3002\u81EA\u52A8\u5E94\u7528\u7167\u6837\u8FC7\u56DE\u5F52\u68C0\u67E5\uFF0C\u53EF\u5728 Evolution \u9875\u56DE\u6EDA\u3002\u5DF2\u6392\u961F\u7684 run \u4E0D\u53D7\u7B49\u7EA7\u5F71\u54CD\uFF0C\u59CB\u7EC8\u6267\u884C\u3002", default: "L0" },
+      { key: "evolution.auto_apply_threshold", type: "int", min: 0, max: 100, globalOnly: true, description: "Minimum average score (0\u2013100) for auto-apply at L2/L3. Also required: confidence high, behavior \u2265 70, lint 100, all sandbox checks passed. Ignored at L0/L1.", description_zh: "L2/L3 \u81EA\u52A8\u5E94\u7528\u8981\u6C42\u7684\u6700\u4F4E\u5E73\u5747\u5206\uFF080\u2013100\uFF09\u3002\u53E6\u9700\u540C\u65F6\u6EE1\u8DB3\uFF1Aconfidence \u4E3A high\u3001behavior \u2265 70\u3001lint \u4E3A 100\u3001\u6C99\u7BB1\u68C0\u67E5\u5168\u90E8\u901A\u8FC7\u3002L0/L1 \u4E0B\u5FFD\u7565\u3002", default: "80" },
       { key: "evolution.max_concurrent_run", type: "int", globalOnly: true, description: "Max concurrent evo run wrappers (drafting patches).", description_zh: "\u540C\u65F6\u8FD0\u884C\u7684 evo run wrapper \u4E0A\u9650\uFF08\u8D77\u8349 patch\uFF09\u3002", default: "1" },
       { key: "evolution.max_concurrent_apply", type: "int", globalOnly: true, description: "Max concurrent evo apply wrappers (merging patches).", description_zh: "\u540C\u65F6\u8FD0\u884C\u7684 evo apply wrapper \u4E0A\u9650\uFF08\u5408\u5E76 patch\uFF09\u3002", default: "1" },
       { key: "evolution.run_timeout_minutes", type: "int", globalOnly: true, description: "Heartbeat timeout for run wrappers. The wrapper writes a heartbeat every 60s for as long as it lives, so exceeding this means the wrapper process died \u2014 the row is requeued (or marked timeout past max_attempts). This is dead-wrapper detection latency, NOT a budget for slow models; the per-phase model budget is the wrapper-internal cap (draft 60min, other phases 45min).", description_zh: "run wrapper \u5FC3\u8DF3\u8D85\u65F6\uFF08\u5206\u949F\uFF09\u3002wrapper \u5B58\u6D3B\u671F\u95F4\u6BCF 60 \u79D2\u5199\u4E00\u6B21\u5FC3\u8DF3\uFF0C\u8D85\u65F6\u5373\u89C6\u4E3A wrapper \u8FDB\u7A0B\u5DF2\u6B7B\uFF0C\u4EFB\u52A1\u91CD\u6392\uFF08\u8D85\u8FC7 max_attempts \u5219\u6807 timeout\uFF09\u3002\u8FD9\u662F\u6B7B wrapper \u7684\u68C0\u6D4B\u5EF6\u8FDF\uFF0C\u4E0D\u662F\u6162\u6A21\u578B\u7684\u8FD0\u884C\u9884\u7B97\u2014\u2014\u5355\u9636\u6BB5\u6A21\u578B\u9884\u7B97\u662F wrapper \u5185\u90E8\u7684\u4E0A\u9650\uFF08\u8D77\u8349 60 \u5206\u949F\uFF0C\u5176\u4F59\u9636\u6BB5 45 \u5206\u949F\uFF09\u3002", default: "12" },
@@ -1254,6 +1303,13 @@ function systemString(envKey, configPath, fallback) {
     return cv;
   return fallback;
 }
+var EVO_LEVELS = ["L0", "L1", "L2", "L3"];
+function parseEvoLevel(raw) {
+  return EVO_LEVELS.includes(raw) ? raw : "L0";
+}
+function evoLevelRank(level) {
+  return EVO_LEVELS.indexOf(level);
+}
 var config = {
   // Goal entry points are retired, not the runtime. Internal/global-only, no UI:
   // set general.goal_mode_enabled in ~/.halo/secrets/settings.yaml, then restart.
@@ -1445,8 +1501,12 @@ var config = {
   // in settings.yaml take effect on the next ticker run without restart.
   evolution: {
     get level() {
-      const raw = settingsStr("general.evolution.level", "L0");
-      return raw === "L1" ? "L1" : "L0";
+      return parseEvoLevel(settingsStr("general.evolution.level", "L0"));
+    },
+    // Minimum average score for L2/L3 auto-apply (see evolution/auto-apply.ts
+    // for the extra fixed floors).
+    get autoApplyThreshold() {
+      return settingsInt("general.evolution.auto_apply_threshold", 80);
     },
     get maxConcurrentRun() {
       return settingsInt("general.evolution.max_concurrent_run", 1);
@@ -1477,6 +1537,477 @@ var config = {
   }
 };
 
+// ../server/dist/evolution/auto-apply.js
+import fs9 from "node:fs";
+import path12 from "node:path";
+import YAML6 from "yaml";
+var AUTO_APPLY_FILE = "auto-apply.json";
+var OVERRIDE_DIRS = /* @__PURE__ */ new Set(["agents", "skills", "prompts"]);
+function isDir(p) {
+  try {
+    return fs9.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readOrNull(p) {
+  try {
+    return fs9.readFileSync(p);
+  } catch {
+    return null;
+  }
+}
+function walkFiles(root, rel, out = []) {
+  let st;
+  try {
+    st = fs9.statSync(path12.join(root, rel));
+  } catch {
+    return out;
+  }
+  if (st.isFile())
+    out.push(rel);
+  else if (st.isDirectory()) {
+    for (const e of fs9.readdirSync(path12.join(root, rel)))
+      walkFiles(root, path12.join(rel, e), out);
+  }
+  return out;
+}
+var toPosix = (rel) => rel.split(path12.sep).join("/");
+function isInternalAgentDir(dir) {
+  const raw = readOrNull(path12.join(dir, "agent.yaml"));
+  return raw !== null && parseYamlLoose(raw.toString("utf-8"))?.internal === true;
+}
+function liveBaseline(dirs, rel) {
+  const parts = rel.split(path12.sep);
+  if (!OVERRIDE_DIRS.has(parts[0]) || parts.length < 3)
+    return { file: path12.join(dirs.mainHalo, rel), newDir: false };
+  const dirRel = path12.join(parts[0], parts[1]);
+  const internal = (root) => parts[0] === "agents" && isInternalAgentDir(path12.join(root, dirRel));
+  if (isDir(path12.join(dirs.mainHalo, dirRel)))
+    return { file: path12.join(dirs.mainHalo, rel), newDir: false, internalAgent: internal(dirs.mainHalo) };
+  if (isDir(path12.join(dirs.globalHalo, dirRel)))
+    return { file: path12.join(dirs.globalHalo, rel), newDir: false, globalDir: dirRel, internalAgent: internal(dirs.globalHalo) };
+  return { file: null, newDir: true };
+}
+function fileChange(rel, base, after) {
+  const before = base.file ? readOrNull(base.file) : null;
+  if (before && before.equals(after))
+    return null;
+  return {
+    rel: toPosix(rel),
+    before: before?.toString("utf-8") ?? null,
+    after: after.toString("utf-8"),
+    newDir: base.newDir,
+    ...base.internalAgent ? { internalAgent: true } : {}
+  };
+}
+function publishChanges(dirs, files) {
+  const out = [];
+  const globalBacked = /* @__PURE__ */ new Set();
+  for (const { rel, full } of files) {
+    const base = liveBaseline(dirs, rel);
+    if (base.globalDir)
+      globalBacked.add(base.globalDir);
+    const c = fileChange(rel, base, fs9.readFileSync(full));
+    if (c)
+      out.push(c);
+  }
+  for (const dirRel of globalBacked) {
+    for (const rel of walkFiles(dirs.globalHalo, dirRel)) {
+      if (fs9.existsSync(path12.join(dirs.sandboxHalo, rel)))
+        continue;
+      out.push({ rel: toPosix(rel), before: fs9.readFileSync(path12.join(dirs.globalHalo, rel), "utf-8"), after: null, newDir: false });
+    }
+  }
+  return out;
+}
+function collectChanges(dirs) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const globalBacked = /* @__PURE__ */ new Set();
+  for (const top of dirs.entries) {
+    for (const rel of walkFiles(dirs.sandboxHalo, top)) {
+      seen.add(rel);
+      const base = liveBaseline(dirs, rel);
+      if (base.globalDir)
+        globalBacked.add(base.globalDir);
+      const c = fileChange(rel, base, fs9.readFileSync(path12.join(dirs.sandboxHalo, rel)));
+      if (c)
+        out.push(c);
+    }
+    for (const rel of walkFiles(dirs.mainHalo, top)) {
+      if (seen.has(rel))
+        continue;
+      out.push({ rel: toPosix(rel), before: fs9.readFileSync(path12.join(dirs.mainHalo, rel), "utf-8"), after: null, newDir: false });
+    }
+  }
+  for (const dirRel of globalBacked) {
+    for (const rel of walkFiles(dirs.globalHalo, dirRel)) {
+      if (seen.has(rel))
+        continue;
+      out.push({ rel: toPosix(rel), before: fs9.readFileSync(path12.join(dirs.globalHalo, rel), "utf-8"), after: null, newDir: false });
+    }
+  }
+  return out;
+}
+var PROMPT_SCOPES = /* @__PURE__ */ new Set(["bootstrap", "all", "root"]);
+var EGRESS_TOOLS = /* @__PURE__ */ new Set(["shell_exec", "web_fetch", "relay_send", "a2a_send"]);
+var isEgressTool = (t) => EGRESS_TOOLS.has(t) || t.startsWith("node_");
+var AGENT_CAPABILITY_KEYS = /* @__PURE__ */ new Set(["description", "system_prompt", "context"]);
+var MODEL_CAPABILITY_KEYS = /* @__PURE__ */ new Set(["id", "maxTokens", "promptCaching", "thinking", "verbosity"]);
+var SKILL_PROMPT_KEYS = /* @__PURE__ */ new Set(["name", "description"]);
+var SKILL_CAPABILITY_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "disableModelInvocation", "user-invocable", "userInvocable"]);
+var manual = (rel, reason) => ({ rel, category: "manual", reason });
+function same(a, b) {
+  const canon = (v) => {
+    if (Array.isArray(v))
+      return v.map(canon);
+    if (v && typeof v === "object") {
+      return Object.fromEntries(Object.keys(v).sort().map((k) => [k, canon(v[k])]));
+    }
+    return v;
+  };
+  return JSON.stringify(canon(a)) === JSON.stringify(canon(b));
+}
+function asRecord(v) {
+  if (v === void 0 || v === null)
+    return {};
+  return typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function parseYamlRecord(text2) {
+  try {
+    return asRecord(YAML6.parse(text2));
+  } catch {
+    return null;
+  }
+}
+function classifyAgentYaml(rel, before, after) {
+  const a = parseYamlRecord(before);
+  const b = parseYamlRecord(after);
+  if (!a || !b)
+    return manual(rel, "agent_yaml_unparsable");
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])) {
+    if (same(a[key], b[key]) || AGENT_CAPABILITY_KEYS.has(key))
+      continue;
+    if (key === "tools") {
+      if (b.tools !== void 0 && !Array.isArray(b.tools) || a.tools !== void 0 && !Array.isArray(a.tools)) {
+        return manual(rel, "agent_yaml:tools");
+      }
+      const had = new Set((a.tools ?? []).map(String));
+      const egress = (b.tools ?? []).map(String).find((t) => !had.has(t) && isEgressTool(t));
+      if (egress)
+        return manual(rel, `agent_yaml:tools+${egress}`);
+      continue;
+    }
+    if (key === "skills") {
+      if (b.skills !== void 0 && !Array.isArray(b.skills) || a.skills !== void 0 && !Array.isArray(a.skills)) {
+        return manual(rel, "agent_yaml:skills");
+      }
+      const had = new Set((a.skills ?? []).map(String));
+      const added = (b.skills ?? []).map(String).find((s) => !had.has(s));
+      if (added)
+        return manual(rel, `agent_yaml:skills+${added}`);
+      continue;
+    }
+    if (key === "model") {
+      const ma = asRecord(a.model);
+      const mb = asRecord(b.model);
+      if (!ma || !mb)
+        return manual(rel, "agent_yaml:model");
+      for (const mk of /* @__PURE__ */ new Set([...Object.keys(ma), ...Object.keys(mb)])) {
+        if (!same(ma[mk], mb[mk]) && !MODEL_CAPABILITY_KEYS.has(mk))
+          return manual(rel, `agent_yaml:model.${mk}`);
+      }
+      continue;
+    }
+    return manual(rel, `agent_yaml:${key}`);
+  }
+  return { rel, category: "capability" };
+}
+function parseYamlLoose(text2) {
+  let v;
+  try {
+    v = YAML6.parse(text2);
+  } catch {
+    return void 0;
+  }
+  return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+function splitSkillMd(raw) {
+  const m = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
+  if (!m)
+    return { fm: {}, body: raw.trim() };
+  const block = m[1];
+  const fm = parseYamlLoose(block) ?? parseYamlLoose(block.replace(/^(name|description|command):.*$/gm, ""));
+  if (!fm)
+    return null;
+  for (const key of ["name", "description", "command"]) {
+    const lm = block.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+    if (lm)
+      fm[key] = lm[1].trim();
+    else
+      delete fm[key];
+  }
+  return { fm, body: raw.slice(m[0].length).trim() };
+}
+var normAccess = (v) => {
+  const t = typeof v === "string" ? v.trim() : "";
+  return t === "full" || t === "workspace" || t === "readonly" ? t : null;
+};
+function verbAccess(fm) {
+  const objectAccess = normAccess(fm.requiresAccess);
+  const out = {};
+  for (const v of Array.isArray(fm.verbs) ? fm.verbs : []) {
+    const o = asRecord(v);
+    if (!o || typeof o.name !== "string")
+      continue;
+    out[o.name.trim()] = normAccess(o.requiresAccess) ?? objectAccess;
+  }
+  return out;
+}
+function classifySkillMd(rel, before, after) {
+  const a = splitSkillMd(before);
+  const b = splitSkillMd(after);
+  if (!a || !b)
+    return manual(rel, "skill_frontmatter_unparsable");
+  let category = "prompt";
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(a.fm), ...Object.keys(b.fm)])) {
+    if (same(a.fm[key], b.fm[key]) || SKILL_PROMPT_KEYS.has(key))
+      continue;
+    if (SKILL_CAPABILITY_KEYS.has(key)) {
+      category = "capability";
+      continue;
+    }
+    if (key === "verbs") {
+      if (!same(verbAccess(a.fm), verbAccess(b.fm)))
+        return manual(rel, "skill_fm:verbs.requiresAccess");
+      category = "capability";
+      continue;
+    }
+    return manual(rel, `skill_fm:${key}`);
+  }
+  return { rel, category };
+}
+function classifyChange(c) {
+  const parts = c.rel.split("/");
+  const [top, id] = parts;
+  if (c.after === null)
+    return manual(c.rel, "deleted");
+  if (parts.length === 1) {
+    if (top === "INSTRUCTIONS.md" || top === "INDEX.md")
+      return { rel: c.rel, category: "prompt" };
+    if (top === "USER.md")
+      return manual(c.rel, "user_md");
+    return manual(c.rel, "unrecognized");
+  }
+  if (top === "agents" && parts.length >= 3) {
+    if (c.internalAgent || id.startsWith("__"))
+      return manual(c.rel, "internal_agent");
+    if (c.newDir)
+      return manual(c.rel, "new_agent");
+    if (parts.length === 3 && parts[2] === "AGENT.md")
+      return { rel: c.rel, category: "prompt" };
+    if (parts.length === 3 && parts[2] === "agent.yaml") {
+      return c.before === null ? manual(c.rel, "new_file") : classifyAgentYaml(c.rel, c.before, c.after);
+    }
+    return manual(c.rel, "agent_extra_file");
+  }
+  if (top === "skills" && parts.length >= 3) {
+    if (c.newDir)
+      return manual(c.rel, "new_skill");
+    if (parts.length === 3 && parts[2] === "SKILL.md") {
+      return c.before === null ? manual(c.rel, "new_file") : classifySkillMd(c.rel, c.before, c.after);
+    }
+    return manual(c.rel, "skill_extra_file");
+  }
+  if (top === "prompts" && parts.length === 3 && PROMPT_SCOPES.has(id) && parts[2].endsWith(".md")) {
+    return { rel: c.rel, category: "prompt" };
+  }
+  return manual(c.rel, "unrecognized");
+}
+var CATEGORY_RANK = { prompt: 0, capability: 1, manual: 2 };
+function classifyChanges(changes) {
+  const files = changes.map(classifyChange);
+  let category = "none";
+  for (const f of files) {
+    if (category === "none" || CATEGORY_RANK[f.category] > CATEGORY_RANK[category])
+      category = f.category;
+  }
+  return { category, files };
+}
+var AUTO_APPLY_BEHAVIOR_FLOOR = 70;
+var AUTO_APPLY_LINT_REQUIRED = 100;
+var REQUIRED_CHECKS = {
+  patchInSandbox: "pass",
+  usedInDryRun: "yes",
+  probe: "valid",
+  probeLanguage: "same"
+};
+function parseScore(raw) {
+  const r = asRecord(raw);
+  if (!r)
+    return null;
+  const { lint, behavior, scope, confidence } = r;
+  if (![lint, behavior, scope].every((n) => typeof n === "number" && Number.isFinite(n)))
+    return null;
+  if (typeof confidence !== "string")
+    return null;
+  const [l, b, s] = [lint, behavior, scope];
+  return { lint: l, behavior: b, scope: s, avg: Math.round((l + b + s) / 3), confidence, checks: asRecord(r.checks) ?? {} };
+}
+function readScore(file) {
+  try {
+    return parseScore(JSON.parse(fs9.readFileSync(file, "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function categoryGate(level, cls) {
+  const rank = evoLevelRank(level);
+  if (rank < 2)
+    return "level";
+  if (cls.category === "none")
+    return "no_effective_change";
+  if (cls.category === "manual") {
+    const f = cls.files.find((x) => x.category === "manual");
+    return `category_manual:${f.rel}${f.reason ? `(${f.reason})` : ""}`;
+  }
+  if (cls.category === "capability" && rank < 3)
+    return "level";
+  return null;
+}
+function sourceGate(sourceAccess) {
+  if (sourceAccess === SOURCE_WEBHOOK)
+    return "source_webhook";
+  return sourceAccess === "full" ? null : "source_access";
+}
+var SOURCE_WEBHOOK = "webhook";
+function scoreGate(score, threshold) {
+  if (!score)
+    return "score_missing";
+  if (score.avg < threshold)
+    return "below_threshold";
+  if (score.confidence !== "high")
+    return "confidence";
+  if (score.behavior < AUTO_APPLY_BEHAVIOR_FLOOR)
+    return "behavior_floor";
+  if (score.lint !== AUTO_APPLY_LINT_REQUIRED)
+    return "lint_floor";
+  for (const [name, want] of Object.entries(REQUIRED_CHECKS)) {
+    if (score.checks[name] !== want)
+      return `checks:${name}`;
+  }
+  return null;
+}
+function decideAutoApply(input) {
+  const reason = (evoLevelRank(input.level) >= 2 ? sourceGate(input.sourceAccess) : null) ?? categoryGate(input.level, input.classification) ?? scoreGate(input.score, input.threshold);
+  return { auto: reason === null, reason };
+}
+function evaluateSandbox(input) {
+  const classification = classifyChanges(collectChanges(input));
+  const { auto, reason } = decideAutoApply({ level: input.level, threshold: input.threshold, sourceAccess: input.sourceAccess, classification, score: input.score });
+  const sc = input.score;
+  return {
+    decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    level: input.level,
+    threshold: input.threshold,
+    sourceAccess: input.sourceAccess,
+    category: classification.category,
+    files: classification.files,
+    auto,
+    reason,
+    score: sc ? { lint: sc.lint, behavior: sc.behavior, scope: sc.scope, avg: sc.avg, confidence: sc.confidence } : null,
+    observation: input.observation
+  };
+}
+var OBSERVATION_MAX_CHARS = 2e3;
+function extractLargerObservation(md) {
+  const lines = md.split(/\r?\n/);
+  const start = lines.findIndex((l) => /^#{2,3}\s+Larger observation\s*:?\s*$/i.test(l));
+  if (start < 0)
+    return null;
+  const level = lines[start].match(/^#+/)[0].length;
+  const stop = new RegExp(`^#{1,${level}}\\s`);
+  const body = [];
+  for (const l of lines.slice(start + 1)) {
+    if (stop.test(l))
+      break;
+    body.push(l);
+  }
+  const text2 = body.join("\n").trim();
+  return text2 ? text2.slice(0, OBSERVATION_MAX_CHARS) : null;
+}
+function readObservation(file) {
+  try {
+    return extractLargerObservation(fs9.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// ../server/dist/evolution/queue-apply.js
+import { and, eq, sql } from "drizzle-orm";
+var BLOCKING_APPLY_STATUSES = ["pending", "running", "syncing", "applied"];
+function queueApply(db, input) {
+  const applyId = `apply-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  class Blocked extends Error {
+    reason;
+    constructor(reason) {
+      super(reason);
+      this.reason = reason;
+    }
+  }
+  try {
+    return db.transaction((tx) => {
+      const fromState = input.mode === "reviewer" ? eq(evolutionRuns.status, "awaiting_review") : and(eq(evolutionRuns.status, "running"), eq(evolutionRuns.attempts, input.attempts));
+      const flipped = tx.update(evolutionRuns).set(input.mode === "auto" ? { status: "approved", completedAt: Date.now(), failureReason: null } : { status: "approved" }).where(and(eq(evolutionRuns.id, input.runId), fromState)).returning({ workspacePath: evolutionRuns.workspacePath }).all();
+      if (flipped.length === 0)
+        throw new Blocked("state");
+      const existing = tx.select({ id: evolutionApplies.id }).from(evolutionApplies).where(and(sql`EXISTS (SELECT 1 FROM json_each(${evolutionApplies.sourceRunIds}) WHERE value = ${input.runId})`, sql`${evolutionApplies.status} IN (${sql.join(BLOCKING_APPLY_STATUSES.map((s) => sql`${s}`), sql`, `)})`)).get();
+      if (existing)
+        throw new Blocked("apply_exists");
+      tx.insert(evolutionApplies).values({
+        id: applyId,
+        workspacePath: flipped[0].workspacePath,
+        status: "pending",
+        sourceRunIds: JSON.stringify([input.runId]),
+        reviewerHint: input.mode === "reviewer" ? input.reviewerHint ?? null : null,
+        createdAt: Date.now(),
+        approvedBy: input.mode
+      }).run();
+      return { ok: true, applyId, workspacePath: flipped[0].workspacePath };
+    });
+  } catch (err) {
+    if (err instanceof Blocked)
+      return { ok: false, reason: err.reason };
+    throw err;
+  }
+}
+function failApply(db, applyId, input) {
+  return db.transaction((tx) => {
+    const rows = tx.update(evolutionApplies).set({ status: input.status, failureReason: input.failureReason, completedAt: Date.now() }).where(and(eq(evolutionApplies.id, applyId), input.onlyIfStatus !== void 0 ? eq(evolutionApplies.status, input.onlyIfStatus) : void 0, input.onlyIfAttempts !== void 0 ? eq(evolutionApplies.attempts, input.onlyIfAttempts) : void 0)).returning({ approvedBy: evolutionApplies.approvedBy, sourceRunIds: evolutionApplies.sourceRunIds }).all();
+    if (rows.length === 0)
+      return { failed: false, revertedRunIds: [] };
+    const revertedRunIds = [];
+    if (rows[0].approvedBy === "auto") {
+      for (const runId of JSON.parse(rows[0].sourceRunIds)) {
+        const r = tx.update(evolutionRuns).set({ status: "awaiting_review" }).where(and(eq(evolutionRuns.id, runId), eq(evolutionRuns.status, "approved"))).run();
+        if (r.changes > 0)
+          revertedRunIds.push(runId);
+      }
+    }
+    return { failed: true, revertedRunIds };
+  });
+}
+
+// ../server/dist/evolution/rollback.js
+import fs10 from "node:fs";
+import { createHash } from "node:crypto";
+import { and as and2, eq as eq2, inArray } from "drizzle-orm";
+function sha256File(file) {
+  return createHash("sha256").update(fs10.readFileSync(file)).digest("hex");
+}
+
 // ../server/dist/evolution/evo-wrapper.js
 var FIX_BUDGET = 1;
 var DRY_RUN_TIMEOUT_SEC = 2700;
@@ -1507,8 +2038,10 @@ function loadRunRow(id) {
     workspacePath: evolutionRuns.workspacePath,
     triggerKind: evolutionRuns.triggerKind,
     sourceSession: evolutionRuns.sourceSession,
-    userHint: evolutionRuns.userHint
-  }).from(evolutionRuns).where(eq(evolutionRuns.id, id)).get();
+    userHint: evolutionRuns.userHint,
+    attempts: evolutionRuns.attempts,
+    sourceAccess: evolutionRuns.sourceAccess
+  }).from(evolutionRuns).where(eq3(evolutionRuns.id, id)).get();
   if (!row)
     throw new Error(`evolution_runs row not found: ${id}`);
   return row;
@@ -1518,11 +2051,23 @@ function resolveHaloCli() {
     return process.env.HALO_CLI;
   return process.platform === "win32" ? "halo.cmd" : "halo";
 }
+var liveProcs = /* @__PURE__ */ new Set();
+var KILL_GRACE_MS = 1e4;
+var stopping = false;
+function resetStoppingForTests() {
+  stopping = false;
+}
 function spawnProc(bin, args, logFd, teePath, stdinInput, timeoutSec) {
   const loggedArgs = stdinInput === void 0 ? args.slice(0, -1) : args;
+  if (stopping) {
+    writeLog(logFd, `[wrapper] stopping (claim lost) \u2014 not spawning ${bin}
+`);
+    return new Promise(() => {
+    });
+  }
   writeLog(logFd, `[wrapper] $ ${bin} ${loggedArgs.join(" ")}${stdinInput === void 0 ? " <last-arg-omitted>" : " <prompt-on-stdin>"}${timeoutSec ? ` (timeout ${timeoutSec}s)` : ""}
 `);
-  const tee = teePath ? fs9.createWriteStream(teePath, { flags: "a" }) : null;
+  const tee = teePath ? fs11.createWriteStream(teePath, { flags: "a" }) : null;
   const [spawnBin, spawnArgs] = process.platform === "win32" && bin.endsWith(".cmd") ? ["cmd.exe", ["/c", bin, ...args]] : [bin, args];
   return new Promise((resolve) => {
     const child = spawn2(spawnBin, spawnArgs, {
@@ -1563,16 +2108,17 @@ function spawnProc(bin, args, logFd, teePath, stdinInput, timeoutSec) {
       } catch {
       }
     };
+    liveProcs.add(killTree);
     const killTimer = timeoutSec ? setTimeout(() => {
       timedOut = true;
       writeLog(logFd, `[wrapper] timeout ${timeoutSec}s \u2014 killing process group (SIGTERM)
 `);
       killTree("SIGTERM");
       sigkillTimer = setTimeout(() => {
-        writeLog(logFd, `[wrapper] still alive 10s after SIGTERM \u2014 SIGKILL
+        writeLog(logFd, `[wrapper] still alive ${KILL_GRACE_MS / 1e3}s after SIGTERM \u2014 SIGKILL
 `);
         killTree("SIGKILL");
-      }, 1e4);
+      }, KILL_GRACE_MS);
       sigkillTimer.unref?.();
     }, timeoutSec * 1e3) : null;
     child.stdout?.on("data", (chunk) => {
@@ -1584,6 +2130,7 @@ function spawnProc(bin, args, logFd, teePath, stdinInput, timeoutSec) {
       tee?.write(chunk);
     });
     child.on("exit", (code, signal) => {
+      liveProcs.delete(killTree);
       if (killTimer)
         clearTimeout(killTimer);
       if (sigkillTimer)
@@ -1592,9 +2139,12 @@ function spawnProc(bin, args, logFd, teePath, stdinInput, timeoutSec) {
       writeLog(logFd, `[wrapper] proc exit code=${code} signal=${signal}${timedOut ? " (timed out \u2192 124)" : ""} stdout=${stdout.length}B stderr=${stderr.length}B
 `);
       tee?.end();
+      if (stopping)
+        return;
       resolve({ exitCode, stdout, stderr });
     });
     child.on("error", (err) => {
+      liveProcs.delete(killTree);
       if (killTimer)
         clearTimeout(killTimer);
       if (sigkillTimer)
@@ -1605,17 +2155,19 @@ function spawnProc(bin, args, logFd, teePath, stdinInput, timeoutSec) {
 [spawn error] ${err.message}
 `);
       tee?.end();
+      if (stopping)
+        return;
       resolve({ exitCode: 1, stdout, stderr: stderr + `
 [spawn error] ${err.message}` });
     });
   });
 }
 function subCliLogPath(runDir) {
-  return path12.join(runDir, "sub-cli.log");
+  return path13.join(runDir, "sub-cli.log");
 }
 function appendSubCliHeader(runDir, header) {
   try {
-    fs9.appendFileSync(subCliLogPath(runDir), `
+    fs11.appendFileSync(subCliLogPath(runDir), `
 === ${(/* @__PURE__ */ new Date()).toISOString()} ${header} ===
 `);
   } catch {
@@ -1649,10 +2201,10 @@ function buildLanguageClause(langHint, scope) {
   ];
 }
 function readPatchFrontmatter(runDir) {
-  const patchPath = path12.join(runDir, "patch.md");
+  const patchPath = path13.join(runDir, "patch.md");
   let raw;
   try {
-    raw = fs9.readFileSync(patchPath, "utf-8");
+    raw = fs11.readFileSync(patchPath, "utf-8");
   } catch {
     return null;
   }
@@ -1660,7 +2212,7 @@ function readPatchFrontmatter(runDir) {
   if (!m)
     return null;
   try {
-    const parsed = YAML6.parse(m[1]);
+    const parsed = YAML7.parse(m[1]);
     return parsed ?? null;
   } catch {
     return null;
@@ -1682,14 +2234,14 @@ function extractTestScenario(fm) {
   return { agentId: o.agentId, testMessage, originalMessage };
 }
 function readEvoContext(runDir, logFd) {
-  const p = path12.join(runDir, "evo-context.json");
-  if (!fs9.existsSync(p)) {
+  const p = path13.join(runDir, "evo-context.json");
+  if (!fs11.existsSync(p)) {
     writeLog(logFd, `[brief] evo-context.json missing at ${p}
 `);
     return null;
   }
   try {
-    return JSON.parse(fs9.readFileSync(p, "utf-8"));
+    return JSON.parse(fs11.readFileSync(p, "utf-8"));
   } catch (err) {
     writeLog(logFd, `[brief] evo-context.json parse failed: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -1697,12 +2249,12 @@ function readEvoContext(runDir, logFd) {
   }
 }
 function dumpSnapshotImages(runDir, logFd) {
-  const snapshotPath = path12.join(runDir, "source-snapshot.json");
-  if (!fs9.existsSync(snapshotPath))
+  const snapshotPath = path13.join(runDir, "source-snapshot.json");
+  if (!fs11.existsSync(snapshotPath))
     return [];
   let parsed;
   try {
-    parsed = JSON.parse(fs9.readFileSync(snapshotPath, "utf-8"));
+    parsed = JSON.parse(fs11.readFileSync(snapshotPath, "utf-8"));
   } catch {
     writeLog(logFd, `[dumpSnapshotImages] snapshot parse failed
 `);
@@ -1711,8 +2263,8 @@ function dumpSnapshotImages(runDir, logFd) {
   const messages = Array.isArray(parsed.rawMessages) ? parsed.rawMessages : [];
   if (messages.length === 0)
     return [];
-  const imagesDir = path12.join(runDir, "images");
-  fs9.mkdirSync(imagesDir, { recursive: true });
+  const imagesDir = path13.join(runDir, "images");
+  fs11.mkdirSync(imagesDir, { recursive: true });
   const out = [];
   const extByMime = {
     "image/png": "png",
@@ -1751,10 +2303,10 @@ function dumpSnapshotImages(runDir, logFd) {
           continue;
         const ext = extByMime[mediaType] ?? "bin";
         const fileName = c.subBlockIdx == null ? `${m}-${b}.${ext}` : `${m}-${b}-${c.subBlockIdx}.${ext}`;
-        const fullPath = path12.join(imagesDir, fileName);
+        const fullPath = path13.join(imagesDir, fileName);
         try {
           const buf = Buffer.from(data, "base64");
-          fs9.writeFileSync(fullPath, buf);
+          fs11.writeFileSync(fullPath, buf);
           out.push({
             relPath: `images/${fileName}`,
             msgIdx: m,
@@ -1841,15 +2393,15 @@ function renderEvoContextSections(ctx) {
     lines.push("");
   }
   if (ctx.skills.length > 0) {
-    const globalSkillsDir = path12.join(homedir6(), ".halo", "global", "skills");
+    const globalSkillsDir = path13.join(homedir6(), ".halo", "global", "skills");
     lines.push("=== Skills in this workspace ===");
     for (const s of ctx.skills)
       lines.push(`  ${s.id} [${s.scope}]`);
     lines.push("");
     lines.push("To read a skill's content, file_read its SKILL.md (you have full");
     lines.push("file access \u2014 absolute paths resolve):");
-    lines.push(`  [workspace] \u2192 ${path12.join("<workspace>", ".halo", "skills", "<id>", "SKILL.md")}`);
-    lines.push(`  [global] / [builtin] \u2192 ${path12.join(globalSkillsDir, "<id>", "SKILL.md")}`);
+    lines.push(`  [workspace] \u2192 ${path13.join("<workspace>", ".halo", "skills", "<id>", "SKILL.md")}`);
+    lines.push(`  [global] / [builtin] \u2192 ${path13.join(globalSkillsDir, "<id>", "SKILL.md")}`);
     lines.push("A [global]/[builtin] skill is NOT inside your sandbox \u2014 read it");
     lines.push(`from ${globalSkillsDir} directly; don't glob the sandbox for it.`);
     lines.push("Sibling resource files live next to SKILL.md in that same dir.");
@@ -1872,13 +2424,13 @@ function buildDraftBrief(args) {
   ];
   if (args.userHint)
     lines.push(`Reviewer hint: ${args.userHint}`);
-  lines.push("", "The triggering agent's full message log lives on disk:", `  ${path12.join(args.runDir, "tool-flow.md")}        \u2014 clipped, fast skim`, `  ${path12.join(args.runDir, "source-snapshot.json")}    \u2014 full rawMessages`, "", "Read tool-flow.md first to understand what the user wanted, what the", "agent did, and where it diverged. Each tool_result is clipped to a", "~200-char peek (with the `is_error` flag when the tool failed) \u2014", "enough to see the *shape* of the flow without re-tokenizing large", "grep / shell outputs. Fall back to source-snapshot.json only for", "messages whose full tool result actually matters to your patch.", "", ...renderEvoContextSections(args.evoContext), ...renderImageManifest(args.images), "=== Non-text media note ===", "", "Inline images in source-snapshot.json are base64 \u2014 you can't read them", "directly. The `images/` dump", "(see manifest above) decodes them to disk so you can `view_image` if", "a specific image is load-bearing. Video, audio, and binary documents", "(PDF, etc.) are even more limited: at trigger time the source agent", "worked with them via shell tooling (ffmpeg, pdftotext, etc.), and your", "view is limited to the textual results those tools produced (visible", "inside source-snapshot.json as tool_result text).", "", "When the patch you have in mind requires understanding what's INSIDE", "the media file (a video's visual content, an audio's acoustic", "content, a PDF's layout), the dry-run test scenario can't reliably", "verify it \u2014 skipping the run is the right call. When the patch is", "about the shell-tooling pattern itself (how to call ffmpeg, how to", "grep its output, how to handle credential errors), it can be", "verified at the textual level and the run proceeds normally.", "", "=== Task ===", "", "Decide what change in the prompt surface above would help the next time", "a similar conversation comes up. Three shapes, in order of preference:", "rewrite an existing rule; tighten / reorganize what's there; or, only", "when neither applies, add a new rule.", "", `Sandbox path: ${evoSandboxDir(args.runDir)}`, "", `When you have a change worth making, write ${path12.join(args.runDir, "patch.md")}`, "(frontmatter + body) and one new file at", `${evoSandboxHaloDir(args.runDir)}/<target> with the`, "full new contents. AGENT.md describes the patch.md schema.", "", "When the conversation has no signal worth a patch (rule already covers,", "too short to learn from, agent did fine, depends on media content", `you can't see), write ${path12.join(args.runDir, ".skip.md")} with a`, "one or two sentence reason instead, and skip the rest.", "", ...buildLanguageClause(args.langHint, "all natural-language content (patch.md body, prose drafted into sandbox files, .skip.md body)"));
+  lines.push("", "The triggering agent's full message log lives on disk:", `  ${path13.join(args.runDir, "tool-flow.md")}        \u2014 clipped, fast skim`, `  ${path13.join(args.runDir, "source-snapshot.json")}    \u2014 full rawMessages`, "", "Read tool-flow.md first to understand what the user wanted, what the", "agent did, and where it diverged. Each tool_result is clipped to a", "~200-char peek (with the `is_error` flag when the tool failed) \u2014", "enough to see the *shape* of the flow without re-tokenizing large", "grep / shell outputs. Fall back to source-snapshot.json only for", "messages whose full tool result actually matters to your patch.", "", ...renderEvoContextSections(args.evoContext), ...renderImageManifest(args.images), "=== Non-text media note ===", "", "Inline images in source-snapshot.json are base64 \u2014 you can't read them", "directly. The `images/` dump", "(see manifest above) decodes them to disk so you can `view_image` if", "a specific image is load-bearing. Video, audio, and binary documents", "(PDF, etc.) are even more limited: at trigger time the source agent", "worked with them via shell tooling (ffmpeg, pdftotext, etc.), and your", "view is limited to the textual results those tools produced (visible", "inside source-snapshot.json as tool_result text).", "", "When the patch you have in mind requires understanding what's INSIDE", "the media file (a video's visual content, an audio's acoustic", "content, a PDF's layout), the dry-run test scenario can't reliably", "verify it \u2014 skipping the run is the right call. When the patch is", "about the shell-tooling pattern itself (how to call ffmpeg, how to", "grep its output, how to handle credential errors), it can be", "verified at the textual level and the run proceeds normally.", "", "=== Task ===", "", "Decide what change in the prompt surface above would help the next time", "a similar conversation comes up. Three shapes, in order of preference:", "rewrite an existing rule; tighten / reorganize what's there; or, only", "when neither applies, add a new rule.", "", `Sandbox path: ${evoSandboxDir(args.runDir)}`, "", `When you have a change worth making, write ${path13.join(args.runDir, "patch.md")}`, "(frontmatter + body) and one new file at", `${evoSandboxHaloDir(args.runDir)}/<target> with the`, "full new contents. AGENT.md describes the patch.md schema.", "", "When the conversation has no signal worth a patch (rule already covers,", "too short to learn from, agent did fine, depends on media content", `you can't see), write ${path13.join(args.runDir, ".skip.md")} with a`, "one or two sentence reason instead, and skip the rest.", "", ...buildLanguageClause(args.langHint, "all natural-language content (patch.md body, prose drafted into sandbox files, .skip.md body)"));
   return lines.join("\n");
 }
 function buildFixBrief(args) {
   let failLogText = "";
   try {
-    failLogText = fs9.readFileSync(args.failLogPath, "utf-8");
+    failLogText = fs11.readFileSync(args.failLogPath, "utf-8");
   } catch {
     failLogText = `(failed to read ${args.failLogPath})`;
   }
@@ -1893,7 +2445,7 @@ function buildFixBrief(args) {
     `Fix attempt: ${args.attempt}/${args.maxAttempts}`,
     "",
     `An earlier draft pass produced patch.md + a sandbox at`,
-    `${path12.join(args.runDir, "patch.md")} and`,
+    `${path13.join(args.runDir, "patch.md")} and`,
     `${evoSandboxHaloDir(args.runDir)} respectively.`,
     "The dry-run failed; the wrapper's failure log:",
     "",
@@ -1914,16 +2466,16 @@ function buildFixBrief(args) {
 function buildScoreBrief(args) {
   function readOrEmpty(p, label) {
     try {
-      return fs9.readFileSync(p, "utf-8");
+      return fs11.readFileSync(p, "utf-8");
     } catch (err) {
       writeLog(args.logFd, `[buildScoreBrief] ${label} read failed: ${err instanceof Error ? err.message : String(err)}
 `);
       return `(${label} unavailable)`;
     }
   }
-  const patchMd = readOrEmpty(path12.join(args.runDir, "patch.md"), "patch.md");
-  const dryRun = readOrEmpty(path12.join(args.runDir, "dry-run-output.txt"), "dry-run-output.txt");
-  const meta = readOrEmpty(path12.join(args.runDir, "meta.json"), "meta.json");
+  const patchMd = readOrEmpty(path13.join(args.runDir, "patch.md"), "patch.md");
+  const dryRun = readOrEmpty(path13.join(args.runDir, "dry-run-output.txt"), "dry-run-output.txt");
+  const meta = readOrEmpty(path13.join(args.runDir, "meta.json"), "meta.json");
   return [
     "You are running as the Evolution scorer.",
     "",
@@ -1934,8 +2486,8 @@ function buildScoreBrief(args) {
     "write score.json with the absolute path given below)",
     "",
     `The original conversation lives on disk:`,
-    `  ${path12.join(args.runDir, "tool-flow.md")}    \u2014 clipped, fast skim`,
-    `  ${path12.join(args.runDir, "source-snapshot.json")}  \u2014 full rawMessages, when needed`,
+    `  ${path13.join(args.runDir, "tool-flow.md")}    \u2014 clipped, fast skim`,
+    `  ${path13.join(args.runDir, "source-snapshot.json")}  \u2014 full rawMessages, when needed`,
     "Read tool-flow.md first to find the user turn matching",
     "`testScenario.originalMessage` and the assistant reply that followed",
     "it. Fall back to source-snapshot.json only when the full tool result",
@@ -1985,7 +2537,7 @@ function buildScoreBrief(args) {
     "find the assistant turn that followed it in tool-flow.md (or",
     "source-snapshot.json) \u2014 that's your baseline. Compare baseline to",
     "dry-run-output.txt, rate lint / behavior / scope, write",
-    `${path12.join(args.runDir, "score.json")} with the shape AGENT.md describes.`,
+    `${path13.join(args.runDir, "score.json")} with the shape AGENT.md describes.`,
     "",
     ...buildLanguageClause(args.langHint, 'the score.json "notes" field'),
     'The numeric fields and "confidence" enum stay in their canonical form.'
@@ -2028,14 +2580,14 @@ async function phaseDraft(args) {
   return outcome;
 }
 function judgeDraft(runDir, workspacePath, exitCode) {
-  if (fs9.existsSync(path12.join(runDir, ".skip.md"))) {
+  if (fs11.existsSync(path13.join(runDir, ".skip.md"))) {
     return { outcome: "skipped", why: ".skip.md present \u2014 evo declared skip" };
   }
   if (exitCode !== 0) {
     const timeout = exitCode === 124 ? " (timeout)" : "";
     return { outcome: "failed", why: `drafter exited ${exitCode}${timeout} \u2014 draft interrupted, not trusted` };
   }
-  if (!fs9.existsSync(path12.join(runDir, "patch.md"))) {
+  if (!fs11.existsSync(path13.join(runDir, "patch.md"))) {
     return { outcome: "failed", why: "patch.md missing" };
   }
   const target = readPatchFrontmatter(runDir)?.target;
@@ -2043,16 +2595,16 @@ function judgeDraft(runDir, workspacePath, exitCode) {
     return { outcome: "drafted", why: "patch.md present, no target in frontmatter \u2014 target file not checked" };
   }
   const sandboxDir = evoSandboxDir(runDir);
-  const rel = path12.relative(sandboxDir, path12.resolve(sandboxDir, target));
-  if (!rel.startsWith(".halo" + path12.sep)) {
+  const rel = path13.relative(sandboxDir, path13.resolve(sandboxDir, target));
+  if (!rel.startsWith(".halo" + path13.sep)) {
     return { outcome: "failed", why: `target ${JSON.stringify(target)} does not resolve under sandbox/.halo/` };
   }
-  const sandboxFile = path12.join(sandboxDir, rel);
-  if (!fs9.statSync(sandboxFile, { throwIfNoEntry: false })?.isFile()) {
+  const sandboxFile = path13.join(sandboxDir, rel);
+  if (!fs11.statSync(sandboxFile, { throwIfNoEntry: false })?.isFile()) {
     return { outcome: "failed", why: `target not written to sandbox: ${target}` };
   }
-  const wsFile = path12.join(workspacePath, rel);
-  if (fs9.statSync(wsFile, { throwIfNoEntry: false })?.isFile() && fs9.readFileSync(wsFile).equals(fs9.readFileSync(sandboxFile))) {
+  const wsFile = path13.join(workspacePath, rel);
+  if (fs11.statSync(wsFile, { throwIfNoEntry: false })?.isFile() && fs11.readFileSync(wsFile).equals(fs11.readFileSync(sandboxFile))) {
     return { outcome: "failed", why: `target unchanged from workspace: ${target}` };
   }
   return { outcome: "drafted", why: `patch.md + target ${target} present` };
@@ -2079,15 +2631,15 @@ async function phaseDryRun(args) {
 }
 async function tryDryRun(args, attemptIndex) {
   const sandboxDir = evoSandboxDir(args.runDir);
-  const outputPath = path12.join(args.runDir, "dry-run-output.txt");
-  const failLogPath = path12.join(args.runDir, `dry-run-fail-${attemptIndex}.log`);
+  const outputPath = path13.join(args.runDir, "dry-run-output.txt");
+  const failLogPath = path13.join(args.runDir, `dry-run-fail-${attemptIndex}.log`);
   const cli = resolveHaloCli();
   const fm = readPatchFrontmatter(args.runDir);
   const scenario = extractTestScenario(fm);
   if (!scenario) {
     writeLog(args.logFd, `[tryDryRun:${attemptIndex}] patch.md frontmatter missing testScenario.{agentId, testMessage}
 `);
-    fs9.writeFileSync(failLogPath, "patch.md frontmatter missing testScenario.{agentId, testMessage} \u2014 wrapper cannot run dry-run without it.\n", "utf-8");
+    fs11.writeFileSync(failLogPath, "patch.md frontmatter missing testScenario.{agentId, testMessage} \u2014 wrapper cannot run dry-run without it.\n", "utf-8");
     return { kind: "no-scenario", failLogPath };
   }
   writeLog(args.logFd, `[tryDryRun:${attemptIndex}] agent=${scenario.agentId} testMessage=${JSON.stringify(scenario.testMessage).slice(0, 200)}
@@ -2105,14 +2657,14 @@ async function tryDryRun(args, attemptIndex) {
   const timedOut = result.exitCode === 124;
   const ok = result.exitCode === 0 && result.stdout.trim().length > 0;
   if (ok) {
-    fs9.writeFileSync(outputPath, result.stdout, "utf-8");
+    fs11.writeFileSync(outputPath, result.stdout, "utf-8");
     writeLog(args.logFd, `[tryDryRun:${attemptIndex}] success: wrote ${outputPath} (${result.stdout.length}B)
 `);
     return { kind: "ok" };
   }
   const stdoutTail = result.stdout.length > 4e3 ? "\u2026" + result.stdout.slice(-4e3) : result.stdout;
   const stderrTail = result.stderr.length > 4e3 ? "\u2026" + result.stderr.slice(-4e3) : result.stderr;
-  fs9.writeFileSync(failLogPath, [
+  fs11.writeFileSync(failLogPath, [
     `Wrapper command:  halo cli -a ${scenario.agentId} -n -w ${sandboxDir} <testMessage>`,
     `Test message:     ${scenario.testMessage}`,
     `Exit code:        ${result.exitCode}${timedOut ? " (timeout)" : ""}`,
@@ -2168,6 +2720,7 @@ async function phaseScore(args) {
   const sandboxWs = evoSandboxDir(args.runDir);
   buildEvoSandbox(args.workspacePath, args.runDir, args.logFd);
   const cliArgs = ["cli", "-a", "__score__", "-n", "-w", sandboxWs];
+  fs11.rmSync(path13.join(args.runDir, "score.json"), { force: true });
   appendSubCliHeader(args.runDir, "Phase C: __score__");
   const result = await spawnProc(
     resolveHaloCli(),
@@ -2188,7 +2741,7 @@ async function phaseScore(args) {
       writeLog(args.logFd, `[phaseScore] stdout (last 1KB): ${result.stdout.slice(-1e3)}
 `);
   }
-  const hasScore = fs9.existsSync(path12.join(args.runDir, "score.json"));
+  const hasScore = fs11.existsSync(path13.join(args.runDir, "score.json"));
   writeLog(args.logFd, `[phaseScore] score.json=${hasScore}
 `);
   return hasScore;
@@ -2202,7 +2755,7 @@ var RUN_INPUT_FILES = /* @__PURE__ */ new Set([
 function resetRunArtifacts(runDir, logFd) {
   let entries;
   try {
-    entries = fs9.readdirSync(runDir);
+    entries = fs11.readdirSync(runDir);
   } catch {
     return;
   }
@@ -2210,26 +2763,19 @@ function resetRunArtifacts(runDir, logFd) {
     if (RUN_INPUT_FILES.has(entry))
       continue;
     try {
-      fs9.rmSync(path12.join(runDir, entry), { recursive: true, force: true });
+      fs11.rmSync(path13.join(runDir, entry), { recursive: true, force: true });
     } catch (err) {
       writeLog(logFd, `[resetRunArtifacts] failed to remove ${entry}: ${err instanceof Error ? err.message : String(err)}
 `);
     }
   }
 }
-async function runMode(id, logFd) {
-  const row = loadRunRow(id);
+async function runMode(row, logFd) {
+  const { id } = row;
   const runDir = wsEvoRunDir(row.workspacePath, id);
-  fs9.mkdirSync(runDir, { recursive: true });
+  fs11.mkdirSync(runDir, { recursive: true });
   resetRunArtifacts(runDir, logFd);
-  const hb = setInterval(() => {
-    try {
-      getEvoDb().update(evolutionRuns).set({ heartbeatAt: Date.now() }).where(eq(evolutionRuns.id, id)).run();
-    } catch (err) {
-      writeLog(logFd, `[wrapper] heartbeat failed: ${err instanceof Error ? err.message : String(err)}
-`);
-    }
-  }, 6e4);
+  const hb = setInterval(() => heartbeat("run", id, row.attempts, logFd), 6e4);
   const langHint = resolveLangHint();
   writeLog(logFd, `[wrapper] resolved langHint=${langHint}
 `);
@@ -2244,35 +2790,118 @@ async function runMode(id, logFd) {
   };
   try {
     const outcome = await phaseDraft(ctx);
+    markObservation(id, row.attempts, runDir, outcome, logFd);
     if (outcome === "failed") {
-      finalize(id, "failed", "phase A: draft incomplete (drafter exited non-zero, or patch.md / target file missing or unchanged) \u2014 see run log", logFd);
+      finalize(id, row.attempts, "failed", "phase A: draft incomplete (drafter exited non-zero, or patch.md / target file missing or unchanged) \u2014 see run log", logFd);
       return;
     }
     if (outcome === "skipped") {
-      finalize(id, "skipped", null, logFd);
+      finalize(id, row.attempts, "skipped", null, logFd);
       return;
     }
     const dryRunOk = await phaseDryRun(ctx);
     if (!dryRunOk) {
-      finalize(id, "failed", "phase B: dry-run failed (fix budget exhausted)", logFd);
+      finalize(id, row.attempts, "failed", "phase B: dry-run failed (fix budget exhausted)", logFd);
       return;
     }
     const scored = await phaseScore(ctx);
     if (!scored) {
-      finalize(id, "failed", "phase C: scorer did not produce score.json", logFd);
+      finalize(id, row.attempts, "failed", "phase C: scorer did not produce score.json", logFd);
       return;
     }
-    finalize(id, "awaiting_review", null, logFd);
+    if (maybeAutoApply({ runId: id, workspacePath: row.workspacePath, runDir, attempts: row.attempts, sourceAccess: row.sourceAccess, logFd }))
+      return;
+    finalize(id, row.attempts, "awaiting_review", null, logFd);
   } finally {
     clearInterval(hb);
   }
 }
-function finalize(id, status, failureReason, logFd) {
+function markObservation(id, attempts, runDir, outcome, logFd) {
+  const has = outcome !== "failed" && readObservation(path13.join(runDir, outcome === "skipped" ? ".skip.md" : "patch.md")) !== null;
+  getEvoDb().update(evolutionRuns).set({ hasObservation: has }).where(ownsRun(id, attempts)).run();
+  if (has)
+    writeLog(logFd, `[wrapper] draft carries a Larger observation
+`);
+}
+function maybeAutoApply(args) {
+  const level = config.evolution.level;
+  if (evoLevelRank(level) < 2)
+    return false;
+  let record;
+  try {
+    record = evaluateSandbox({
+      mainHalo: wsHaloDir(args.workspacePath),
+      globalHalo: globalDir(),
+      sandboxHalo: evoSandboxHaloDir(args.runDir),
+      entries: PUBLISH_WHITELIST,
+      level,
+      threshold: config.evolution.autoApplyThreshold,
+      sourceAccess: args.sourceAccess,
+      score: readScore(path13.join(args.runDir, "score.json")),
+      observation: readObservation(path13.join(args.runDir, "patch.md"))
+    });
+    fs11.writeFileSync(path13.join(args.runDir, AUTO_APPLY_FILE), JSON.stringify(record, null, 2), "utf-8");
+  } catch (err) {
+    writeLog(args.logFd, `[autoApply] evaluation failed, leaving the run for review: ${err instanceof Error ? err.message : String(err)}
+`);
+    return false;
+  }
+  writeLog(args.logFd, `[autoApply] level=${level} category=${record.category} auto=${record.auto}${record.reason ? ` reason=${record.reason}` : ""} files=${record.files.map((f) => `${f.rel}:${f.category}`).join(",")}
+`);
+  if (!record.auto)
+    return false;
+  const queued = queueApply(getEvoDb(), { mode: "auto", runId: args.runId, attempts: args.attempts });
+  if (queued.ok) {
+    writeLog(args.logFd, `[autoApply] queued ${queued.applyId} (approved_by=auto)
+`);
+    return true;
+  }
+  writeLog(args.logFd, `[autoApply] not queued: ${queued.reason}
+`);
+  return queued.reason === "state";
+}
+function finalize(id, attempts, status, failureReason, logFd) {
   const now = Date.now();
-  getEvoDb().update(evolutionRuns).set({ status, failureReason, completedAt: now }).where(eq(evolutionRuns.id, id)).run();
+  const r = getEvoDb().update(evolutionRuns).set({ status, failureReason, completedAt: now }).where(ownsRun(id, attempts)).run();
+  if (r.changes === 0) {
+    writeLog(logFd, `[wrapper] finalize skipped: run is no longer this wrapper's claim (re-claimed or moved on) \u2014 wanted status=${status}
+`);
+    return;
+  }
   writeLog(logFd, `[wrapper] finalize: status=${status}${failureReason ? ` reason=${failureReason}` : ""}
 `);
 }
+function ownsRun(id, attempts) {
+  return and3(eq3(evolutionRuns.id, id), eq3(evolutionRuns.status, "running"), eq3(evolutionRuns.attempts, attempts));
+}
+function heartbeat(mode, id, attempts, logFd) {
+  if (stopping)
+    return;
+  let owned;
+  try {
+    owned = mode === "run" ? getEvoDb().update(evolutionRuns).set({ heartbeatAt: Date.now() }).where(ownsRun(id, attempts)).run().changes > 0 : touchApply(id, attempts, ["running", "syncing"]);
+  } catch (err) {
+    writeLog(logFd, `[wrapper] heartbeat failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return;
+  }
+  if (owned)
+    return;
+  stopping = true;
+  writeLog(logFd, `[wrapper] heartbeat refused: ${mode} ${id} is no longer this wrapper's claim (attempt ${attempts}) \u2014 stopping ${liveProcs.size} sub-cli and exiting
+`);
+  if (liveProcs.size === 0) {
+    process.exit(1);
+    return;
+  }
+  for (const kill of liveProcs)
+    kill("SIGTERM");
+  setTimeout(() => {
+    for (const kill of liveProcs)
+      kill("SIGKILL");
+    process.exit(1);
+  }, KILL_GRACE_MS);
+}
 var APPLY_REGRESSION_FLOOR = 50;
 function loadApplyRow(id) {
   const db = getEvoDb();
@@ -2281,8 +2910,10 @@ function loadApplyRow(id) {
     workspacePath: evolutionApplies.workspacePath,
     sourceRunIds: evolutionApplies.sourceRunIds,
     reviewerHint: evolutionApplies.reviewerHint,
-    status: evolutionApplies.status
-  }).from(evolutionApplies).where(eq(evolutionApplies.id, id)).get();
+    status: evolutionApplies.status,
+    approvedBy: evolutionApplies.approvedBy,
+    attempts: evolutionApplies.attempts
+  }).from(evolutionApplies).where(eq3(evolutionApplies.id, id)).get();
   if (!row)
     throw new Error(`evolution_applies row not found: ${id}`);
   let sourceRunIds;
@@ -2299,20 +2930,22 @@ function loadApplyRow(id) {
     workspacePath: row.workspacePath,
     sourceRunIds,
     reviewerHint: row.reviewerHint,
-    status: row.status
+    status: row.status,
+    approvedBy: row.approvedBy,
+    attempts: row.attempts
   };
 }
 function buildEvoSandbox(workspacePath, sandboxParent, logFd) {
   const srcWs = wsHaloDir(workspacePath);
   const dstWs = evoSandboxHaloDir(sandboxParent);
-  fs9.mkdirSync(dstWs, { recursive: true });
+  fs11.mkdirSync(dstWs, { recursive: true });
   const whitelist = SANDBOX_WHITELIST;
   for (const entry of whitelist) {
-    const srcEntry = path12.join(srcWs, entry);
-    if (!fs9.existsSync(srcEntry))
+    const srcEntry = path13.join(srcWs, entry);
+    if (!fs11.existsSync(srcEntry))
       continue;
-    const dstEntry = path12.join(dstWs, entry);
-    if (fs9.existsSync(dstEntry))
+    const dstEntry = path13.join(dstWs, entry);
+    if (fs11.existsSync(dstEntry))
       continue;
     copyDereferenced(srcEntry, dstEntry);
   }
@@ -2320,13 +2953,13 @@ function buildEvoSandbox(workspacePath, sandboxParent, logFd) {
 `);
 }
 function copyDereferenced(src, dst) {
-  if (fs9.statSync(src).isDirectory()) {
-    fs9.mkdirSync(dst, { recursive: true });
-    for (const entry of fs9.readdirSync(src))
-      copyDereferenced(path12.join(src, entry), path12.join(dst, entry));
+  if (fs11.statSync(src).isDirectory()) {
+    fs11.mkdirSync(dst, { recursive: true });
+    for (const entry of fs11.readdirSync(src))
+      copyDereferenced(path13.join(src, entry), path13.join(dst, entry));
     return;
   }
-  fs9.copyFileSync(src, dst);
+  fs11.copyFileSync(src, dst);
 }
 function buildApplySandbox(workspacePath, applyDir, logFd) {
   buildEvoSandbox(workspacePath, applyDir, logFd);
@@ -2354,11 +2987,11 @@ function buildApplyMergeBrief(args) {
     "",
     "Hard rules: only edit files under sandbox/.halo/ \u2014 main workspace",
     "and ~/.halo/global/ are off-limits. Do NOT spawn halo cli. Do NOT",
-    `write score.json. Write ${path12.join(args.applyDir, "apply.log")}`,
+    `write score.json. Write ${path13.join(args.applyDir, "apply.log")}`,
     "with a summary of what you did.",
     "",
     "If the merge cannot proceed (irreconcilable patch conflicts, malformed",
-    `input, missing sandbox), write ${path12.join(args.applyDir, "ABORT.md")}`,
+    `input, missing sandbox), write ${path13.join(args.applyDir, "ABORT.md")}`,
     'with the diagnosis \u2014 the wrapper treats its presence as "abort this',
     'apply" and fails the apply instead of publishing. You cannot signal',
     "abort via exit code; ABORT.md is the only abort channel.",
@@ -2379,19 +3012,19 @@ function buildApplyScoreBrief(args) {
     "The apply agent has merged this patch (and possibly others) into",
     "an apply sandbox. The wrapper just ran the patch's testScenario",
     "against the merged sandbox; stdout is in",
-    `${path12.join(args.regressDir, "dry-run-output.txt")}.`,
+    `${path13.join(args.regressDir, "dry-run-output.txt")}.`,
     "An empty dry-run-output.txt means the dry-run against the merged",
     "sandbox failed \u2014 score lint 0 (that is the regression signal the",
     `wrapper acts on); the failure detail is in`,
-    `${path12.join(args.regressDir, "dry-run-fail.log")} when present.`,
+    `${path13.join(args.regressDir, "dry-run-fail.log")} when present.`,
     "",
     "Follow your AGENT.md procedure. Read:",
     `  patch.md      \u2192 ${args.patchMdPath}`,
-    `  tool-flow.md  \u2192 ${path12.join(path12.dirname(args.patchMdPath), "tool-flow.md")} (baseline conversation)`,
+    `  tool-flow.md  \u2192 ${path13.join(path13.dirname(args.patchMdPath), "tool-flow.md")} (baseline conversation)`,
     `  source-snapshot.json \u2192 ${args.snapshotPath}`,
-    `  dry-run output  \u2192 ${path12.join(args.regressDir, "dry-run-output.txt")}`,
+    `  dry-run output  \u2192 ${path13.join(args.regressDir, "dry-run-output.txt")}`,
     "",
-    `Write ${path12.join(args.regressDir, "score.json")} \u2014 NOT the source`,
+    `Write ${path13.join(args.regressDir, "score.json")} \u2014 NOT the source`,
     "run's score.json. Same format as run mode.",
     "Do not modify any other file.",
     ...buildLanguageClause(args.langHint, 'the score.json "notes" field'),
@@ -2403,9 +3036,9 @@ async function phaseApplyMerge(ctx) {
 === Phase A': merge ===
 `);
   buildApplySandbox(ctx.workspacePath, ctx.applyDir, ctx.logFd);
-  const abortPath = path12.join(ctx.applyDir, "ABORT.md");
+  const abortPath = path13.join(ctx.applyDir, "ABORT.md");
   try {
-    fs9.rmSync(abortPath, { force: true });
+    fs11.rmSync(abortPath, { force: true });
   } catch {
   }
   const brief = buildApplyMergeBrief(ctx);
@@ -2424,10 +3057,10 @@ async function phaseApplyMerge(ctx) {
 `);
     return { ok: false, reason: `apply cli exited ${result.exitCode}` };
   }
-  if (fs9.existsSync(abortPath)) {
+  if (fs11.existsSync(abortPath)) {
     let abortText = "";
     try {
-      abortText = fs9.readFileSync(abortPath, "utf-8").trim();
+      abortText = fs11.readFileSync(abortPath, "utf-8").trim();
     } catch {
     }
     writeLog(ctx.logFd, `[phaseApplyMerge] ABORT.md present \u2014 agent aborted the merge:
@@ -2436,7 +3069,7 @@ ${abortText}
     const firstLine = abortText.split("\n")[0]?.slice(0, 300) ?? "";
     return { ok: false, reason: `apply agent aborted: ${firstLine || "see ABORT.md in apply dir"}` };
   }
-  const hasLog = fs9.existsSync(path12.join(ctx.applyDir, "apply.log"));
+  const hasLog = fs11.existsSync(path13.join(ctx.applyDir, "apply.log"));
   writeLog(ctx.logFd, `[phaseApplyMerge] apply.log=${hasLog}
 `);
   if (!hasLog)
@@ -2448,17 +3081,17 @@ async function phaseApplyRegress(ctx) {
 === Phase B': regress ===
 `);
   const sandboxDir = evoSandboxDir(ctx.applyDir);
-  fs9.mkdirSync(evoRegressDir(ctx.applyDir), { recursive: true });
+  fs11.mkdirSync(evoRegressDir(ctx.applyDir), { recursive: true });
   const outcomes = [];
   for (const runId of ctx.sourceRunIds) {
     writeLog(ctx.logFd, `
 --- regress for source run ${runId} ---
 `);
     const regressDir = evoRegressRunDir(ctx.applyDir, runId);
-    fs9.mkdirSync(regressDir, { recursive: true });
+    fs11.mkdirSync(regressDir, { recursive: true });
     const runDir = wsEvoRunDir(ctx.workspacePath, runId);
-    const patchMdPath = path12.join(runDir, "patch.md");
-    const snapshotPath = path12.join(runDir, "source-snapshot.json");
+    const patchMdPath = path13.join(runDir, "patch.md");
+    const snapshotPath = path13.join(runDir, "source-snapshot.json");
     const fm = readPatchFrontmatter(runDir);
     const scenario = extractTestScenario(fm);
     if (!scenario) {
@@ -2485,14 +3118,14 @@ async function phaseApplyRegress(ctx) {
       // stdin, not argv
       DRY_RUN_TIMEOUT_SEC
     );
-    const dryRunOut = path12.join(regressDir, "dry-run-output.txt");
+    const dryRunOut = path13.join(regressDir, "dry-run-output.txt");
     if (dryRun.exitCode === 0 && dryRun.stdout.trim().length > 0) {
-      fs9.writeFileSync(dryRunOut, dryRun.stdout, "utf-8");
+      fs11.writeFileSync(dryRunOut, dryRun.stdout, "utf-8");
     } else {
       const tail = dryRun.stdout.length > 4e3 ? "\u2026" + dryRun.stdout.slice(-4e3) : dryRun.stdout;
       const errTail = dryRun.stderr.length > 4e3 ? "\u2026" + dryRun.stderr.slice(-4e3) : dryRun.stderr;
-      fs9.writeFileSync(dryRunOut, "", "utf-8");
-      fs9.writeFileSync(path12.join(regressDir, "dry-run-fail.log"), [
+      fs11.writeFileSync(dryRunOut, "", "utf-8");
+      fs11.writeFileSync(path13.join(regressDir, "dry-run-fail.log"), [
         `Wrapper command:  halo cli -a ${scenario.agentId} -n -w ${sandboxDir} <testMessage>`,
         `Test message:     ${scenario.testMessage}`,
         `Exit code:        ${dryRun.exitCode}${dryRun.exitCode === 124 ? " (timeout)" : ""}`,
@@ -2513,6 +3146,7 @@ async function phaseApplyRegress(ctx) {
       langHint: ctx.langHint
     });
     const scoreSandboxWs = evoSandboxDir(ctx.applyDir);
+    fs11.rmSync(path13.join(regressDir, "score.json"), { force: true });
     const scoreRun = await spawnProc(
       resolveHaloCli(),
       ["cli", "-a", "__score__", "-n", "-w", scoreSandboxWs],
@@ -2526,10 +3160,10 @@ async function phaseApplyRegress(ctx) {
       writeLog(ctx.logFd, `[phaseApplyRegress:${runId}] scorer cli exited ${scoreRun.exitCode}
 `);
     }
-    const scorePath = path12.join(regressDir, "score.json");
+    const scorePath = path13.join(regressDir, "score.json");
     let scoreJson = null;
     try {
-      scoreJson = JSON.parse(fs9.readFileSync(scorePath, "utf-8"));
+      scoreJson = JSON.parse(fs11.readFileSync(scorePath, "utf-8"));
     } catch {
     }
     if (!scoreJson) {
@@ -2567,31 +3201,36 @@ async function phaseApplyRegress(ctx) {
 `);
   return { allOk, outcomes };
 }
-function finalizeApply(applyId, status, failureReason, logFd) {
-  const now = Date.now();
-  getEvoDb().update(evolutionApplies).set({ status, failureReason, completedAt: now }).where(eq(evolutionApplies.id, applyId)).run();
-  writeLog(logFd, `[wrapper] finalize apply: status=${status}${failureReason ? ` reason=${failureReason}` : ""}
+function finalizeApply(applyId, attempts, failureReason, logFd) {
+  const { failed, revertedRunIds } = failApply(getEvoDb(), applyId, { status: "failed", failureReason, onlyIfStatus: "running", onlyIfAttempts: attempts });
+  if (!failed) {
+    writeLog(logFd, `[wrapper] finalize apply skipped: row is no longer running at attempt ${attempts} (re-claimed, or syncing \u2014 left to the ticker) \u2014 wanted failed: ${failureReason}
+`);
+    return;
+  }
+  writeLog(logFd, `[wrapper] finalize apply: status=failed reason=${failureReason}${revertedRunIds.length ? ` (auto: ${revertedRunIds.join(", ")} back to awaiting_review)` : ""}
 `);
 }
+function autoApplyRecheck(workspacePath, applyDir, changed) {
+  const cls = classifyChanges(publishChanges({
+    mainHalo: wsHaloDir(workspacePath),
+    globalHalo: globalDir(),
+    sandboxHalo: evoSandboxHaloDir(applyDir)
+  }, changed));
+  return categoryGate(config.evolution.level, cls);
+}
 async function applyMode(id, logFd) {
   const row = loadApplyRow(id);
   const applyDir = wsEvoApplyDir(row.workspacePath, id);
-  fs9.mkdirSync(applyDir, { recursive: true });
-  fs9.writeFileSync(path12.join(applyDir, "meta.json"), JSON.stringify({
+  fs11.mkdirSync(applyDir, { recursive: true });
+  fs11.writeFileSync(path13.join(applyDir, "meta.json"), JSON.stringify({
     id,
     sourceRunIds: row.sourceRunIds,
     reviewerHint: row.reviewerHint,
     workspacePath: row.workspacePath,
     createdAt: Date.now()
   }, null, 2), "utf-8");
-  const hb = setInterval(() => {
-    try {
-      getEvoDb().update(evolutionApplies).set({ heartbeatAt: Date.now() }).where(eq(evolutionApplies.id, id)).run();
-    } catch (err) {
-      writeLog(logFd, `[wrapper] heartbeat (apply) failed: ${err instanceof Error ? err.message : String(err)}
-`);
-    }
-  }, 6e4);
+  const hb = setInterval(() => heartbeat("apply", id, row.attempts, logFd), 6e4);
   const ctx = {
     applyId: id,
     workspacePath: row.workspacePath,
@@ -2610,75 +3249,93 @@ async function applyMode(id, logFd) {
     if (!isResume) {
       const merged = await phaseApplyMerge(ctx);
       if (!merged.ok) {
-        finalizeApply(id, "failed", `phase A': ${merged.reason}`, logFd);
+        finalizeApply(id, row.attempts, `phase A': ${merged.reason}`, logFd);
         return;
       }
       const { allOk, outcomes } = await phaseApplyRegress(ctx);
       if (!allOk) {
         const regressedRuns = outcomes.filter((o) => o.regressed).map((o) => `${o.runId}(${o.reason ?? "?"})`).join("; ");
-        finalizeApply(id, "failed", `phase B': regression in ${regressedRuns}`, logFd);
+        finalizeApply(id, row.attempts, `phase B': regression in ${regressedRuns}`, logFd);
         return;
       }
     }
     try {
-      const preflight = await phaseApplyPreflight(ctx);
-      if (!preflight.ok) {
-        finalizeApply(id, "failed", `phase 12 preflight: ${preflight.reason}`, logFd);
-        return;
-      }
-      if (!isResume)
-        markSyncing(id, logFd);
-      await phaseApplyPublish(ctx, preflight.result);
-      for (const runId of ctx.sourceRunIds) {
-        getEvoDb().update(evolutionRuns).set({ status: "applied", appliedAt: Date.now() }).where(eq(evolutionRuns.id, runId)).run();
-      }
-      finalizeApplied(id, logFd);
-      writeLog(logFd, `[wrapper] phase 12: published ${preflight.result.fileCount} files to main; history snapshot at ${preflight.result.historyDir}
-`);
-      writeLog(logFd, `[wrapper] note: no explicit session-release step needed. Halo's SessionManager evicts every session from the in-memory cache as soon as its current message turn finishes (runSession's finally block). The next message \u2014 channel reply, web reload, /new \u2014 runs ensureSession \u2192 buildAgentInstance, which re-reads agent.yaml + INSTRUCTIONS.md + USER.md from disk. So the new prompts kick in on the next turn for free, and currently-running turns finish on the old prompts (which is the right behavior \u2014 we don't want to abort a user mid-conversation).
-`);
+      await phase12Sync(ctx, row, isResume);
     } catch (err) {
-      const currentStatus = getEvoDb().select({ status: evolutionApplies.status }).from(evolutionApplies).where(eq(evolutionApplies.id, id)).get()?.status;
+      const currentStatus = getEvoDb().select({ status: evolutionApplies.status }).from(evolutionApplies).where(eq3(evolutionApplies.id, id)).get()?.status;
       if (currentStatus === "syncing") {
-        writeLog(logFd, `[wrapper] phase 12 publish threw (${err instanceof Error ? err.message : String(err)}); leaving status='syncing' so ticker can resume \u2014 main may be half-applied
-`);
-        getEvoDb().update(evolutionApplies).set({ startedAt: null, heartbeatAt: null }).where(and(eq(evolutionApplies.id, id), eq(evolutionApplies.status, "syncing"))).run();
+        releaseSyncing(id, row.attempts, `phase 12 publish: ${err instanceof Error ? err.message : String(err)}`, logFd);
       } else {
-        finalizeApply(id, "failed", `phase 12: ${err instanceof Error ? err.message : String(err)}`, logFd);
+        finalizeApply(id, row.attempts, `phase 12: ${err instanceof Error ? err.message : String(err)}`, logFd);
       }
     }
   } finally {
     clearInterval(hb);
   }
 }
-async function phaseApplyPreflight(ctx) {
+async function phase12Sync(ctx, row, isResume) {
+  const { applyId: id, logFd } = ctx;
+  if (!isResume && !touchApply(id, row.attempts, ["running"])) {
+    writeLog(logFd, `[wrapper] phase 12: apply is no longer this wrapper's claim (attempt ${row.attempts}) \u2014 not writing history
+`);
+    return;
+  }
+  const preflight = await phaseApplyPreflight(ctx, isResume);
+  if (!preflight.ok) {
+    const reason = `phase 12 preflight: ${preflight.reason}`;
+    if (isResume)
+      releaseSyncing(id, row.attempts, reason, logFd);
+    else
+      finalizeApply(id, row.attempts, reason, logFd);
+    return;
+  }
+  if (!isResume && row.approvedBy === "auto") {
+    const blocked = autoApplyRecheck(ctx.workspacePath, ctx.applyDir, preflight.result.changed);
+    if (blocked) {
+      finalizeApply(id, row.attempts, `auto_recheck:${blocked}`, logFd);
+      return;
+    }
+    writeLog(logFd, `[wrapper] auto-apply recheck passed
+`);
+  }
+  if (!markSyncing(id, isResume ? "syncing" : "running", row.attempts, logFd))
+    return;
+  await phaseApplyPublish(ctx, preflight.result);
+  if (!finalizeApplied(id, row.attempts, ctx.sourceRunIds, logFd))
+    return;
+  writeLog(logFd, `[wrapper] phase 12: published ${preflight.result.fileCount} files to main; history snapshot at ${preflight.result.historyDir}
+`);
+  writeLog(logFd, `[wrapper] note: no explicit session-release step needed. Halo's SessionManager evicts every session from the in-memory cache as soon as its current message turn finishes (runSession's finally block). The next message \u2014 channel reply, web reload, /new \u2014 runs ensureSession \u2192 buildAgentInstance, which re-reads agent.yaml + INSTRUCTIONS.md + USER.md from disk. So the new prompts kick in on the next turn for free, and currently-running turns finish on the old prompts (which is the right behavior \u2014 we don't want to abort a user mid-conversation).
+`);
+}
+async function phaseApplyPreflight(ctx, isResume) {
   writeLog(ctx.logFd, `
 === Phase 12 preflight: diff + history backup ===
 `);
   const sandboxHalo = evoSandboxHaloDir(ctx.applyDir);
   const mainHalo = wsHaloDir(ctx.workspacePath);
-  if (!fs9.existsSync(sandboxHalo))
+  if (!fs11.existsSync(sandboxHalo))
     return { ok: false, reason: "sandbox missing \u2014 phase 11 must run first" };
   const whitelistTop = new Set(PUBLISH_WHITELIST);
   const filesToConsider = [];
-  for (const top of fs9.readdirSync(sandboxHalo)) {
+  for (const top of fs11.readdirSync(sandboxHalo)) {
     if (!whitelistTop.has(top))
       continue;
-    walkInto(path12.join(sandboxHalo, top), top, filesToConsider);
+    walkInto(path13.join(sandboxHalo, top), top, filesToConsider);
   }
   const historyDir = wsEvoHistoryDir(ctx.workspacePath, ctx.applyId);
   const changed = [];
   for (const { rel, full } of filesToConsider) {
-    const mainPath = path12.join(mainHalo, rel);
+    const mainPath = path13.join(mainHalo, rel);
     let existsInMain = false;
     try {
-      fs9.accessSync(mainPath);
+      fs11.accessSync(mainPath);
       existsInMain = true;
     } catch {
     }
     if (existsInMain) {
-      const sandboxBuf = fs9.readFileSync(full);
-      const mainBuf = fs9.readFileSync(mainPath);
+      const sandboxBuf = fs11.readFileSync(full);
+      const mainBuf = fs11.readFileSync(mainPath);
       if (sandboxBuf.equals(mainBuf))
         continue;
     }
@@ -2686,29 +3343,39 @@ async function phaseApplyPreflight(ctx) {
   }
   writeLog(ctx.logFd, `[preflight] ${changed.length} of ${filesToConsider.length} whitelisted files differ from main
 `);
+  if (!isResume)
+    fs11.rmSync(historyDir, { recursive: true, force: true });
   if (changed.length === 0) {
     return { ok: true, result: { changed, historyDir, fileCount: 0 } };
   }
-  fs9.mkdirSync(historyDir, { recursive: true });
-  const manifestPath = path12.join(historyDir, "MANIFEST.json");
-  const isFirstPreflight = !fs9.existsSync(manifestPath);
-  if (isFirstPreflight) {
+  fs11.mkdirSync(historyDir, { recursive: true });
+  const manifestPath = path13.join(historyDir, "MANIFEST.json");
+  if (!isResume) {
     for (const { rel, existsInMain } of changed) {
       if (!existsInMain)
         continue;
-      const mainPath = path12.join(mainHalo, rel);
-      const histPath = path12.join(historyDir, rel);
-      fs9.mkdirSync(path12.dirname(histPath), { recursive: true });
-      fs9.copyFileSync(mainPath, histPath);
+      const mainPath = path13.join(mainHalo, rel);
+      const histPath = path13.join(historyDir, rel);
+      fs11.mkdirSync(path13.dirname(histPath), { recursive: true });
+      fs11.copyFileSync(mainPath, histPath);
     }
-    fs9.writeFileSync(manifestPath, JSON.stringify({
+    const effective = new Set(publishChanges({ mainHalo, globalHalo: globalDir(), sandboxHalo }, changed).map((c) => c.rel));
+    const manifest = {
       applyId: ctx.applyId,
       sourceRunIds: ctx.sourceRunIds,
       capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      files: changed.map((c) => ({ rel: c.rel, kind: c.existsInMain ? "overwrite" : "new" }))
-    }, null, 2), "utf-8");
+      files: changed.map((c) => ({
+        rel: c.rel,
+        kind: c.existsInMain ? "overwrite" : "new",
+        before: c.existsInMain ? sha256File(path13.join(mainHalo, c.rel)) : null,
+        after: sha256File(c.full),
+        ...effective.has(c.rel.split(path13.sep).join("/")) ? {} : { unchanged: true }
+      })),
+      createdDirs: dirsCreatedBy(mainHalo, changed.filter((c) => !c.existsInMain).map((c) => c.rel))
+    };
+    fs11.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } else {
-    writeLog(ctx.logFd, `[preflight] MANIFEST.json already exists \u2014 resume path, skipping history backup (the pre-apply state is already preserved from the first preflight)
+    writeLog(ctx.logFd, `[preflight] resume path, skipping history backup (the pre-apply state is already preserved from the fresh claim's preflight)
 `);
   }
   writeLog(ctx.logFd, `[preflight] history snapshot: ${historyDir} (${changed.filter((c) => c.existsInMain).length} backed up, ${changed.filter((c) => !c.existsInMain).length} new)
@@ -2721,59 +3388,96 @@ async function phaseApplyPublish(ctx, preflight) {
 `);
   const mainHalo = wsHaloDir(ctx.workspacePath);
   for (const { rel, full } of preflight.changed) {
-    const mainPath = path12.join(mainHalo, rel);
-    fs9.mkdirSync(path12.dirname(mainPath), { recursive: true });
-    fs9.copyFileSync(full, mainPath);
+    const mainPath = path13.join(mainHalo, rel);
+    fs11.mkdirSync(path13.dirname(mainPath), { recursive: true });
+    fs11.copyFileSync(full, mainPath);
   }
   writeLog(ctx.logFd, `[publish] copied ${preflight.changed.length} files to ${mainHalo}
 `);
 }
-function markSyncing(applyId, logFd) {
-  getEvoDb().update(evolutionApplies).set({ status: "syncing" }).where(eq(evolutionApplies.id, applyId)).run();
+function dirsCreatedBy(mainHalo, newFiles) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const rel of newFiles) {
+    for (let d = path13.dirname(rel); d !== "." && !fs11.existsSync(path13.join(mainHalo, d)); d = path13.dirname(d))
+      dirs.add(d);
+  }
+  return [...dirs].sort((a, b) => b.split(path13.sep).length - a.split(path13.sep).length || (a < b ? -1 : 1));
+}
+function ownsApply(id, status, attempts) {
+  return and3(eq3(evolutionApplies.id, id), eq3(evolutionApplies.status, status), eq3(evolutionApplies.attempts, attempts));
+}
+function touchApply(id, attempts, statuses) {
+  return getEvoDb().update(evolutionApplies).set({ heartbeatAt: Date.now() }).where(and3(eq3(evolutionApplies.id, id), inArray2(evolutionApplies.status, statuses), eq3(evolutionApplies.attempts, attempts))).run().changes > 0;
+}
+function markSyncing(applyId, from, attempts, logFd) {
+  const r = getEvoDb().update(evolutionApplies).set(from === "running" ? { status: "syncing", heartbeatAt: Date.now() } : { heartbeatAt: Date.now() }).where(ownsApply(applyId, from, attempts)).run();
+  if (r.changes === 0) {
+    writeLog(logFd, `[wrapper] checkpoint refused: apply is no longer ${from} at attempt ${attempts} (re-claimed) \u2014 not publishing
+`);
+    return false;
+  }
   writeLog(logFd, `[wrapper] checkpoint: status=syncing (publishing main)
+`);
+  return true;
+}
+function releaseSyncing(applyId, attempts, reason, logFd) {
+  const r = getEvoDb().update(evolutionApplies).set({ startedAt: null, heartbeatAt: null, failureReason: reason }).where(ownsApply(applyId, "syncing", attempts)).run();
+  writeLog(logFd, r.changes === 0 ? `[wrapper] ${reason}; row is no longer this wrapper's syncing claim \u2014 left alone
+` : `[wrapper] ${reason}; leaving status='syncing' for the ticker to resume \u2014 main may be half-applied
 `);
 }
 function walkInto(absPath, relPath, out) {
-  const stat = fs9.statSync(absPath);
+  const stat = fs11.statSync(absPath);
   if (stat.isFile()) {
     out.push({ rel: relPath, full: absPath });
     return;
   }
   if (!stat.isDirectory())
     return;
-  for (const entry of fs9.readdirSync(absPath)) {
-    walkInto(path12.join(absPath, entry), path12.join(relPath, entry), out);
+  for (const entry of fs11.readdirSync(absPath)) {
+    walkInto(path13.join(absPath, entry), path13.join(relPath, entry), out);
   }
 }
-function finalizeApplied(applyId, logFd) {
+function finalizeApplied(applyId, attempts, sourceRunIds, logFd) {
   const now = Date.now();
-  getEvoDb().update(evolutionApplies).set({ status: "applied", completedAt: now }).where(eq(evolutionApplies.id, applyId)).run();
-  writeLog(logFd, `[wrapper] finalize apply: status=applied
+  const ok = getEvoDb().transaction((tx) => {
+    const r = tx.update(evolutionApplies).set({ status: "applied", completedAt: now, failureReason: null }).where(ownsApply(applyId, "syncing", attempts)).run();
+    if (r.changes === 0)
+      return false;
+    tx.update(evolutionRuns).set({ status: "applied", appliedAt: now }).where(and3(inArray2(evolutionRuns.id, sourceRunIds), eq3(evolutionRuns.status, "approved"))).run();
+    return true;
+  });
+  writeLog(logFd, ok ? `[wrapper] finalize apply: status=applied
+` : `[wrapper] finalize apply skipped: row is no longer syncing at attempt ${attempts} (re-claimed)
 `);
+  return ok;
 }
 function writeLog(fd, msg) {
   try {
-    fs9.writeSync(fd, msg);
+    fs11.writeSync(fd, msg);
   } catch {
   }
 }
 function openLogFor(mode, id) {
-  fs9.mkdirSync(evoLogsDir(), { recursive: true });
+  fs11.mkdirSync(evoLogsDir(), { recursive: true });
   const logPath = mode === "run" ? evoWrapperLogFile(id) : evoApplyLogFile(id);
-  const fd = fs9.openSync(logPath, "a");
+  const fd = fs11.openSync(logPath, "a");
   return { fd, logPath };
 }
 async function main() {
   const { mode, id } = parseCli(process.argv.slice(2));
-  setEvoDb(createEvoDb(path12.join(homedir6(), ".halo", "global")));
+  setEvoDb(createEvoDb(path13.join(homedir6(), ".halo", "global")));
   const { fd, logPath } = openLogFor(mode, id);
   writeLog(fd, `
 === ${(/* @__PURE__ */ new Date()).toISOString()} wrapper start mode=${mode} id=${id} pid=${process.pid} ===
 `);
+  let runAttempts = null;
   try {
-    if (mode === "run")
-      await runMode(id, fd);
-    else
+    if (mode === "run") {
+      const row = loadRunRow(id);
+      runAttempts = row.attempts;
+      await runMode(row, fd);
+    } else
       await applyMode(id, fd);
     writeLog(fd, `[wrapper] done; log: ${logPath}
 `);
@@ -2783,16 +3487,14 @@ async function main() {
     writeLog(fd, `[wrapper] fatal: ${msg}
 `);
     try {
-      const now = Date.now();
-      if (mode === "run") {
-        getEvoDb().update(evolutionRuns).set({ status: "failed", failureReason: `wrapper crash: ${msg}`, completedAt: now }).where(eq(evolutionRuns.id, id)).run();
-      }
+      if (mode === "run" && runAttempts !== null)
+        finalize(id, runAttempts, "failed", `wrapper crash: ${msg}`, fd);
     } catch {
     }
     process.exit(1);
   }
 }
-if (process.argv[1] && path12.resolve(process.argv[1]) === fileURLToPath2(import.meta.url)) {
+if (process.argv[1] && path13.resolve(process.argv[1]) === fileURLToPath2(import.meta.url)) {
   main().catch((err) => {
     process.stderr.write(`[wrapper] startup error: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -2802,11 +3504,21 @@ if (process.argv[1] && path12.resolve(process.argv[1]) === fileURLToPath2(import
 export {
   PUBLISH_WHITELIST,
   SANDBOX_WHITELIST,
+  autoApplyRecheck,
   buildEvoSandbox,
   extractTestScenario,
+  finalize,
+  finalizeApplied,
+  finalizeApply,
+  heartbeat,
   judgeDraft,
+  markObservation,
+  markSyncing,
+  maybeAutoApply,
+  phase12Sync,
   phaseApplyPreflight,
   phaseApplyPublish,
   readPatchFrontmatter,
+  resetStoppingForTests,
   spawnProc
 };