@gobing-ai/spur 0.3.26 → 0.3.27

package/spur.js

@@ -37197,6 +37197,29 @@ var init_finding_codes = __esm(() => {
   };
 });
 
+// ../../packages/config/src/projects.ts
+import { homedir } from "os";
+import { join } from "path";
+function getProjectsFilePath() {
+  if (process.env.SPUR_PROJECTS_FILE) {
+    return process.env.SPUR_PROJECTS_FILE;
+  }
+  return join(homedir(), ".config", "spur", "projects.json");
+}
+var projectEntrySchema, projectsFileSchema;
+var init_projects = __esm(() => {
+  init_zod();
+  projectEntrySchema = exports_external.object({
+    name: exports_external.string().min(1),
+    path: exports_external.string().min(1),
+    port: exports_external.number().int().nonnegative().default(0)
+  });
+  projectsFileSchema = exports_external.object({
+    schema_version: exports_external.literal(1).default(1),
+    projects: exports_external.array(projectEntrySchema).default([])
+  });
+});
+
 // ../../packages/config/src/index.ts
 function folderPathWithDefault(defaultPath) {
   return exports_external.preprocess((v) => v == null ? undefined : v, exports_external.string().default(defaultPath));
@@ -37248,6 +37271,7 @@ var SPUR_ENV_VARS, SPUR_LOG_LEVELS, DEFAULT_TASKS_DIR = "docs/tasks", DEFAULT_FE
 var init_src = __esm(() => {
   init_zod();
   init_finding_codes();
+  init_projects();
   SPUR_ENV_VARS = {
     nodeEnv: "NODE_ENV",
     port: "PORT",
@@ -38938,14 +38962,14 @@ var init_dist5 = __esm(() => {
 
 // ../../packages/config/src/bundled-config.ts
 import { existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
-import { dirname as dirname3, join } from "path";
+import { dirname as dirname3, join as join2 } from "path";
 function bundledConfigRoot() {
   if (cachedRoot !== undefined)
     return cachedRoot;
   let dir = import.meta.dirname;
   while (true) {
     for (const name of BUNDLED_CONFIG_DIRS) {
-      const candidate = join(dir, name);
+      const candidate = join2(dir, name);
       if (isBundledConfigDir(candidate)) {
         cachedRoot = candidate;
         return cachedRoot;
@@ -38960,7 +38984,7 @@ function bundledConfigRoot() {
   return cachedRoot;
 }
 function isBundledConfigDir(candidate) {
-  return existsSync3(candidate) && statSync4(candidate).isDirectory() && existsSync3(join(candidate, "rules")) && existsSync3(join(candidate, "workflows"));
+  return existsSync3(candidate) && statSync4(candidate).isDirectory() && existsSync3(join2(candidate, "rules")) && existsSync3(join2(candidate, "workflows"));
 }
 function listBundledConfigFiles() {
   const root = bundledConfigRoot();
@@ -38971,7 +38995,7 @@ function listBundledConfigFiles() {
 function walk(dir, relPrefix, filter = /\.(ya?ml|json)$/i) {
   const acc = [];
   for (const entry of readdirSync3(dir)) {
-    const abs = join(dir, entry);
+    const abs = join2(dir, entry);
     const rel = relPrefix.length > 0 ? `${relPrefix}/${entry}` : entry;
     if (statSync4(abs).isDirectory()) {
       acc.push(...walk(abs, rel, filter));
@@ -38998,8 +39022,8 @@ var init_template_renderer = () => {};
 
 // ../../packages/config/src/loader.ts
 import { existsSync as existsSync4, statSync as statSync5 } from "fs";
-import { homedir } from "os";
-import { dirname as dirname4, join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname4, join as join3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function embeddedSchemasId(embeddedSchemas) {
   if (embeddedSchemas === undefined)
@@ -39022,7 +39046,7 @@ function cacheKey(configPath, opts, validateJsonSchema2) {
 }
 function resolveSchemaSpecifier(specifier, manifestSpecifier) {
   if (specifier === manifestSpecifier) {
-    const workspaceManifest = join2(LOADER_DIR, "..", "..", "..", "apps", "cli", "package.json");
+    const workspaceManifest = join3(LOADER_DIR, "..", "..", "..", "apps", "cli", "package.json");
     if (existsSync4(workspaceManifest))
       return workspaceManifest;
   }
@@ -39034,7 +39058,7 @@ function resolveSchemaSpecifier(specifier, manifestSpecifier) {
   }
 }
 function resolveConfigFile(cwd) {
-  const projectConfig = join2(cwd ?? process.cwd(), SPUR_CONFIG_DIR, SPUR_CONFIG_FILE);
+  const projectConfig = join3(cwd ?? process.cwd(), SPUR_CONFIG_DIR, SPUR_CONFIG_FILE);
   if (existsSync4(projectConfig))
     return projectConfig;
   if (process.env.SPUR_SKIP_GLOBAL_CONFIG === "true")
@@ -39074,9 +39098,9 @@ async function loadSpurConfig(cwd = process.cwd(), opts) {
 }
 function expandTilde(path8) {
   if (path8 === "~")
-    return homedir();
+    return homedir2();
   if (path8.startsWith("~/"))
-    return join2(homedir(), path8.slice(2));
+    return join3(homedir2(), path8.slice(2));
   return path8;
 }
 function expandTeamTildes(config4) {
@@ -39163,7 +39187,7 @@ async function resolvePlanningFolders(fs2) {
   return promise2;
 }
 async function resolvePlanningFoldersUncached(fs2) {
-  const configPath = fs2.resolve(join2(SPUR_CONFIG_DIR, SPUR_CONFIG_FILE));
+  const configPath = fs2.resolve(join3(SPUR_CONFIG_DIR, SPUR_CONFIG_FILE));
   if (!await fs2.exists(configPath))
     return defaultPlanningFolders();
   try {
@@ -39200,7 +39224,8 @@ var init_loader = __esm(() => {
   init_src();
   init_bundled_config();
   init_template_renderer();
-  GLOBAL_CONFIG_FILE = join2(homedir(), ".config", "spur", "config.yaml");
+  init_projects();
+  GLOBAL_CONFIG_FILE = join3(homedir2(), ".config", "spur", "config.yaml");
   LOADER_DIR = dirname4(fileURLToPath3(import.meta.url));
   embeddedSchemasIds = new WeakMap;
   spurConfigCache = new Map;
@@ -51376,16 +51401,21 @@ var init_run_dao = __esm(() => {
       });
     }
     traceRows(filter) {
-      return this.adapter.queryAll(`SELECT id, workflow_name, mode, status, started_at, completed_at, metadata_json
+      return this.adapter.queryAll(`SELECT id, workflow_name, mode, status, agent, started_at, completed_at, metadata_json
              FROM runs
              WHERE (?1 IS NULL OR workflow_name = ?1)
                AND (?2 IS NULL OR status = ?2)
                AND (?3 IS NULL OR started_at >= ?3)
-             ORDER BY started_at DESC
-             LIMIT ?4`, filter.workflow ?? null, filter.status ?? null, filter.since ?? null, filter.limit);
+               AND (
+                 ?4 IS NULL
+                 OR started_at < ?4
+                 OR (started_at = ?4 AND id < ?5)
+               )
+             ORDER BY started_at DESC, id DESC
+             LIMIT ?6`, filter.workflow ?? null, filter.status ?? null, filter.since ?? null, filter.before?.started_at ?? null, filter.before?.id ?? null, filter.limit);
     }
     traceRowById(runId) {
-      return this.adapter.queryFirst("SELECT id, workflow_name, mode, status, started_at, completed_at, metadata_json FROM runs WHERE id = ?", runId);
+      return this.adapter.queryFirst("SELECT id, workflow_name, mode, status, agent, started_at, completed_at, metadata_json FROM runs WHERE id = ?", runId);
     }
     stampMetadata(runId, metadata) {
       return this.adapter.run("UPDATE runs SET metadata_json = ? WHERE id = ?", JSON.stringify(metadata), runId);
@@ -51430,51 +51460,85 @@ class SystemEventDao {
     this.db = db2;
   }
   async insert(input) {
-    await this.db.run(`INSERT INTO system_events (id, event_name, occurred_at, actor, payload_json)
-             VALUES (?, ?, ?, ?, ?)`, [input.id, input.event_name, input.occurred_at, input.actor ?? null, input.payload_json ?? null]);
-  }
-  async prune(cap) {
-    const before = await this.db.queryFirst("SELECT COUNT(*) AS c FROM system_events");
-    await this.db.run(`DELETE FROM system_events
-             WHERE id IN (
-                 SELECT id FROM system_events
-                 WHERE id NOT IN (
-                     SELECT id FROM system_events
-                     ORDER BY occurred_at DESC
-                     LIMIT ?1
-                 )
-             )`, [cap]);
-    const after = await this.db.queryFirst("SELECT COUNT(*) AS c FROM system_events");
-    return (before?.c ?? 0) - (after?.c ?? 0);
+    await this.db.run(`INSERT INTO system_events (${SYSTEM_EVENT_COLUMNS})
+             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)`, input.id, input.event_name, input.occurred_at, input.actor ?? null, input.payload_json ?? null, input.run_id ?? null, input.entity_kind ?? null, input.entity_id ?? null, input.sequence ?? null);
+  }
+  async pruneQuotas(quotas, prefix) {
+    try {
+      const entries = prefix !== undefined ? quotas.filter((q) => q.prefix === prefix) : quotas;
+      let deleted = 0;
+      for (const { prefix: p, quota } of entries) {
+        const pattern = `${p}.%`;
+        const before = await this.db.queryFirst("SELECT COUNT(*) AS c FROM system_events WHERE event_name LIKE ?1", pattern);
+        await this.db.run(`DELETE FROM system_events
+                     WHERE event_name LIKE ?1
+                     AND id NOT IN (
+                         SELECT id FROM system_events
+                         WHERE event_name LIKE ?1
+                         ORDER BY occurred_at DESC
+                         LIMIT ?2
+                     )`, pattern, quota);
+        const after = await this.db.queryFirst("SELECT COUNT(*) AS c FROM system_events WHERE event_name LIKE ?1", pattern);
+        deleted += (before?.c ?? 0) - (after?.c ?? 0);
+      }
+      return deleted;
+    } catch (error51) {
+      if (error51 instanceof Error && error51.message.includes("no such table: system_events")) {
+        return 0;
+      }
+      throw error51;
+    }
   }
   async query(spec = {}) {
     const limit = spec.limit ?? 100;
+    const clauses = [];
+    const params = [];
+    const pushEq = (column2, value) => {
+      params.push(value);
+      clauses.push(`${column2} = ?${params.length}`);
+    };
+    if (spec.name !== undefined)
+      pushEq("event_name", spec.name);
+    if (spec.names !== undefined && spec.names.length > 0) {
+      const placeholders = [];
+      for (const name of spec.names) {
+        params.push(name);
+        placeholders.push(`?${params.length}`);
+      }
+      clauses.push(`event_name IN (${placeholders.join(", ")})`);
+    }
+    if (spec.prefix !== undefined) {
+      const escaped = spec.prefix.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+      params.push(`${escaped}.%`);
+      clauses.push(`event_name LIKE ?${params.length} ESCAPE '\\'`);
+    }
+    if (spec.since !== undefined) {
+      params.push(spec.since);
+      clauses.push(`occurred_at > ?${params.length}`);
+    }
+    if (spec.run_id !== undefined)
+      pushEq("run_id", spec.run_id);
+    if (spec.entity_kind !== undefined)
+      pushEq("entity_kind", spec.entity_kind);
+    if (spec.entity_id !== undefined)
+      pushEq("entity_id", spec.entity_id);
+    if (spec.actor !== undefined)
+      pushEq("actor", spec.actor);
+    if (spec.before !== undefined) {
+      params.push(spec.before.occurred_at);
+      const atIdx = params.length;
+      params.push(spec.before.id);
+      const idIdx = params.length;
+      clauses.push(`(occurred_at < ?${atIdx} OR (occurred_at = ?${atIdx} AND id < ?${idIdx}))`);
+    }
+    const where = clauses.length === 0 ? "" : `WHERE ${clauses.join(" AND ")}`;
+    params.push(limit);
     try {
-      if (spec.name !== undefined && spec.since !== undefined) {
-        return await this.db.queryAll(`SELECT id, event_name, occurred_at, actor, payload_json
-                     FROM system_events
-                     WHERE event_name = ?1 AND occurred_at > ?2
-                     ORDER BY occurred_at DESC
-                     LIMIT ?3`, spec.name, spec.since, limit);
-      }
-      if (spec.name !== undefined) {
-        return await this.db.queryAll(`SELECT id, event_name, occurred_at, actor, payload_json
-                     FROM system_events
-                     WHERE event_name = ?1
-                     ORDER BY occurred_at DESC
-                     LIMIT ?2`, spec.name, limit);
-      }
-      if (spec.since !== undefined) {
-        return await this.db.queryAll(`SELECT id, event_name, occurred_at, actor, payload_json
-                     FROM system_events
-                     WHERE occurred_at > ?1
-                     ORDER BY occurred_at DESC
-                     LIMIT ?2`, spec.since, limit);
-      }
-      return await this.db.queryAll(`SELECT id, event_name, occurred_at, actor, payload_json
+      return await this.db.queryAll(`SELECT ${SYSTEM_EVENT_COLUMNS}
                  FROM system_events
-                 ORDER BY occurred_at DESC
-                 LIMIT ?1`, limit);
+                 ${where}
+                 ORDER BY occurred_at DESC, id DESC
+                 LIMIT ?${params.length}`, ...params);
     } catch (error51) {
       if (error51 instanceof Error && error51.message.includes("no such table: system_events")) {
         return [];
@@ -51486,6 +51550,7 @@ class SystemEventDao {
     await this.db.run("DELETE FROM system_events");
   }
 }
+var SYSTEM_EVENT_COLUMNS = "id, event_name, occurred_at, actor, payload_json, run_id, entity_kind, entity_id, sequence";
 
 // ../../packages/domain/src/dao/task-run-link-dao.ts
 class TaskRunLinkDao {
@@ -57586,8 +57651,7 @@ var init_schema3 = __esm(() => {
 });
 
 // ../../packages/domain/src/migrations.ts
-import { readdir as readdir2 } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 async function applyCliMigrations(adapter, migrations = CLI_MIGRATIONS) {
   await adapter.exec('CREATE TABLE IF NOT EXISTS "__spur_cli_migrations" (id TEXT PRIMARY KEY, applied_at INTEGER NOT NULL)');
   let applied = 0;
@@ -57608,12 +57672,14 @@ async function applyCliMigrations(adapter, migrations = CLI_MIGRATIONS) {
   return applied;
 }
 async function loadSqlMigrations(folder) {
-  const entries = (await readdir2(folder)).filter((entry) => entry.endsWith(".sql") && entry.includes(CLI_MIGRATION_FILE_MARKER)).sort((left, right) => left.localeCompare(right));
+  const fs3 = createNodeFileSystem3();
+  const rawEntries = await fs3.readDir(folder);
+  const entries = rawEntries.filter((entry) => entry.endsWith(".sql") && entry.includes(CLI_MIGRATION_FILE_MARKER)).sort((left, right) => left.localeCompare(right));
   const migrations = [];
   for (const entry of entries) {
     migrations.push({
       id: entry.replace(/\.sql$/, ""),
-      sql: await Bun.file(join4(folder, entry)).text()
+      sql: await fs3.readFile(join5(folder, entry))
     });
   }
   return migrations.length > 0 ? migrations : CLI_MIGRATIONS;
@@ -57664,20 +57730,35 @@ CREATE TABLE IF NOT EXISTS system_events (
     event_name TEXT NOT NULL,
     occurred_at TEXT NOT NULL,
     actor TEXT,
-    payload_json TEXT
+    payload_json TEXT,
+    run_id TEXT,
+    entity_kind TEXT,
+    entity_id TEXT,
+    sequence INTEGER
 );
 
 CREATE INDEX IF NOT EXISTS idx_system_events_occurred_at ON system_events (occurred_at);
 CREATE INDEX IF NOT EXISTS idx_system_events_event_name ON system_events (event_name);
+CREATE INDEX IF NOT EXISTS idx_system_events_run_id ON system_events (run_id);
+CREATE INDEX IF NOT EXISTS idx_system_events_entity ON system_events (entity_kind, entity_id);
 `, CLI_SCHEMA_SQL, RUN_PID_COLUMN_SCHEMA_SQL = `
 ALTER TABLE runs ADD COLUMN pid INTEGER;
 `, RUNS_EXTERNAL_KEY_COLUMN_SCHEMA_SQL = `
 ALTER TABLE runs ADD COLUMN external_key TEXT;
+`, SYSTEM_EVENTS_CORRELATION_COLUMNS_SCHEMA_SQL = `
+ALTER TABLE system_events ADD COLUMN run_id TEXT;
+ALTER TABLE system_events ADD COLUMN entity_kind TEXT;
+ALTER TABLE system_events ADD COLUMN entity_id TEXT;
+ALTER TABLE system_events ADD COLUMN sequence INTEGER;
+
+CREATE INDEX IF NOT EXISTS idx_system_events_run_id ON system_events (run_id);
+CREATE INDEX IF NOT EXISTS idx_system_events_entity ON system_events (entity_kind, entity_id);
 `, CLI_MIGRATIONS, CLI_MIGRATION_FILE_MARKER = "_spur_cli_";
 var init_migrations = __esm(() => {
   init_dist7();
   init_dist8();
   init_dist10();
+  init_dist5();
   init_schema3();
   CLI_SCHEMA_SQL = `
 ${DOMAIN_SCHEMA_SQL}
@@ -57712,6 +57793,11 @@ ${SYSTEM_EVENTS_SCHEMA_SQL}
       id: "0007_spur_cli_runs_external_key",
       sql: RUNS_EXTERNAL_KEY_COLUMN_SCHEMA_SQL,
       addColumnIfMissing: { table: "runs", column: "external_key" }
+    },
+    {
+      id: "0008_spur_cli_system_events_correlation",
+      sql: SYSTEM_EVENTS_CORRELATION_COLUMNS_SCHEMA_SQL,
+      addColumnIfMissing: { table: "system_events", column: "sequence" }
     }
   ];
 });
@@ -58895,12 +58981,12 @@ var init_envelope = __esm(() => {
 
 // ../../packages/domain/src/planning/locks.ts
 import { closeSync, fsyncSync, mkdirSync as mkdirSync4, openSync, readFileSync as readFileSync7, renameSync as renameSync3, unlinkSync, writeSync } from "fs";
-import { dirname as dirname7, join as join5 } from "path";
+import { dirname as dirname7, join as join6 } from "path";
 function lockPathForEntity(folder, entityId) {
-  return join5(folder, `.${entityId}.lock`);
+  return join6(folder, `.${entityId}.lock`);
 }
 function createLockPath(folder) {
-  return join5(folder, ".create.lock");
+  return join6(folder, ".create.lock");
 }
 function parseLockContent(raw) {
   const str = typeof raw === "string" ? raw : raw.toString();
@@ -59005,7 +59091,7 @@ function fsyncPath(path9, swallowErrors = false) {
 function atomicWrite(dest, content, entityId, fs3, projectName = "spur") {
   const dir = dirname7(dest);
   const rand = Math.random().toString(36).slice(2, 10);
-  const tempPath = join5(dir, `.${projectName}.${entityId}.${rand}.tmp`);
+  const tempPath = join6(dir, `.${projectName}.${entityId}.${rand}.tmp`);
   fs3.writeFile(tempPath, content);
   fsyncPath(tempPath);
   renameSync3(tempPath, dest);
@@ -59014,7 +59100,7 @@ function atomicWrite(dest, content, entityId, fs3, projectName = "spur") {
 async function atomicWriteAsync(dest, content, entityId, fs3, projectName = "spur") {
   const dir = dirname7(dest);
   const rand = Math.random().toString(36).slice(2, 10);
-  const tempPath = join5(dir, `.${projectName}.${entityId}.${rand}.tmp`);
+  const tempPath = join6(dir, `.${projectName}.${entityId}.${rand}.tmp`);
   await fs3.writeFile(tempPath, content);
   fsyncPath(tempPath);
   renameSync3(tempPath, dest);
@@ -59029,7 +59115,7 @@ function cleanupTempFiles(folder, entityId, fs3, projectName = "spur") {
   let count3 = 0;
   for (const entry of entries) {
     if (entry.startsWith(prefix) && entry.endsWith(suffix)) {
-      fs3.deleteFile(join5(folder, entry));
+      fs3.deleteFile(join6(folder, entry));
       count3++;
     }
   }
@@ -60093,6 +60179,7 @@ __export(exports_src, {
   SystemEventDao: () => SystemEventDao,
   StageRegistryError: () => StageRegistryError,
   SYSTEM_EVENTS_SCHEMA_SQL: () => SYSTEM_EVENTS_SCHEMA_SQL,
+  SYSTEM_EVENTS_CORRELATION_COLUMNS_SCHEMA_SQL: () => SYSTEM_EVENTS_CORRELATION_COLUMNS_SCHEMA_SQL,
   STAGE_REGISTRY_SCHEMA_VERSION: () => STAGE_REGISTRY_SCHEMA_VERSION,
   STAGE_ID_PATTERN: () => STAGE_ID_PATTERN,
   STABLE_LAYER_NAMES: () => STABLE_LAYER_NAMES,
@@ -60163,7 +60250,6 @@ function bridgeEventBus(serverBus) {
 }
 
 // ../../packages/app/src/services/agent-service.ts
-import { stat } from "fs/promises";
 import { isatty as isatty3 } from "tty";
 
 class AgentService {
@@ -60567,7 +60653,7 @@ class AgentService {
   }
   async statCwd(cwd) {
     try {
-      return await stat(cwd);
+      return await createNodeFileSystem3(this.ctx.cwd).stat(cwd);
     } catch {
       return null;
     }
@@ -60746,7 +60832,7 @@ var init_agent_service = __esm(() => {
 });
 
 // ../../packages/app/src/services/corpus-migrator.ts
-import { join as join6, relative } from "path";
+import { join as join7, relative } from "path";
 function applyM1(data, flags) {
   const raw = data.status;
   if (typeof raw !== "string")
@@ -60955,15 +61041,17 @@ function yamlScalar(value) {
 }
 async function loadGitLastModified(cwd, dir) {
   try {
-    const proc = Bun.spawn(["git", "log", "--format=%aI", "--name-only", "-z", "--", dir], {
+    const result = await new NodeProcessExecutor3().run({
+      command: "git",
+      args: ["log", "--format=%aI", "--name-only", "-z", "--", dir],
       cwd,
-      stdout: "pipe",
-      stderr: "pipe"
+      maxOutput: 32 * 1024 * 1024,
+      forceBuffered: true,
+      rejectOnError: false
     });
-    const output2 = await new Response(proc.stdout).text();
-    if (await proc.exited !== 0)
+    if (result.exitCode !== 0)
       return new Map;
-    return parseGitNameOnlyZ(output2);
+    return parseGitNameOnlyZ(result.stdout);
   } catch {
     return new Map;
   }
@@ -61044,7 +61132,7 @@ class CorpusMigrator {
   }
   async discoverFiles() {
     const entries = await this.fs.readDir(this.corpusDir);
-    return entries.filter((name) => name.endsWith(".md")).filter((name) => name !== "kanban.md").map((name) => join6(this.corpusDir, name)).sort();
+    return entries.filter((name) => name.endsWith(".md")).filter((name) => name !== "kanban.md").map((name) => join7(this.corpusDir, name)).sort();
   }
   async migrateFile(filePath, dryRun, gitDates = new Map) {
     const flags = [];
@@ -61106,8 +61194,8 @@ class CorpusMigrator {
     applyM5(data, filenameParent ?? "", flags);
     applyM6(data);
     const gitDate = gitDates.get(relative(this.fs.getProjectRoot(), filePath)) ?? null;
-    const stat2 = await this.fs.stat(filePath);
-    const mtime = stat2 ? new Date(stat2.mtimeMs).toISOString() : null;
+    const stat = await this.fs.stat(filePath);
+    const mtime = stat ? new Date(stat.mtimeMs).toISOString() : null;
     applyM7(data, gitDate, mtime, flags);
     const tags = coerceArray(data.tags);
     if (tags !== undefined)
@@ -61167,6 +61255,7 @@ var PRIORITY_MAP, FIELD_ORDER, NULL_PRESERVING_KEYS, ISO_TIMESTAMP_RE;
 var init_corpus_migrator = __esm(() => {
   init_src();
   init_src2();
+  init_dist5();
   init_dist2();
   PRIORITY_MAP = {
     p0: "P0",
@@ -61331,24 +61420,42 @@ function event(name, source, renderer, payloadPolicy = "metadata-only", tier = "
 function systemEventCatalogEntry(name) {
   return SYSTEM_EVENT_CATALOG.find((entry) => entry.name === name);
 }
-function normalizeSystemEventPayload(entry, eventPayload) {
+function normalizeSystemEventPayload(entry, eventPayload, secretValues = []) {
   if (eventPayload === null || eventPayload === undefined)
     return null;
-  if (typeof eventPayload !== "object")
-    return { value: eventPayload };
+  if (typeof eventPayload !== "object") {
+    return { value: redactSecretValue(eventPayload, secretValues) };
+  }
   const source = eventPayload;
   if (entry.payloadPolicy === "raw-safe")
-    return { ...source };
+    return redactSecretValues({ ...source }, secretValues);
   const redacted = { ...source };
   for (const key of ["body", "content", "message", "prompt", "query", "response", "value"]) {
     if (key in redacted) {
       redacted[key] = "[redacted]";
     }
   }
-  return redacted;
+  return redactSecretValues(redacted, secretValues);
 }
-var SYSTEM_EVENT_CATALOG, SYSTEM_EVENT_NAMES, SYSTEM_EVENT_PERSISTED_NAMES, SYSTEM_EVENT_STREAMED_NAMES, SYSTEM_EVENT_PREFIXES, SYSTEM_EVENT_DEFAULT_NAMES, SYSTEM_EVENT_DIAGNOSTIC_NAMES, PLANNING_EVENT_NAMES, SYSTEM_EVENT_CATALOG_METADATA;
+function redactSecretValue(value, secretValues) {
+  if (typeof value === "string")
+    return redactAndBound(value, secretValues, MAX_FIELD_LENGTH);
+  if (Array.isArray(value))
+    return value.map((item) => redactSecretValue(item, secretValues));
+  if (value !== null && typeof value === "object") {
+    return redactSecretValues({ ...value }, secretValues);
+  }
+  return value;
+}
+function redactSecretValues(payload, secretValues) {
+  for (const key of Object.keys(payload)) {
+    payload[key] = redactSecretValue(payload[key], secretValues);
+  }
+  return payload;
+}
+var SYSTEM_EVENT_CATALOG, SYSTEM_EVENT_NAMES, SYSTEM_EVENT_PERSISTED_NAMES, SYSTEM_EVENT_STREAMED_NAMES, SYSTEM_EVENT_PREFIXES, SYSTEM_EVENT_DEFAULT_NAMES, SYSTEM_EVENT_DIAGNOSTIC_NAMES, PLANNING_EVENT_NAMES, SYSTEM_EVENT_CATALOG_METADATA, MAX_FIELD_LENGTH = 256;
 var init_event_names = __esm(() => {
+  init_agent_execution();
   SYSTEM_EVENT_CATALOG = [
     event("task.created", "planning", "planning"),
     event("task.updated", "planning", "planning"),
@@ -61358,12 +61465,12 @@ var init_event_names = __esm(() => {
     event("feature.transitioned", "planning", "planning"),
     event("queue.consumer.started", "queue", "queue"),
     event("queue.consumer.stopped", "queue", "queue"),
-    event("queue.job.enqueued", "queue", "queue"),
-    event("queue.job.completed", "queue", "queue"),
+    event("queue.job.enqueued", "queue", "queue", "metadata-only", "diagnostic"),
+    event("queue.job.completed", "queue", "queue", "metadata-only", "diagnostic"),
     event("queue.job.failed", "queue", "queue"),
     event("queue.job.retrying", "queue", "queue"),
     event("queue.stats", "queue", "queue"),
-    event("scheduler.job.executed", "scheduler", "scheduler"),
+    event("scheduler.job.executed", "scheduler", "scheduler", "metadata-only", "diagnostic"),
     event("message.sent", "message", "message"),
     event("message.replied", "message", "message"),
     event("process.spawned", "process", "process"),
@@ -61375,6 +61482,11 @@ var init_event_names = __esm(() => {
     event("agent.started", "agent", "agent"),
     event("agent.stopped", "agent", "agent"),
     event("agent.message.sent", "agent", "agent"),
+    event("team.up", "team", "team"),
+    event("team.down", "team", "team"),
+    event("team.member.assigned", "team", "team"),
+    event("team.member.started", "team", "team"),
+    event("team.member.stopped", "team", "team"),
     event("rule.run.start", "rule", "rule"),
     event("rule.eval.start", "rule", "rule"),
     event("rule.eval.done", "rule", "rule"),
@@ -61403,6 +61515,8 @@ var init_event_names = __esm(() => {
     event("workflow.hitl.response", "workflow", "workflow-hitl", "redacted"),
     event("workflow.hitl.note", "workflow", "workflow-hitl", "redacted"),
     event("workflow.custom", "workflow", "workflow-custom"),
+    event("workflow.agent", "workflow", "workflow-agent", "redacted", "diagnostic"),
+    event("workflow.steering", "workflow", "workflow-steering", "redacted"),
     event("api.request.error", "api", "api"),
     event("bus.emit.done", "bus", "bus", "metadata-only", "diagnostic"),
     event("bus.emit.noop", "bus", "bus", "metadata-only", "diagnostic"),
@@ -61562,13 +61676,13 @@ __export(exports_feature_check, {
   FeatureCheckService: () => FeatureCheckService,
   DEFAULT_FEATURE_MATRIX: () => DEFAULT_FEATURE_MATRIX
 });
-import { dirname as dirname8, join as join7 } from "path";
+import { dirname as dirname8, join as join8 } from "path";
 function defaultVerdictRunDir(tasksDir) {
   const norm = tasksDir.replace(/\\/g, "/");
   if (/\/docs\/tasks\d*$/.test(norm) || /\/docs\/tasks$/.test(norm)) {
-    return join7(dirname8(dirname8(tasksDir)), ".spur", "run");
+    return join8(dirname8(dirname8(tasksDir)), ".spur", "run");
   }
-  return join7(dirname8(tasksDir), ".spur", "run");
+  return join8(dirname8(tasksDir), ".spur", "run");
 }
 function rowMatchesScenario(id, sc) {
   const stripped = id.replace(/^Scenario:\s*/i, "").trim();
@@ -61638,7 +61752,7 @@ var init_feature_check = __esm(() => {
         await this.checkOneActiveGoal(fm, featureId2, options.featuresDir, findings);
         await this.checkChildrenLimit(featureId2, options.featuresDir, findings);
       }
-      const dogfoodDir = options?.dogfoodDir ?? (options?.featuresDir ? join7(dirname8(options.featuresDir), "dogfood") : undefined);
+      const dogfoodDir = options?.dogfoodDir ?? (options?.featuresDir ? join8(dirname8(options.featuresDir), "dogfood") : undefined);
       const runDir = options?.runDir ?? (options?.tasksDir ? defaultVerdictRunDir(options.tasksDir) : undefined);
       await this.runL4(doc2, featureId2, status, options?.tasksDir, dogfoodDir, runDir, findings);
       return { id: featureId2, ...this.summarizeWithStatus(status, findings, strict, options?.severityOverrides) };
@@ -61831,7 +61945,7 @@ var init_feature_check = __esm(() => {
         for (const taskAc of linkedTaskAc) {
           if (stillOrphan.size === 0)
             break;
-          const orphanedByThisTask = new Set(checkAcCoverage(acBody, taskAc).orphans);
+          const orphanedByThisTask = new Set(checkAcCoverage(acBody, taskAc, parseChecklist(taskAc)).orphans);
           stillOrphan = new Set([...stillOrphan].filter((o2) => orphanedByThisTask.has(o2)));
         }
         for (const orphan of stillOrphan) {
@@ -61899,7 +62013,7 @@ var init_feature_check = __esm(() => {
         for (const task of linkedTasks) {
           const taskCov = checkAcCoverage(`Feature: x
   Scenario: ${sc.title}
-    Given x`, task.ac);
+    Given x`, task.ac, parseChecklist(task.ac));
           if (!taskCov.orphans.includes(sc.title)) {
             linked.push({ wbs: task.wbs, status: task.status });
           }
@@ -61940,7 +62054,7 @@ var init_feature_check = __esm(() => {
     }
     async readVerdictArtifact(runDir, wbs) {
       try {
-        const raw = await this.fs.readFile(join7(runDir, `${wbs}-verdict.json`));
+        const raw = await this.fs.readFile(join8(runDir, `${wbs}-verdict.json`));
         const parsed = JSON.parse(raw);
         if (typeof parsed.verdict !== "string")
           return null;
@@ -62027,6 +62141,9 @@ var init_task_locator = __esm(() => {
 });
 
 // ../../packages/app/src/services/feature-service.ts
+function isFeatureActionName(action) {
+  return FEATURE_ACTION_NAMES.includes(action);
+}
 function stripLeadingSectionHeader(body, sectionName) {
   const match = body.match(/^(\s*)#{1,6}\s+(.+?)\s*(?:\n|$)/);
   if (match === null)
@@ -62619,6 +62736,23 @@ Feature: ${name}
 ## History
 `;
   }
+  async fulfillAction(featureId2, action, enqueue, options) {
+    const feature = await this.show(featureId2);
+    if (!feature) {
+      throw new Error(`Feature not found: ${featureId2}`);
+    }
+    if (!isFeatureActionName(action)) {
+      throw new Error(`Unsupported feature action: ${action}`);
+    }
+    const runId = await enqueue({
+      featureId: featureId2,
+      action,
+      command: FEATURE_ACTION_COMMANDS[action](featureId2),
+      channel: options?.channel,
+      skipDeps: options?.skipDeps
+    });
+    return { runId, action, status: "queued" };
+  }
 }
 function renderIndex(features) {
   const sorted = [...features].sort((a2, b) => a2.id.localeCompare(b.id));
@@ -62671,11 +62805,16 @@ ${body}`;
 function escapePipes(text4) {
   return text4.replace(/\|/g, "\\|");
 }
-var FEATURE_FILE_RE;
+var FEATURE_ACTION_NAMES, FEATURE_ACTION_COMMANDS, FEATURE_FILE_RE;
 var init_feature_service = __esm(() => {
   init_src2();
   init_feature_check();
   init_task_locator();
+  FEATURE_ACTION_NAMES = ["brainstorm", "plan"];
+  FEATURE_ACTION_COMMANDS = {
+    brainstorm: (id) => `spur dev brainstorm --feature ${id}`,
+    plan: (id) => `spur dev plan --feature ${id}`
+  };
   FEATURE_FILE_RE = /^([A-Z][1-9]*)_(.+)\.md$/;
 });
 
@@ -63092,19 +63231,21 @@ function createPsProcessInspector(platform2 = process.platform, runPs = defaultR
   };
 }
 async function defaultRunPs() {
-  const proc = Bun.spawn([...PS_LIST_ARGV], { stdout: "pipe", stderr: "pipe" });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited
-  ]);
-  if (exitCode !== 0) {
-    throw new Error(`ps failed (exit ${exitCode}): ${stderr.trim() || "no stderr"}`);
+  const [command, ...args] = PS_LIST_ARGV;
+  const result = await new NodeProcessExecutor3().run({
+    command: command ?? "ps",
+    args,
+    forceBuffered: true,
+    rejectOnError: false
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`ps failed (exit ${result.exitCode}): ${result.stderr.trim() || "no stderr"}`);
   }
-  return stdout;
+  return result.stdout;
 }
 var UnsupportedProcessPlatformError, PS_LIST_ARGV;
 var init_process_inspector = __esm(() => {
+  init_dist5();
   UnsupportedProcessPlatformError = class UnsupportedProcessPlatformError extends Error {
     code = "UNSUPPORTED_PLATFORM";
     constructor(platform2) {
@@ -63230,9 +63371,399 @@ var init_process_inventory_service = __esm(() => {
   init_process_inspector();
 });
 
+// ../../packages/app/src/services/project-registry.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync8, realpathSync as realpathSync3, renameSync as renameSync4, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
+import { connect, createServer } from "net";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname9, join as join9, resolve } from "path";
+function normalizeProjectPath(pathInput) {
+  const trimmed = pathInput.trim();
+  let expanded = trimmed;
+  if (trimmed === "~") {
+    expanded = homedir3();
+  } else if (trimmed.startsWith("~/")) {
+    expanded = join9(homedir3(), trimmed.slice(2));
+  } else {
+    expanded = resolve(trimmed);
+  }
+  try {
+    if (existsSync5(expanded)) {
+      return realpathSync3(expanded);
+    }
+  } catch {}
+  return expanded;
+}
+async function isPortLiveOnHost(port, host, timeoutMs) {
+  return new Promise((resolve2) => {
+    const socket = connect({ port, host, timeout: timeoutMs });
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve2(true);
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve2(false);
+    });
+    socket.on("error", () => {
+      socket.destroy();
+      resolve2(false);
+    });
+  });
+}
+async function isPortLive(port, timeoutMs = 200) {
+  if (port <= 0)
+    return false;
+  if (await isPortLiveOnHost(port, "127.0.0.1", timeoutMs))
+    return true;
+  if (await isPortLiveOnHost(port, "::1", timeoutMs))
+    return true;
+  return false;
+}
+async function isPortAvailable(port) {
+  if (port <= 0 || port > 65535)
+    return false;
+  return new Promise((resolve2) => {
+    const server = createServer();
+    server.unref();
+    server.on("error", () => resolve2(false));
+    server.listen({ port, host: "127.0.0.1" }, () => {
+      server.close(() => resolve2(true));
+    });
+  });
+}
+
+class ProjectRegistry {
+  filePath;
+  lockDir;
+  constructor(customPath) {
+    this.filePath = customPath ?? getProjectsFilePath();
+    this.lockDir = `${this.filePath}.lock`;
+  }
+  async withLock(fn) {
+    const lockParent = dirname9(this.lockDir);
+    if (!existsSync5(lockParent)) {
+      mkdirSync5(lockParent, { recursive: true });
+    }
+    const maxTries = 50;
+    let acquired = false;
+    for (let i2 = 0;i2 < maxTries; i2++) {
+      try {
+        mkdirSync5(this.lockDir);
+        acquired = true;
+        break;
+      } catch {
+        await new Promise((r) => setTimeout(r, 50));
+      }
+    }
+    if (!acquired) {
+      try {
+        rmSync3(this.lockDir, { recursive: true, force: true });
+        mkdirSync5(this.lockDir);
+        acquired = true;
+      } catch {
+        throw new Error(`Failed to acquire lock for project registry: ${this.lockDir}`);
+      }
+    }
+    try {
+      return await fn();
+    } finally {
+      if (acquired) {
+        try {
+          rmSync3(this.lockDir, { recursive: true, force: true });
+        } catch {}
+      }
+    }
+  }
+  readRaw() {
+    if (!existsSync5(this.filePath)) {
+      return { schema_version: 1, projects: [] };
+    }
+    try {
+      const raw = readFileSync8(this.filePath, "utf-8");
+      const json3 = JSON.parse(raw);
+      return projectsFileSchema.parse(json3);
+    } catch {
+      return { schema_version: 1, projects: [] };
+    }
+  }
+  writeRaw(data) {
+    const parentDir2 = dirname9(this.filePath);
+    if (!existsSync5(parentDir2)) {
+      mkdirSync5(parentDir2, { recursive: true });
+    }
+    const tmpFile = `${this.filePath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+    const content = JSON.stringify(data, null, 2);
+    writeFileSync4(tmpFile, content, "utf-8");
+    renameSync4(tmpFile, this.filePath);
+  }
+  async healTildePaths() {
+    return this.withLock(async () => {
+      const data = this.readRaw();
+      let changed = false;
+      for (const project of data.projects) {
+        const normalized = normalizeProjectPath(project.path);
+        if (normalized !== project.path) {
+          project.path = normalized;
+          changed = true;
+        }
+      }
+      if (changed) {
+        this.writeRaw(data);
+      }
+    });
+  }
+  async list() {
+    await this.healTildePaths();
+    await this.healStale();
+    return this.readRaw().projects;
+  }
+  async getByPath(pathInput) {
+    const normalized = normalizeProjectPath(pathInput);
+    const projects3 = await this.list();
+    return projects3.find((p) => normalizeProjectPath(p.path) === normalized);
+  }
+  async getByName(nameInput) {
+    const trimmed = nameInput.trim();
+    const projects3 = await this.list();
+    return projects3.find((p) => p.name === trimmed) ?? projects3.find((p) => p.name.toLowerCase() === trimmed.toLowerCase());
+  }
+  async upsert(entry) {
+    return this.withLock(async () => {
+      const currentData = this.readRaw();
+      const normalizedPath = normalizeProjectPath(entry.path);
+      const index2 = currentData.projects.findIndex((p) => normalizeProjectPath(p.path) === normalizedPath);
+      const newEntry = {
+        name: entry.name,
+        path: normalizedPath,
+        port: entry.port ?? 0
+      };
+      if (index2 >= 0 && currentData.projects[index2]) {
+        const existing = currentData.projects[index2];
+        currentData.projects[index2] = {
+          ...existing,
+          name: entry.name,
+          port: entry.port ?? existing.port
+        };
+      } else {
+        currentData.projects.push(newEntry);
+      }
+      this.writeRaw(currentData);
+      const res = currentData.projects.find((p) => normalizeProjectPath(p.path) === normalizedPath);
+      if (!res) {
+        throw new Error(`Failed to upsert project: ${normalizedPath}`);
+      }
+      return res;
+    });
+  }
+  async remove(nameOrPath) {
+    return this.withLock(async () => {
+      const currentData = this.readRaw();
+      const normalized = normalizeProjectPath(nameOrPath);
+      const initialLen = currentData.projects.length;
+      currentData.projects = currentData.projects.filter((p) => {
+        const pNorm = normalizeProjectPath(p.path);
+        const nameMatch = p.name.toLowerCase() === nameOrPath.trim().toLowerCase();
+        return pNorm !== normalized && !nameMatch;
+      });
+      if (currentData.projects.length !== initialLen) {
+        this.writeRaw(currentData);
+        return true;
+      }
+      return false;
+    });
+  }
+  async setPort(pathInput, port) {
+    return this.withLock(async () => {
+      const currentData = this.readRaw();
+      const normalized = normalizeProjectPath(pathInput);
+      const project = currentData.projects.find((p) => normalizeProjectPath(p.path) === normalized);
+      if (project) {
+        project.port = port;
+        this.writeRaw(currentData);
+        return true;
+      }
+      return false;
+    });
+  }
+  async allocatePort(preferredPort) {
+    if (preferredPort && preferredPort > 0 && await isPortAvailable(preferredPort)) {
+      return preferredPort;
+    }
+    const data = this.readRaw();
+    const claimedPorts = new Set(data.projects.map((p) => p.port).filter((p) => p > 0));
+    for (let port = 3000;port <= 3999; port++) {
+      if (claimedPorts.has(port))
+        continue;
+      if (await isPortAvailable(port)) {
+        return port;
+      }
+    }
+    throw new Error("No available ports in range 3000\u20133999");
+  }
+  async healStale() {
+    return this.withLock(async () => {
+      const data = this.readRaw();
+      let changed = false;
+      for (const project of data.projects) {
+        if (project.port > 0) {
+          const live = await isPortLive(project.port);
+          if (!live) {
+            project.port = 0;
+            changed = true;
+          }
+        }
+      }
+      if (changed) {
+        this.writeRaw(data);
+      }
+    });
+  }
+}
+var init_project_registry = __esm(() => {
+  init_src();
+});
+
+// ../../packages/app/src/services/project-start.ts
+import { existsSync as existsSync6 } from "fs";
+import { basename as basename2, resolve as resolve2 } from "path";
+function shQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function flattenEnv(env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== undefined)
+      out[key] = value;
+  }
+  return out;
+}
+function setDetachedServeSpawnForTests(spawn2) {
+  testDetachedServeSpawn = spawn2;
+}
+function resolveSpurServeCommand() {
+  if (process.env.SPUR_CLI_PATH && existsSync6(process.env.SPUR_CLI_PATH)) {
+    return [process.execPath, process.env.SPUR_CLI_PATH];
+  }
+  const argv1 = process.argv[1];
+  if (typeof argv1 === "string" && argv1.length > 0) {
+    const base2 = argv1.replace(/\\/g, "/");
+    if (base2.endsWith("/spur.js") || base2.endsWith("/spur") || base2.includes("/apps/cli/src/index") || base2.endsWith("apps/cli/src/index.ts")) {
+      return [process.execPath, argv1];
+    }
+  }
+  const monorepoCli = resolve2(process.cwd(), "apps/cli/src/index.ts");
+  if (existsSync6(monorepoCli)) {
+    return [process.execPath, monorepoCli];
+  }
+  const fromPath = typeof Bun !== "undefined" && typeof Bun.which === "function" ? Bun.which("spur") : null;
+  if (fromPath) {
+    return [fromPath];
+  }
+  throw new Error("Could not resolve the spur CLI to spawn `spur serve`. Ensure `spur` is on PATH (or invoke start via the monorepo CLI).");
+}
+async function startRegisteredProject(registry2, target, options = {}) {
+  let entry = await registry2.getByName(target) ?? await registry2.getByPath(target);
+  if (!entry) {
+    const absPath = normalizeProjectPath(target);
+    if (existsSync6(absPath)) {
+      entry = await registry2.upsert({ path: absPath, name: basename2(absPath), port: 0 });
+    } else {
+      throw new Error(`Project not found in registry: "${target}"`);
+    }
+  }
+  const projectPath = normalizeProjectPath(entry.path);
+  if (!existsSync6(projectPath)) {
+    throw new Error(`Project path does not exist: "${entry.path}" (resolved to ${projectPath}). Update ~/.config/spur/projects.json.`);
+  }
+  if (projectPath !== entry.path) {
+    await registry2.upsert({ name: entry.name, path: projectPath, port: entry.port });
+    entry = { ...entry, path: projectPath };
+  }
+  if (entry.port > 0 && await isPortLive(entry.port)) {
+    return {
+      name: entry.name,
+      path: projectPath,
+      port: entry.port,
+      running: true,
+      url: `http://127.0.0.1:${entry.port}`,
+      alreadyRunning: true
+    };
+  }
+  const allocatedPort = options.port && options.port > 0 ? options.port : await registry2.allocatePort();
+  const invocation = resolveSpurServeCommand();
+  const spawn2 = options.spawn ?? testDetachedServeSpawn ?? defaultDetachedServeSpawn;
+  const child = await Promise.resolve(spawn2([
+    ...invocation,
+    "serve",
+    "--cwd",
+    projectPath,
+    "--port",
+    String(allocatedPort),
+    "--host",
+    "127.0.0.1",
+    "--no-open"
+  ], {
+    cwd: projectPath,
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"],
+    env: process.env
+  }));
+  const pollAttempts = options.pollAttempts ?? 100;
+  const pollIntervalMs = options.pollIntervalMs ?? 100;
+  let live = false;
+  for (let i2 = 0;i2 < pollAttempts; i2++) {
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+    if (await isPortLive(allocatedPort)) {
+      live = true;
+      break;
+    }
+    if (child.exitCode !== null) {
+      child.unref();
+      throw new Error(`Project "${entry.name}" serve process exited with code ${child.exitCode} before port ${allocatedPort} became ready (path: ${projectPath}).`);
+    }
+  }
+  child.unref();
+  if (!live) {
+    throw new Error(`Project "${entry.name}" failed to start on port ${allocatedPort} within ${pollAttempts * pollIntervalMs / 1000}s (path: ${projectPath}).`);
+  }
+  await registry2.setPort(projectPath, allocatedPort);
+  return {
+    name: entry.name,
+    path: projectPath,
+    port: allocatedPort,
+    running: true,
+    url: `http://127.0.0.1:${allocatedPort}`,
+    alreadyRunning: false
+  };
+}
+var defaultDetachedServeSpawn = async (cmd, options) => {
+  const executor = new NodeProcessExecutor3;
+  const line = cmd.map(shQuote).join(" ");
+  const shell = process.platform === "win32" ? {
+    command: "cmd",
+    args: ["/c", `start /b "" ${cmd.map((c3) => `"${c3.replace(/"/g, '""')}"`).join(" ")}`]
+  } : {
+    command: "/bin/sh",
+    args: ["-c", `nohup ${line} </dev/null >/dev/null 2>&1 &`]
+  };
+  await executor.run({
+    command: shell.command,
+    args: shell.args,
+    ...options.cwd !== undefined ? { cwd: options.cwd } : {},
+    env: flattenEnv(options.env ?? process.env),
+    forceBuffered: true,
+    rejectOnError: false
+  });
+  return { exitCode: null, unref: () => {} };
+}, testDetachedServeSpawn;
+var init_project_start = __esm(() => {
+  init_dist5();
+  init_project_registry();
+});
+
 // ../../packages/app/src/services/rule-service.ts
-import { homedir as homedir2 } from "os";
-import { delimiter, join as join8, relative as relative2, resolve } from "path";
+import { homedir as homedir4 } from "os";
+import { delimiter, join as join10, relative as relative2, resolve as resolve3 } from "path";
 
 class RuleService {
   context;
@@ -63411,22 +63942,22 @@ ${ruleIds.join(`
     if (envValue !== undefined && envValue.length > 0) {
       for (const entry of envValue.split(delimiter)) {
         if (entry.length > 0) {
-          layers.push({ id: "env-override", path: resolve(cwd, entry), priority: -10 });
+          layers.push({ id: "env-override", path: resolve3(cwd, entry), priority: -10 });
         }
       }
     }
-    layers.push({ id: "local", path: resolve(cwd, LOCAL_RULES_DIR), priority: 0 });
+    layers.push({ id: "local", path: resolve3(cwd, LOCAL_RULES_DIR), priority: 0 });
     const globalOverride = env.SPUR_GLOBAL_RULES_DIR;
     const hasGlobalOverride = globalOverride !== undefined && globalOverride.length > 0;
     layers.push({
       id: "global",
-      path: hasGlobalOverride ? resolve(cwd, globalOverride) : join8(homedir2(), GLOBAL_RULES_DIR),
+      path: hasGlobalOverride ? resolve3(cwd, globalOverride) : join10(homedir4(), GLOBAL_RULES_DIR),
       priority: 10
     });
     if (opts.includeBundled && !hasGlobalOverride) {
       const bundledConfig = bundledConfigRoot();
       if (bundledConfig !== null) {
-        layers.push({ id: "bundled-config", path: join8(bundledConfig, "rules"), priority: 15 });
+        layers.push({ id: "bundled-config", path: join10(bundledConfig, "rules"), priority: 15 });
       }
       const bundled = await bundledRulesRoot();
       if (bundled !== null)
@@ -63576,7 +64107,7 @@ ${ruleIds.join(`
   async collectValidationErrors(source, validateSchema) {
     const { cwd, fs: fs3 } = this.context;
     if (source.kind === "file") {
-      const absolute = resolve(cwd, source.value);
+      const absolute = resolve3(cwd, source.value);
       if (!await fs3.exists(absolute))
         return [`File not found: ${absolute}`];
       try {
@@ -63600,7 +64131,7 @@ ${ruleIds.join(`
     const { fs: fs3 } = this.context;
     for (const root of await this.ruleRoots()) {
       for (const ext of ["yaml", "yml", "json"]) {
-        if (await fs3.exists(join8(root, `${name}.${ext}`)))
+        if (await fs3.exists(join10(root, `${name}.${ext}`)))
           return true;
       }
     }
@@ -63636,7 +64167,7 @@ ${ruleIds.join(`
     for (const layer of await this.existingRuleSourceLayers()) {
       const entries = await this.context.fs.readDir(layer.path);
       const named = entries.map((entry) => ({ entry, name: entry.match(/^([\w-]+)\.(?:ya?ml|json)$/i)?.[1] ?? "" })).filter(({ name }) => name.length > 0);
-      const stats = await Promise.all(named.map(({ entry }) => this.context.fs.stat(join8(layer.path, entry))));
+      const stats = await Promise.all(named.map(({ entry }) => this.context.fs.stat(join10(layer.path, entry))));
       named.forEach(({ name }, i2) => {
         if (stats[i2]?.isFile())
           candidates.add(name);
@@ -63658,7 +64189,7 @@ ${ruleIds.join(`
     for (const layer of layers) {
       for (const file2 of await this.listRuleFilesInLayer(layer.path)) {
         if (!merged.has(file2))
-          merged.set(file2, { absolutePath: join8(layer.path, file2), source: layer.id });
+          merged.set(file2, { absolutePath: join10(layer.path, file2), source: layer.id });
       }
     }
     const files = [];
@@ -63726,24 +64257,24 @@ ${ruleIds.join(`
     for (const entry of entries.sort()) {
       if (entry === "presets")
         continue;
-      const stat2 = await this.context.fs.stat(join8(root, entry));
-      if (stat2?.isDirectory())
+      const stat = await this.context.fs.stat(join10(root, entry));
+      if (stat?.isDirectory())
         dirs.push(entry);
     }
     return dirs;
   }
   async listRuleFiles(root, relativeDir) {
     const { fs: fs3 } = this.context;
-    const dir = join8(root, relativeDir);
+    const dir = join10(root, relativeDir);
     const entries = await fs3.readDir(dir);
     const files = [];
     for (const entry of entries.sort()) {
-      const relativePath2 = relativeDir.length === 0 ? entry : join8(relativeDir, entry);
-      const absolutePath = join8(root, relativePath2);
-      const stat2 = await fs3.stat(absolutePath);
-      if (stat2?.isDirectory()) {
+      const relativePath2 = relativeDir.length === 0 ? entry : join10(relativeDir, entry);
+      const absolutePath = join10(root, relativePath2);
+      const stat = await fs3.stat(absolutePath);
+      if (stat?.isDirectory()) {
         files.push(...await this.listRuleFiles(root, relativePath2));
-      } else if (stat2?.isFile() && /\.(ya?ml|json)$/i.test(entry)) {
+      } else if (stat?.isFile() && /\.(ya?ml|json)$/i.test(entry)) {
         files.push(relativePath2);
       }
     }
@@ -63764,8 +64295,8 @@ var init_rule_service = __esm(() => {
   init_src2();
   init_dist6();
   init_dist10();
-  LOCAL_RULES_DIR = join8(".spur", "rules");
-  GLOBAL_RULES_DIR = join8(".config", "spur", "rules");
+  LOCAL_RULES_DIR = join10(".spur", "rules");
+  GLOBAL_RULES_DIR = join10(".config", "spur", "rules");
   SEVERITY_RANK2 = {
     info: 0,
     warning: 1,
@@ -63773,6 +64304,212 @@ var init_rule_service = __esm(() => {
   };
 });
 
+// ../../packages/app/src/services/run-store-service.ts
+function encodeRunListCursor(id, startedAt) {
+  const payload = { id, startedAt };
+  const bytes = new TextEncoder().encode(JSON.stringify(payload));
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function decodeRunListCursor(encoded) {
+  if (encoded.length === 0 || encoded.length > 1024) {
+    throw new RunStoreBadCursorError("malformed cursor: empty or exceeds maximum length");
+  }
+  let json3;
+  try {
+    const base643 = encoded.replaceAll("-", "+").replaceAll("_", "/");
+    const binary = atob(base643);
+    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+    json3 = new TextDecoder().decode(bytes);
+  } catch {
+    throw new RunStoreBadCursorError("malformed cursor: not valid base64url");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json3);
+  } catch {
+    throw new RunStoreBadCursorError("malformed cursor: payload is not JSON");
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new RunStoreBadCursorError("malformed cursor: payload must be an object");
+  }
+  const obj = parsed;
+  if (typeof obj.id !== "string" || obj.id.length === 0) {
+    throw new RunStoreBadCursorError("malformed cursor: missing or invalid id");
+  }
+  if (typeof obj.startedAt !== "string" || obj.startedAt.length === 0) {
+    throw new RunStoreBadCursorError("malformed cursor: missing or invalid startedAt");
+  }
+  return { id: obj.id, startedAt: obj.startedAt };
+}
+function clampRunStoreLimit(raw, defaults = {
+  defaultLimit: RUN_STORE_LIST_DEFAULT_LIMIT,
+  maxLimit: RUN_STORE_LIST_MAX_LIMIT
+}) {
+  if (raw === undefined || Number.isNaN(raw) || raw <= 0)
+    return defaults.defaultLimit;
+  return Math.min(raw, defaults.maxLimit);
+}
+function summarizeActionResult(resultJson, secretValues = []) {
+  if (resultJson === null || resultJson === "")
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(resultJson);
+  } catch {
+    return { summary: redactString(resultJson, secretValues) };
+  }
+  return redactValue3(parsed, secretValues);
+}
+function redactString(value, secretValues) {
+  return redactAndBound(value, secretValues, MAX_FIELD_LENGTH2);
+}
+function redactValue3(value, secretValues) {
+  if (value === null || value === undefined)
+    return value;
+  if (typeof value === "string")
+    return redactString(value, secretValues);
+  if (typeof value === "number" || typeof value === "boolean")
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => redactValue3(item, secretValues));
+  if (typeof value === "object") {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (SENSITIVE_KEYS.has(key)) {
+        out[key] = "[redacted]";
+      } else {
+        out[key] = redactValue3(child, secretValues);
+      }
+    }
+    return out;
+  }
+  return redactString(String(value), secretValues);
+}
+function toListEntry(row) {
+  return {
+    id: row.id,
+    workflowName: row.workflow_name,
+    status: row.status,
+    mode: row.mode,
+    agent: row.agent,
+    startedAt: row.started_at,
+    completedAt: row.completed_at
+  };
+}
+
+class RunStoreService {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async list(query = {}) {
+    const limit = clampRunStoreLimit(query.limit);
+    let before;
+    if (query.cursor !== undefined && query.cursor.length > 0) {
+      const decoded = decodeRunListCursor(query.cursor);
+      before = { started_at: decoded.startedAt, id: decoded.id };
+    }
+    const db2 = await this.ctx.getDb();
+    const rows = await new RunDao(db2).traceRows({
+      status: query.status,
+      before,
+      limit: limit + 1
+    });
+    const hasMore = rows.length > limit;
+    const page = hasMore ? rows.slice(0, limit) : rows;
+    const last = page.at(-1);
+    const nextCursor = hasMore && last ? encodeRunListCursor(last.id, last.started_at) : null;
+    return {
+      runs: page.map(toListEntry),
+      count: page.length,
+      nextCursor,
+      hasMore
+    };
+  }
+  async getDetail(runId) {
+    const db2 = await this.ctx.getDb();
+    const row = await new RunDao(db2).traceRowById(runId);
+    if (!row) {
+      throw new RunStoreNotFoundError(runId);
+    }
+    const [phaseRows, transitionRows, actionRows] = await Promise.all([
+      new PhaseRunDao(db2).phaseRowsByRunId(runId),
+      new TransitionRunDao(db2).transitionRowsByRunId(runId),
+      new ActionRunDao(db2).actionRowsByRunId(runId)
+    ]);
+    return {
+      run: toListEntry(row),
+      phases: phaseRows.map((p) => ({
+        phase: p.phase,
+        status: p.status,
+        startedAt: p.started_at,
+        completedAt: p.completed_at
+      })),
+      transitions: transitionRows.map((t) => ({
+        from: t.from_state,
+        to: t.to_state,
+        trigger: t.trigger
+      })),
+      actions: actionRows.map((a2) => ({
+        id: a2.id,
+        node: a2.node,
+        kind: a2.kind,
+        status: a2.status,
+        durationMs: a2.duration_ms,
+        ok: a2.ok === null ? null : a2.ok === 1,
+        resultSummary: summarizeActionResult(a2.result_json, this.ctx.secretValues),
+        startedAt: a2.started_at,
+        completedAt: a2.completed_at
+      }))
+    };
+  }
+  async listByWbs(wbs, limitRaw) {
+    const limit = clampRunStoreLimit(limitRaw, {
+      defaultLimit: RUN_STORE_WBS_DEFAULT_LIMIT,
+      maxLimit: RUN_STORE_WBS_MAX_LIMIT
+    });
+    const db2 = await this.ctx.getDb();
+    const linkRows = await new TaskRunLinkDao(db2).listByWbs(wbs, limit);
+    const runDao = new RunDao(db2);
+    const links = [];
+    for (const link of linkRows) {
+      const runRow = await runDao.traceRowById(link.run_id);
+      links.push({
+        runId: link.run_id,
+        kind: link.kind,
+        linkedAt: link.created_at,
+        run: runRow ? toListEntry(runRow) : null
+      });
+    }
+    return { wbs, links, count: links.length };
+  }
+}
+var RUN_STORE_LIST_DEFAULT_LIMIT = 50, RUN_STORE_LIST_MAX_LIMIT = 200, RUN_STORE_WBS_DEFAULT_LIMIT = 50, RUN_STORE_WBS_MAX_LIMIT = 200, MAX_FIELD_LENGTH2 = 256, SENSITIVE_KEYS, RunStoreNotFoundError, RunStoreBadCursorError;
+var init_run_store_service = __esm(() => {
+  init_src2();
+  init_agent_execution();
+  SENSITIVE_KEYS = new Set(["body", "content", "message", "prompt", "query", "response", "value"]);
+  RunStoreNotFoundError = class RunStoreNotFoundError extends Error {
+    runId;
+    code = "RUN_NOT_FOUND";
+    constructor(runId) {
+      super(`run not found: ${runId}`);
+      this.runId = runId;
+      this.name = "RunStoreNotFoundError";
+    }
+  };
+  RunStoreBadCursorError = class RunStoreBadCursorError extends Error {
+    code = "MALFORMED_CURSOR";
+    constructor(reason) {
+      super(reason);
+      this.name = "RunStoreBadCursorError";
+    }
+  };
+});
+
 // ../../packages/app/src/services/supervisor-service.ts
 function defaultWrapperArgv(agentId) {
   return {
@@ -63785,6 +64522,7 @@ class SupervisorService {
   processExecutor;
   eventBus;
   configDir;
+  teamMemberStopEmitted = new Set;
   ringBufferSize;
   processes = new Map;
   ringBuffers = new Map;
@@ -63863,6 +64601,12 @@ class SupervisorService {
       teamId,
       agentType: spec.type
     });
+    this.emitTeamMember("team.member.started", {
+      teamId,
+      memberId: agentId,
+      agentType: spec.type ?? null,
+      outcome: "started"
+    });
     handle.exited.then(async (code) => {
       entry.exitCode = code;
       this.emit("process.exited", {
@@ -63872,6 +64616,16 @@ class SupervisorService {
         teamId: entry.teamId ?? null,
         ...entry.agentType ? { agentType: entry.agentType } : {}
       });
+      if (!this.teamMemberStopEmitted.has(agentId)) {
+        this.emitTeamMember("team.member.stopped", {
+          teamId: entry.teamId ?? null,
+          memberId: agentId,
+          agentType: entry.agentType ?? null,
+          outcome: code === 0 ? "exited" : "errored"
+        });
+      } else {
+        this.teamMemberStopEmitted.delete(agentId);
+      }
       if (code === 0 || entry.status === "stopped") {
         entry.status = "exited";
         this.scheduleCleanup(agentId, entry);
@@ -63897,13 +64651,14 @@ class SupervisorService {
     const proc = this.processes.get(agentId);
     if (proc?.entry.status !== "running")
       return;
+    this.teamMemberStopEmitted.add(agentId);
     proc.handle.kill("SIGTERM");
     let timedOut = false;
     const exitPromise = proc.handle.exited;
-    const timeout = new Promise((resolve2) => {
+    const timeout = new Promise((resolve4) => {
       setTimeout(() => {
         timedOut = true;
-        resolve2();
+        resolve4();
       }, 3000);
     });
     await Promise.race([exitPromise, timeout]);
@@ -63924,6 +64679,12 @@ class SupervisorService {
       teamId: proc.entry.teamId ?? null,
       ...proc.entry.agentType ? { agentType: proc.entry.agentType } : {}
     });
+    this.emitTeamMember("team.member.stopped", {
+      teamId: proc.entry.teamId ?? null,
+      memberId: agentId,
+      agentType: proc.entry.agentType ?? null,
+      outcome: "stopped"
+    });
   }
   async startAutostart(ids) {
     const results = [];
@@ -64004,25 +64765,49 @@ class SupervisorService {
       this.eventBus.emit(name, payload);
     } catch {}
   }
+  emitTeamMember(name, payload) {
+    try {
+      this.eventBus.emit(name, payload);
+    } catch {}
+  }
 }
 var DEFAULT_RING_BUFFER_SIZE = 500, MAX_RESTART_ATTEMPTS = 5, RESTART_BACKOFF_SCHEDULE, MAX_RESTART_BACKOFF = 30000;
 var init_supervisor_service = __esm(() => {
   RESTART_BACKOFF_SCHEDULE = [1000, 2000, 4000, 8000, 16000];
 });
 
+// ../../packages/app/src/services/system-event-retention.ts
+function resolveRetentionQuotas(config4 = {}, prefixes = SYSTEM_EVENT_PREFIXES) {
+  const defaultQuota = config4.default ?? DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA;
+  const overrides = config4.prefixes ?? {};
+  return prefixes.map((prefix) => ({
+    prefix,
+    quota: overrides[prefix] ?? defaultQuota
+  }));
+}
+var DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA = 1e4;
+var init_system_event_retention = __esm(() => {
+  init_event_names();
+});
+
 // ../../packages/app/src/services/system-event-tap.ts
 function registerSystemEventTap(bus, dao2, logger3, options = {}) {
   const handlers = new Map;
   const inFlight = new Set;
   const diagnosticEnabled = options.diagnosticEnabled === true;
+  const quotas = resolveRetentionQuotas(options.retention);
   for (const entry of SYSTEM_EVENT_CATALOG) {
     if (entry.tier === "diagnostic" && !diagnosticEnabled)
       continue;
     const handler = (event2) => {
-      const occurredAt = new Date().toISOString();
-      const payloadJson = safeStringify(normalizeSystemEventPayload(entry, event2));
-      const actor = extractSystemEventActor(event2);
-      const p = persist(dao2, entry.name, occurredAt, actor, payloadJson, logger3);
+      const p = persist(dao2, entry.prefix, {
+        id: createId("sev"),
+        event_name: entry.name,
+        occurred_at: new Date().toISOString(),
+        actor: extractSystemEventActor(event2),
+        payload_json: safeStringify(normalizeSystemEventPayload(entry, event2, options.secretValues)),
+        ...extractSystemEventCorrelation(event2)
+      }, quotas, logger3);
       inFlight.add(p);
       p.finally(() => inFlight.delete(p));
     };
@@ -64043,18 +64828,15 @@ function registerSystemEventTap(bus, dao2, logger3, options = {}) {
     }
   };
 }
-async function persist(dao2, name, occurredAt, actor, payloadJson, logger3) {
+async function persist(dao2, prefix, input, quotas, logger3) {
   try {
-    await dao2.insert({
-      id: createId("sev"),
-      event_name: name,
-      occurred_at: occurredAt,
-      actor,
-      payload_json: payloadJson
-    });
-    await dao2.prune(SYSTEM_EVENTS_CAP);
+    await dao2.insert(input);
+    await dao2.pruneQuotas(quotas, prefix);
   } catch (error51) {
-    logger3.warn("system_events tap: persist failed", { name, error: stringifyError(error51) });
+    logger3.warn("system_events tap: persist failed", {
+      name: input.event_name,
+      error: stringifyError(error51)
+    });
   }
 }
 function safeStringify(event2) {
@@ -64071,27 +64853,52 @@ function extractSystemEventActor(event2) {
       return obj.actor;
     if (typeof obj.agentId === "string" && obj.agentId.length > 0)
       return obj.agentId;
+    if (typeof obj.memberId === "string" && obj.memberId.length > 0)
+      return obj.memberId;
   }
   return null;
 }
+function extractSystemEventCorrelation(event2) {
+  const correlation = { run_id: null, entity_kind: null, entity_id: null, sequence: null };
+  if (!event2 || typeof event2 !== "object")
+    return correlation;
+  const obj = event2;
+  if (typeof obj.runId === "string" && obj.runId.length > 0)
+    correlation.run_id = obj.runId;
+  if (typeof obj.sequence === "number" && Number.isFinite(obj.sequence))
+    correlation.sequence = obj.sequence;
+  const entity2 = obj.entity;
+  if (entity2 && typeof entity2 === "object") {
+    const { kind, id } = entity2;
+    if (typeof kind === "string" && kind.length > 0)
+      correlation.entity_kind = kind;
+    if (typeof id === "string" && id.length > 0)
+      correlation.entity_id = id;
+  }
+  return correlation;
+}
 function stringifyError(error51) {
   if (error51 instanceof Error)
     return `${error51.name}: ${error51.message}`;
   return String(error51);
 }
-var SYSTEM_EVENTS_CAP = 1e4;
 var init_system_event_tap = __esm(() => {
   init_src2();
   init_event_names();
+  init_system_event_retention();
 });
 
 // ../../packages/app/src/services/system-event-emitter.ts
 class SystemEventEmitter {
   dao;
   logger;
-  constructor(dao2, logger3) {
+  secretValues;
+  quotas;
+  constructor(dao2, logger3, retention = {}, secretValues = []) {
     this.dao = dao2;
     this.logger = logger3;
+    this.secretValues = secretValues;
+    this.quotas = resolveRetentionQuotas(retention);
   }
   async emit(event2) {
     const entry = systemEventCatalogEntry(event2.event);
@@ -64103,9 +64910,10 @@ class SystemEventEmitter {
         event_name: entry.name,
         occurred_at: event2.at,
         actor: extractSystemEventActor(event2),
-        payload_json: safeStringify(normalizeSystemEventPayload(entry, event2))
+        payload_json: safeStringify(normalizeSystemEventPayload(entry, event2, this.secretValues)),
+        ...extractSystemEventCorrelation(event2)
       });
-      await this.dao.prune(SYSTEM_EVENTS_CAP);
+      await this.dao.pruneQuotas(this.quotas, entry.prefix);
     } catch (error51) {
       this.logger.warn("system_events emitter: persist failed", {
         event: event2.event,
@@ -64117,11 +64925,12 @@ class SystemEventEmitter {
 var init_system_event_emitter = __esm(() => {
   init_src2();
   init_event_names();
+  init_system_event_retention();
   init_system_event_tap();
 });
 
 // ../../packages/app/src/services/task-check.ts
-import { dirname as dirname9, join as join9 } from "path";
+import { dirname as dirname10, join as join11 } from "path";
 function isPlaceholderBody(body) {
   const stripped = body.replace(/<!--[\s\S]*?-->/g, "").replace(/^\s*>\s*TBD\s*$/gim, "").trim();
   return stripped.length === 0;
@@ -64182,9 +64991,9 @@ function isProseOnlyReview(body) {
 function resolveProjectRootFromTasksDir(tasksDir) {
   const norm = tasksDir.replace(/\\/g, "/");
   if (/\/docs\/tasks\d*$/.test(norm) || /\/docs\/tasks$/.test(norm)) {
-    return dirname9(dirname9(tasksDir));
+    return dirname10(dirname10(tasksDir));
   }
-  return dirname9(tasksDir);
+  return dirname10(tasksDir);
 }
 function extractBacktickLineAnchors(body) {
   const out = [];
@@ -64269,8 +65078,8 @@ var init_task_check = __esm(() => {
       const entry = this.resolveMatrixEntry(variant, status);
       this.runL2(doc2, entry, findings);
       this.runL3(doc2, entry, status, findings);
-      const tasksDir = dirname9(filePath);
-      const featuresDir = join9(dirname9(tasksDir), "features");
+      const tasksDir = dirname10(filePath);
+      const featuresDir = join11(dirname10(tasksDir), "features");
       await this.runL4(doc2, fm, status, findings, featuresDir, tasksDir);
       await this.runL4Rollup(doc2, wbs, status, findings, tasksDir);
       if (status !== "done" && status !== "cancelled") {
@@ -64651,7 +65460,7 @@ var init_task_check = __esm(() => {
         for (const cite of citations) {
           if (reported >= 5)
             break;
-          const abs = join9(projectRoot, cite.path);
+          const abs = join11(projectRoot, cite.path);
           let exists2 = false;
           try {
             exists2 = await this.fs.exists(abs);
@@ -64769,7 +65578,6 @@ var init_task_check = __esm(() => {
 });
 
 // ../../packages/app/src/services/task-record.ts
-import { execSync } from "child_process";
 function escapeTablePipe(s) {
   return s.replace(/\|/g, "\\|");
 }
@@ -64953,19 +65761,23 @@ function extractChangedFiles(diffText) {
 }
 function gitDiffU0(cwd) {
   try {
-    return execSync("git diff -U0 HEAD -- '*.ts' '*.tsx' '*.js'", {
-      cwd,
-      encoding: "utf-8",
-      timeout: 1e4
+    const result = new BunSyncProcessExecutor2().runSync({
+      command: "git",
+      args: ["diff", "-U0", "HEAD", "--", "*.ts", "*.tsx", "*.js"],
+      ...cwd !== undefined ? { cwd } : {},
+      rejectOnError: false
     });
+    return result.exitCode === 0 ? result.stdout : "";
   } catch {
     return "";
   }
 }
-var init_task_record = () => {};
+var init_task_record = __esm(() => {
+  init_dist5();
+});
 
 // ../../packages/app/src/services/task-scaffold.ts
-import { dirname as dirname10 } from "path";
+import { dirname as dirname11 } from "path";
 
 class TaskScaffoldService {
   ctx;
@@ -65008,7 +65820,7 @@ class TaskScaffoldService {
       fileExists = false;
     }
     const mergeResult = mergeStubs(existingContent, stubs);
-    const dir = dirname10(targetFile);
+    const dir = dirname11(targetFile);
     await this.ctx.fs.ensureDir(dir);
     if (mergeResult.created > 0 || !fileExists) {
       await this.ctx.fs.writeFile(targetFile, mergeResult.content);
@@ -65770,8 +66582,8 @@ ${block}` : block);
       return { wbs: hit.wbs, filePath: hit.filePath };
     if (opts.strict === true)
       return null;
-    const basename2 = filePath.split("/").pop() ?? "";
-    const capturedWbs = /^(\d{4})_.+\.md$/.exec(basename2)?.[1];
+    const basename3 = filePath.split("/").pop() ?? "";
+    const capturedWbs = /^(\d{4})_.+\.md$/.exec(basename3)?.[1];
     if (capturedWbs) {
       const taskPath = await this.locator.findPathByWbs(capturedWbs);
       if (taskPath !== null)
@@ -66145,7 +66957,7 @@ var init_task_verdict = __esm(() => {
 });
 
 // ../../packages/app/src/services/team-service.ts
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 
 class TeamService {
   ctx;
@@ -66153,7 +66965,7 @@ class TeamService {
   orchestratorPromise;
   constructor(ctx) {
     this.ctx = ctx;
-    this.configDir = join10(ctx.cwd, ".spur", "agents");
+    this.configDir = join12(ctx.cwd, ".spur", "agents");
   }
   async sendMessage(fromId, toId, body, replyTo) {
     validateAgentId(toId);
@@ -66298,6 +67110,14 @@ class TeamService {
     const doc2 = MarkdownDocument.parse(source, "task");
     doc2.setFrontmatterField("assignee", agentId);
     await atomicWriteAsync(path9, doc2.serialize(), taskId, fs3);
+    const identity6 = await this.resolveMemberIdentity(agentId);
+    this.emitTeamMemberEvent("team.member.assigned", {
+      teamId: identity6.teamId,
+      memberId: agentId,
+      agentType: identity6.agentType,
+      outcome: "assigned",
+      taskId
+    });
   }
   async createAgentSpec(input) {
     validateAgentId(input.id);
@@ -66437,12 +67257,18 @@ class TeamService {
     for (const spec of orphaned) {
       await deleteAgentSpec(spec.id, this.configDir);
     }
-    return {
+    const result = {
       teamId,
       upserted: toUpsert.map((s) => s.id),
       orphaned: orphaned.map((s) => s.id),
       written: true
     };
+    this.emitTeamLifecycleEvent("team.up", {
+      teamId,
+      memberCount: result.upserted.length,
+      outcome: "ok"
+    });
+    return result;
   }
   async teardownTeam(teamId, opts) {
     const specs = await loadAgentSpecs(this.configDir);
@@ -66453,11 +67279,17 @@ class TeamService {
         await deleteAgentSpec(spec.id, this.configDir);
       }
     }
-    return {
+    const result = {
       teamId,
       purged: opts?.purge ? generated.map((s) => s.id) : [],
       stopped: teamSpecs.map((s) => s.id)
     };
+    this.emitTeamLifecycleEvent("team.down", {
+      teamId,
+      memberCount: result.stopped.length,
+      outcome: opts?.purge ? "purged" : "ok"
+    });
+    return result;
   }
   async loadTeamConfig() {
     try {
@@ -66478,18 +67310,72 @@ class TeamService {
       bus.emit(name, payload);
     } catch {}
   }
+  emitTeamLifecycleEvent(name, payload) {
+    const bus = this.ctx.eventBus;
+    if (!bus)
+      return;
+    try {
+      bus.emit(name, payload);
+    } catch {}
+  }
+  emitTeamMemberEvent(name, payload) {
+    const bus = this.ctx.eventBus;
+    if (!bus)
+      return;
+    try {
+      bus.emit(name, payload);
+    } catch {}
+  }
+  async resolveMemberIdentity(agentId) {
+    try {
+      const specs = await loadAgentSpecs(this.configDir);
+      const spec = specs.find((s) => s.id === agentId);
+      if (!spec)
+        return { teamId: null, agentType: null };
+      const teamTag = spec.tags?.find((t) => t.startsWith("team:"));
+      return {
+        teamId: teamTag ? teamTag.slice("team:".length) : null,
+        agentType: typeof spec.type === "string" && spec.type.length > 0 ? spec.type : null
+      };
+    } catch {
+      return { teamId: null, agentType: null };
+    }
+  }
   async inboxRecentDao() {
     const db2 = await this.ctx.getDb();
     return new InboxRecentDao(db2);
   }
   orchestrator() {
-    this.orchestratorPromise ??= this.inboxDao().then((dao2) => new TeamOrchestrator(this.configDir, dao2, { events: this.ctx.events }));
+    this.orchestratorPromise ??= this.inboxDao().then((dao2) => {
+      const orch = new TeamOrchestrator(this.configDir, dao2, { events: this.ctx.events });
+      orch.on("agent.started", (event2) => {
+        this.resolveMemberIdentity(event2.agentId).then((identity6) => {
+          this.emitTeamMemberEvent("team.member.started", {
+            teamId: identity6.teamId,
+            memberId: event2.agentId,
+            agentType: event2.agentType ?? identity6.agentType,
+            outcome: "started"
+          });
+        });
+      });
+      orch.on("agent.stopped", (event2) => {
+        this.resolveMemberIdentity(event2.agentId).then((identity6) => {
+          this.emitTeamMemberEvent("team.member.stopped", {
+            teamId: identity6.teamId,
+            memberId: event2.agentId,
+            agentType: identity6.agentType,
+            outcome: "stopped"
+          });
+        });
+      });
+      return orch;
+    });
     return this.orchestratorPromise;
   }
   async resolveTaskFile(taskId) {
     const fs3 = this.ctx.fs;
     const { foldersConfig } = await resolvePlanningFolders(fs3);
-    const dirs = [...new Set([foldersConfig.active_folder, ...Object.keys(foldersConfig.folders)])].map((dir) => join10(this.ctx.cwd, dir));
+    const dirs = [...new Set([foldersConfig.active_folder, ...Object.keys(foldersConfig.folders)])].map((dir) => join12(this.ctx.cwd, dir));
     return await TaskLocator.forDirs(fs3, dirs).findPathByWbs(taskId);
   }
 }
@@ -66525,8 +67411,8 @@ var init_team_service = __esm(() => {
 });
 
 // ../../packages/app/src/services/token-ledger-service.ts
-import { closeSync as closeSync2, existsSync as existsSync5, fstatSync, openSync as openSync2, readSync } from "fs";
-import { join as join11 } from "path";
+import { closeSync as closeSync2, existsSync as existsSync7, fstatSync, openSync as openSync2, readSync } from "fs";
+import { join as join13 } from "path";
 function isSparseToolActivity(events2) {
   return events2.length === 0 || !events2.some((e) => TOOL_ACTIVITY_TYPES.has(e.type));
 }
@@ -66577,7 +67463,7 @@ function parseLedgerLine(line) {
   }
 }
 function tailTokenLedgerFile(filePath, limit, chunkSize = DEFAULT_CHUNK, before) {
-  if (!existsSync5(filePath)) {
+  if (!existsSync7(filePath)) {
     return { events: [], truncated: false };
   }
   const target = limit + 1;
@@ -66627,7 +67513,7 @@ class TokenLedgerService {
   ledgerPath;
   chunkSize;
   constructor(options) {
-    this.ledgerPath = options.ledgerPath ?? join11(options.cwd, TOKEN_LEDGER_RELATIVE_PATH);
+    this.ledgerPath = options.ledgerPath ?? join13(options.cwd, TOKEN_LEDGER_RELATIVE_PATH);
     this.chunkSize = options.chunkSize ?? DEFAULT_CHUNK;
   }
   get path() {
@@ -66668,12 +67554,12 @@ class TokenLedgerService {
 var TOOL_ACTIVITY_TYPES, TOKEN_LEDGER_DEFAULT_LIMIT = 200, TOKEN_LEDGER_MAX_LIMIT = 1000, TOKEN_LEDGER_RELATIVE_PATH, DEFAULT_CHUNK;
 var init_token_ledger_service = __esm(() => {
   TOOL_ACTIVITY_TYPES = new Set(["read", "write", "bash", "grep", "glob"]);
-  TOKEN_LEDGER_RELATIVE_PATH = join11(".spur", "context", "token-ledger.jsonl");
+  TOKEN_LEDGER_RELATIVE_PATH = join13(".spur", "context", "token-ledger.jsonl");
   DEFAULT_CHUNK = 64 * 1024;
 });
 
 // ../../packages/app/src/services/token-ledger-watcher.ts
-import { closeSync as closeSync3, existsSync as existsSync6, fstatSync as fstatSync2, openSync as openSync3, readSync as readSync2, watch } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync8, fstatSync as fstatSync2, openSync as openSync3, readSync as readSync2, watch } from "fs";
 
 class TokenLedgerWatcher {
   ledgerPath;
@@ -66694,7 +67580,7 @@ class TokenLedgerWatcher {
     this.started = true;
     this.offset = this.currentSize();
     try {
-      const target = existsSync6(this.ledgerPath) ? this.ledgerPath : this.parentDir();
+      const target = existsSync8(this.ledgerPath) ? this.ledgerPath : this.parentDir();
       this.watcher = watch(target, () => this.schedulePoll());
     } catch {
       this.watcher = undefined;
@@ -66729,7 +67615,7 @@ class TokenLedgerWatcher {
     return idx > 0 ? this.ledgerPath.slice(0, idx) : ".";
   }
   currentSize() {
-    if (!existsSync6(this.ledgerPath))
+    if (!existsSync8(this.ledgerPath))
       return 0;
     try {
       const fd = openSync3(this.ledgerPath, "r");
@@ -66751,7 +67637,7 @@ class TokenLedgerWatcher {
     }, this.debounceMs);
   }
   pollNewBytes() {
-    if (!existsSync6(this.ledgerPath)) {
+    if (!existsSync8(this.ledgerPath)) {
       this.offset = 0;
       this.carry = "";
       return;
@@ -66842,16 +67728,16 @@ class WorkflowSteeringController {
     active.state = "boundary";
     active.version += 1;
     this.publishState(active);
-    return await new Promise((resolve2) => {
+    return await new Promise((resolve4) => {
       const settle = (decision) => {
         clearTimeout(timer);
-        resolve2(decision);
+        resolve4(decision);
       };
       const timer = setTimeout(() => {
         if (active.resolve !== settle)
           return;
         active.resolve = undefined;
-        this.acceptDefault(active, resolve2);
+        this.acceptDefault(active, resolve4);
       }, active.policy.timeoutMs);
       timer.unref?.();
       active.resolve = settle;
@@ -66949,7 +67835,7 @@ class WorkflowSteeringController {
       deadlineAt: new Date(Date.now() + deadlineMs).toISOString()
     });
   }
-  acceptDefault(active, resolve2) {
+  acceptDefault(active, resolve4) {
     const command = {
       commandId: crypto.randomUUID(),
       runId: active.runId,
@@ -66974,7 +67860,7 @@ class WorkflowSteeringController {
       at: new Date().toISOString()
     };
     this.onAck?.(ack);
-    resolve2({ operation: "continue" });
+    resolve4({ operation: "continue" });
   }
   accept(command, active, note) {
     return this.publish({
@@ -67037,11 +67923,7 @@ var init_steering = __esm(() => {
 });
 
 // ../../packages/app/src/workflow/actions/agent-run.ts
-import { execFile } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import { dirname as dirname11, isAbsolute as isAbsolute2, join as join12 } from "path";
-import { promisify as promisify3 } from "util";
+import { dirname as dirname12, isAbsolute as isAbsolute2, join as join14 } from "path";
 
 class AgentRunActionRunner {
   observabilityBus;
@@ -67135,13 +68017,15 @@ class AgentRunActionRunner {
     const ok = exitCode === 0;
     const invocation = traced.invocation;
     if (capture && answerFile !== undefined) {
-      const target = isAbsolute2(answerFile) ? answerFile : join12(cwd, answerFile);
-      await mkdir(dirname11(target), { recursive: true });
-      await writeFile(target, answer, "utf8");
+      const target = isAbsolute2(answerFile) ? answerFile : join14(cwd, answerFile);
+      const fs3 = createNodeFileSystem3(cwd);
+      await fs3.ensureDir(dirname12(target));
+      await fs3.writeFile(target, answer);
     }
     if (ok && expectFile !== undefined) {
-      const target = isAbsolute2(expectFile) ? expectFile : join12(cwd, expectFile);
-      if (!existsSync7(target)) {
+      const target = isAbsolute2(expectFile) ? expectFile : join14(cwd, expectFile);
+      const fs3 = createNodeFileSystem3(cwd);
+      if (!await fs3.exists(target)) {
         return {
           ok: false,
           data: buildResultData(exitCode, agentLabel, capture, answer, invocation),
@@ -67248,15 +68132,23 @@ async function writePartialWorkArtifact(context4, agentLabel, model, traced, cwd
       ""
     ].join(`
 `);
-    const target = join12(cwd, ".spur", "run", `${context4.runId}-${context4.stateOrNodeId}-partial.md`);
-    await mkdir(dirname11(target), { recursive: true });
-    await writeFile(target, body, "utf8");
+    const target = join14(cwd, ".spur", "run", `${context4.runId}-${context4.stateOrNodeId}-partial.md`);
+    const fs3 = createNodeFileSystem3(cwd);
+    await fs3.ensureDir(dirname12(target));
+    await fs3.writeFile(target, body);
   } catch {}
 }
 async function gitDiffStat(cwd) {
   try {
-    const { stdout } = await execFileAsync("git", ["diff", "--stat"], { cwd, maxBuffer: 1024 * 1024 });
-    return stdout.trim();
+    const result = await new NodeProcessExecutor3().run({
+      command: "git",
+      args: ["diff", "--stat"],
+      cwd,
+      maxOutput: 1024 * 1024,
+      forceBuffered: true,
+      rejectOnError: false
+    });
+    return result.exitCode === 0 ? result.stdout.trim() : "";
   } catch {
     return "";
   }
@@ -67267,10 +68159,10 @@ function tail(text4, maxChars) {
   return `... (truncated) ...
 ${text4.slice(text4.length - maxChars)}`;
 }
-var execFileAsync, PARTIAL_ARTIFACT_TAIL_CHARS = 4000, KIND = "agent.run";
+var PARTIAL_ARTIFACT_TAIL_CHARS = 4000, KIND = "agent.run";
 var init_agent_run = __esm(() => {
+  init_dist5();
   init_steering();
-  execFileAsync = promisify3(execFile);
 });
 
 // ../../packages/app/src/workflow/actions/file-exists.ts
@@ -67326,17 +68218,17 @@ class FileReadActionRunner {
     }
     const maxSize = asNumber(options.maxSize);
     const resolved = joinPath2(context4.workdir ?? ".", rawPath);
-    const stat2 = await this.fileSystem.stat(resolved);
-    if (stat2 === null) {
+    const stat = await this.fileSystem.stat(resolved);
+    if (stat === null) {
       return { ok: false, error: `file.read: file not found: ${resolved}` };
     }
-    if (maxSize !== undefined && stat2.size > maxSize) {
-      return { ok: false, error: `file.read: file too large (${stat2.size} > ${maxSize}): ${resolved}` };
+    if (maxSize !== undefined && stat.size > maxSize) {
+      return { ok: false, error: `file.read: file too large (${stat.size} > ${maxSize}): ${resolved}` };
     }
     const content = await this.fileSystem.readFile(resolved);
     return {
       ok: true,
-      data: { content, size: stat2.size, path: resolved }
+      data: { content, size: stat.size, path: resolved }
     };
   }
 }
@@ -67374,15 +68266,15 @@ class FileReadIntoVarActionRunner {
     }
     const trim = options.trim === undefined ? true : options.trim !== false;
     const resolved = isAbsolutePath2(rawPath) ? normalizeSeparators2(rawPath) : joinPath2(context4.workdir ?? ".", rawPath);
-    const stat2 = await this.fileSystem.stat(resolved);
-    if (stat2 === null) {
+    const stat = await this.fileSystem.stat(resolved);
+    if (stat === null) {
       return { ok: false, error: `file.read.into-var: file not found: ${resolved}` };
     }
     const raw = await this.fileSystem.readFile(resolved);
     const projected = trim ? raw.replace(/\s+$/u, "") : raw;
     return {
       ok: true,
-      data: { content: projected, raw, var: varName, path: resolved, size: stat2.size },
+      data: { content: projected, raw, var: varName, path: resolved, size: stat.size },
       setVars: { [varName]: projected }
     };
   }
@@ -67826,7 +68718,7 @@ var init_builtins2 = __esm(() => {
 // ../../packages/app/src/workflow/observability.ts
 function bounded(value) {
   const redacted = value.replace(SECRET_PATTERN2, "[REDACTED]");
-  return redacted.length <= MAX_FIELD_LENGTH ? redacted : `${redacted.slice(0, MAX_FIELD_LENGTH)}\u2026`;
+  return redacted.length <= MAX_FIELD_LENGTH3 ? redacted : `${redacted.slice(0, MAX_FIELD_LENGTH3)}\u2026`;
 }
 function projectActionMetadata(kind, options) {
   if (options === undefined)
@@ -67971,16 +68863,19 @@ class ObservableWorkflowAdapter {
     return this.inner.listPausedRuns(options);
   }
 }
-var now = () => new Date().toISOString(), MAX_FIELD_LENGTH = 256, SECRET_PATTERN2;
+var now = () => new Date().toISOString(), MAX_FIELD_LENGTH3 = 256, SECRET_PATTERN2;
 var init_observability = __esm(() => {
   SECRET_PATTERN2 = /(?:sk-[a-z0-9_-]{8,}|(?:api[_-]?key|token|secret|password)\s*[:=]\s*\S+|bearer\s+\S+)/gi;
 });
 
 // ../../packages/app/src/services/workflow-service.ts
-import { access as access2, lstat, readdir as readdir3, readFile as readFile2, realpath } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join13, resolve as resolve2 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join15, resolve as resolve4 } from "path";
 function signalSubprocess(pid) {
+  if (!Number.isInteger(pid) || pid <= 1)
+    return false;
+  if (pid === process.pid || pid === process.ppid)
+    return false;
   try {
     process.kill(-pid, "SIGTERM");
     return true;
@@ -68045,7 +68940,7 @@ class WorkflowAppService {
     };
   }
   async validate(file2, opts = {}) {
-    const absolute = resolve2(this.ctx.cwd, file2);
+    const absolute = resolve4(this.ctx.cwd, file2);
     if (!await fileExists(absolute)) {
       return { ok: false, valid: false, file: file2, errors: [`File not found: ${absolute}`] };
     }
@@ -68096,7 +68991,7 @@ class WorkflowAppService {
       return;
     let workflowName;
     try {
-      const def = await loadWorkflowDef(resolve2(this.ctx.cwd, file2));
+      const def = await loadWorkflowDef(resolve4(this.ctx.cwd, file2));
       workflowName = def.name;
     } catch {
       return;
@@ -68156,7 +69051,8 @@ class WorkflowAppService {
     return { runId, finalized, status: after?.status ?? "not_found", killed };
   }
   async continuePaused(runId) {
-    const svc = await this.createEngineService();
+    const eventsBus = this.ctx.events?.();
+    const svc = await this.createEngineService({ events: eventsBus });
     const run = await svc.listPausedRuns();
     const target = run.find((r) => r.id === runId);
     if (target === undefined) {
@@ -68166,7 +69062,10 @@ class WorkflowAppService {
     if (workflow === null) {
       throw new Error(`Cannot resume run "${runId}": workflow definition "${target.workflow_name}" not found in the workflow search paths.`);
     }
-    const result = await svc.resumeRun(workflow, runId, { workdir: this.ctx.cwd });
+    const result = await svc.resumeRun(workflow, runId, {
+      workdir: this.ctx.cwd,
+      ...eventsBus !== undefined ? { events: bridgeEventBus(eventsBus) } : {}
+    });
     await this.stampFailureReason(runId, result);
     return result;
   }
@@ -68183,7 +69082,7 @@ class WorkflowAppService {
     if (entry === undefined)
       return null;
     for (const layer of listing.layers) {
-      const abs = resolve2(layer.path, entry.path);
+      const abs = resolve4(layer.path, entry.path);
       if (await fileExists(abs)) {
         try {
           return await loadWorkflowDef(abs, { validateSchema: false });
@@ -68194,12 +69093,12 @@ class WorkflowAppService {
   }
   async list(workflowPaths = [".spur/workflows/"]) {
     const projectRoot = this.ctx.cwd;
-    const globalRoot = join13(homedir3(), ".config", "spur");
+    const globalRoot = join15(homedir5(), ".config", "spur");
     const layers = [];
     const entries = [];
     const scannedPaths = new Set;
     for (const relPath of workflowPaths) {
-      const absPath = resolve2(projectRoot, relPath);
+      const absPath = resolve4(projectRoot, relPath);
       layers.push({ id: "project", path: absPath });
       scannedPaths.add(absPath);
       try {
@@ -68208,7 +69107,7 @@ class WorkflowAppService {
       } catch {}
     }
     for (const relPath of workflowPaths) {
-      const absPath = resolve2(globalRoot, relPath);
+      const absPath = resolve4(globalRoot, relPath);
       if (scannedPaths.has(absPath))
         continue;
       layers.push({ id: "global", path: absPath });
@@ -68301,7 +69200,8 @@ class WorkflowAppService {
     return { run, events: events2 };
   }
   async createEngineService(opts = {}) {
-    const host = createDefaultWorkflowEngineHost();
+    const processExec = this.ctx.processExecutor?.();
+    const host = createDefaultWorkflowEngineHost(processExec !== undefined ? { processExecutor: processExec } : {});
     const bus = this.ctx.observabilityBus?.();
     registerSpurBuiltins(host, {
       agentService: this.ctx.agentService(),
@@ -68322,39 +69222,40 @@ class WorkflowAppService {
   }
 }
 async function fileExists(path9) {
-  try {
-    await access2(path9);
-    return true;
-  } catch {
-    return false;
-  }
+  const fs3 = createNodeFileSystem3();
+  return await fs3.exists(path9);
 }
 async function scanWorkflowFiles(rootPath, source) {
   const entries = [];
-  let rootStat;
-  try {
-    rootStat = await lstat(rootPath);
-  } catch {
+  const fs3 = createNodeFileSystem3();
+  const rootStat = await fs3.stat(rootPath);
+  if (!rootStat?.isDirectory()) {
     return entries;
   }
-  const realPath = rootStat.isSymbolicLink() ? await realpath(rootPath) : rootPath;
-  const dirents = await readdir3(realPath, { withFileTypes: true, recursive: true });
-  for (const dirent of dirents) {
-    if (!dirent.isFile())
-      continue;
-    const name = dirent.name;
-    if (!name.endsWith(".yaml") && !name.endsWith(".yml"))
-      continue;
-    const fullPath = resolve2(dirent.parentPath, name);
-    const displayPath = fullPath.startsWith(rootPath) ? fullPath.slice(rootPath.length + 1) : fullPath;
-    const meta3 = await extractWorkflowMeta(fullPath);
-    entries.push({ ...meta3, path: displayPath, source });
+  const realPath = fs3.realPath ? await fs3.realPath(rootPath) : rootPath;
+  async function walk3(dirPath) {
+    const names = await fs3.readDir(dirPath);
+    for (const name of names) {
+      const fullPath = resolve4(dirPath, name);
+      const st = await fs3.stat(fullPath);
+      if (!st)
+        continue;
+      if (st.isDirectory()) {
+        await walk3(fullPath);
+      } else if (st.isFile() && (name.endsWith(".yaml") || name.endsWith(".yml"))) {
+        const displayPath = fullPath.startsWith(rootPath) ? fullPath.slice(rootPath.length + 1) : fullPath;
+        const meta3 = await extractWorkflowMeta(fullPath);
+        entries.push({ ...meta3, path: displayPath, source });
+      }
+    }
   }
+  await walk3(realPath);
   return entries;
 }
 async function extractWorkflowMeta(filePath) {
   try {
-    const text4 = await readFile2(filePath, "utf-8");
+    const fs3 = createNodeFileSystem3();
+    const text4 = await fs3.readFile(filePath);
     const parsed = parseYamlObject(text4);
     if (typeof parsed !== "object" || parsed === null) {
       return { name: "<unparseable>", kind: "unknown", valid: false, error: "Top-level value is not an object" };
@@ -68411,8 +69312,6 @@ var init_workflow_service = __esm(() => {
 });
 
 // ../../packages/app/src/workflow/lifecycle-adapter.ts
-import { readFile as readFile3 } from "fs/promises";
-
 class LifecycleAdapter {
   opts;
   workflowCache;
@@ -68523,7 +69422,8 @@ class LifecycleAdapter {
       return this.opts.readTaskMarkdown(ref);
     }
     try {
-      return await readFile3(ref.filePath, "utf8");
+      const fs3 = createNodeFileSystem3(this.opts.cwd);
+      return await fs3.readFile(ref.filePath);
     } catch {
       return null;
     }
@@ -68539,6 +69439,7 @@ var TASK_LIFECYCLE_PROFILE, FEATURE_LIFECYCLE_PROFILE;
 var init_lifecycle_adapter = __esm(() => {
   init_src2();
   init_dist7();
+  init_dist5();
   init_task_check();
   TASK_LIFECYCLE_PROFILE = {
     linkKind: "lifecycle",
@@ -68636,8 +69537,7 @@ function formatDuration(ms) {
 var isAgentExecution = (e) => ("executionId" in e), isActionStarted = (e) => ("kind" in e) && ("node" in e), isActionFinished = (e) => ("durationMs" in e) && ("ok" in e), isPhase = (e) => ("phase" in e), isTransition = (e) => ("from" in e) && ("to" in e);
 
 // ../../packages/app/src/workflow/trace-writer.ts
-import { appendFile, mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname12, join as join14 } from "path";
+import { dirname as dirname13, join as join16 } from "path";
 
 class WorkflowTraceWriter {
   path;
@@ -68645,7 +69545,7 @@ class WorkflowTraceWriter {
   pending = Promise.resolve();
   constructor(cwd, runId) {
     const safeRunId = runId.replace(/[^A-Za-z0-9._-]/g, "_");
-    this.path = join14(cwd, ".spur", "runs", "workflow", `${safeRunId}.jsonl`);
+    this.path = join16(cwd, ".spur", "runs", "workflow", `${safeRunId}.jsonl`);
   }
   attach(bus) {
     bus.on("workflow.run.started", (event2) => this.enqueue("workflow.run.started", event2));
@@ -68670,18 +69570,26 @@ class WorkflowTraceWriter {
     })}
 `;
     this.pending = this.pending.then(async () => {
-      await mkdir2(dirname12(this.path), { recursive: true });
-      await appendFile(this.path, line, "utf8");
+      const fs3 = createNodeFileSystem3();
+      await fs3.ensureDir(dirname13(this.path));
+      await fs3.appendFile(this.path, line);
     });
   }
 }
-var init_trace_writer = () => {};
+var init_trace_writer = __esm(() => {
+  init_dist5();
+});
 
 // ../../packages/app/src/index.ts
 var exports_src2 = {};
 __export(exports_src2, {
   tailTokenLedgerFile: () => tailTokenLedgerFile,
   systemEventCatalogEntry: () => systemEventCatalogEntry,
+  summarizeActionResult: () => summarizeActionResult,
+  startRegisteredProject: () => startRegisteredProject,
+  setDetachedServeSpawnForTests: () => setDetachedServeSpawnForTests,
+  resolveSpurServeCommand: () => resolveSpurServeCommand,
+  resolveRetentionQuotas: () => resolveRetentionQuotas,
   resolvePlanningFolders: () => resolvePlanningFolders,
   resolveAutostartSet: () => resolveAutostartSet,
   renderTesting: () => renderTesting,
@@ -68701,21 +69609,29 @@ __export(exports_src2, {
   parseLedgerLine: () => parseLedgerLine,
   parseEtimeToSeconds: () => parseEtimeToSeconds,
   normalizeSystemEventPayload: () => normalizeSystemEventPayload,
+  normalizeProjectPath: () => normalizeProjectPath,
+  isPortLive: () => isPortLive,
+  isPortAvailable: () => isPortAvailable,
   isFindingCode: () => isFindingCode,
+  isFeatureActionName: () => isFeatureActionName,
   hitlConfirmDefault: () => hitlConfirmDefault,
   hitlAutoApproveEnabled: () => hitlAutoApproveEnabled,
   hasPopulatedPriorityTable: () => hasPopulatedPriorityTable,
   formatNoopMessage: () => formatNoopMessage,
   formatDenialMessage: () => formatDenialMessage,
+  extractSystemEventCorrelation: () => extractSystemEventCorrelation,
   extractSystemEventActor: () => extractSystemEventActor,
   extractReviewSectionBody: () => extractReviewSectionBody,
   evaluateDoneTransition: () => evaluateDoneTransition,
+  encodeRunListCursor: () => encodeRunListCursor,
   deriveVerdict: () => deriveVerdict,
+  decodeRunListCursor: () => decodeRunListCursor,
   createPsProcessInspector: () => createPsProcessInspector,
   configuredSecretValues: () => configuredSecretValues,
   computeAggregate: () => computeAggregate,
   classifyTaskOutcome: () => classifyTaskOutcome,
   clampToolUseLimit: () => clampToolUseLimit,
+  clampRunStoreLimit: () => clampRunStoreLimit,
   bridgeEventBus: () => bridgeEventBus,
   aggregateBatchVerdicts: () => aggregateBatchVerdicts,
   WorkflowTraceWriter: () => WorkflowTraceWriter,
@@ -68743,10 +69659,17 @@ __export(exports_src2, {
   SYSTEM_EVENT_NAMES: () => SYSTEM_EVENT_NAMES,
   SYSTEM_EVENT_CATALOG_METADATA: () => SYSTEM_EVENT_CATALOG_METADATA,
   SYSTEM_EVENT_CATALOG: () => SYSTEM_EVENT_CATALOG,
-  SYSTEM_EVENTS_CAP: () => SYSTEM_EVENTS_CAP,
+  RunStoreService: () => RunStoreService,
+  RunStoreNotFoundError: () => RunStoreNotFoundError,
+  RunStoreBadCursorError: () => RunStoreBadCursorError,
   RuleService: () => RuleService,
   RuleCheckActionRunner: () => RuleCheckActionRunner,
   ResponseValidateActionRunner: () => ResponseValidateActionRunner,
+  RUN_STORE_WBS_MAX_LIMIT: () => RUN_STORE_WBS_MAX_LIMIT,
+  RUN_STORE_WBS_DEFAULT_LIMIT: () => RUN_STORE_WBS_DEFAULT_LIMIT,
+  RUN_STORE_LIST_MAX_LIMIT: () => RUN_STORE_LIST_MAX_LIMIT,
+  RUN_STORE_LIST_DEFAULT_LIMIT: () => RUN_STORE_LIST_DEFAULT_LIMIT,
+  ProjectRegistry: () => ProjectRegistry,
   ProcessInventoryService: () => ProcessInventoryService,
   PluginService: () => PluginService,
   PlanningWriteService: () => PlanningWriteService,
@@ -68768,8 +69691,11 @@ __export(exports_src2, {
   FeatureCheckService: () => FeatureCheckService,
   FINDING_CODES: () => FINDING_CODES,
   FEATURE_LIFECYCLE_PROFILE: () => FEATURE_LIFECYCLE_PROFILE,
+  FEATURE_ACTION_NAMES: () => FEATURE_ACTION_NAMES,
+  FEATURE_ACTION_COMMANDS: () => FEATURE_ACTION_COMMANDS,
   DuplicateFollowUpError: () => DuplicateFollowUpError,
   DependencyMutationError: () => DependencyMutationError,
+  DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA: () => DEFAULT_SYSTEM_EVENT_RETENTION_QUOTA,
   DEFAULT_FEATURE_MATRIX: () => DEFAULT_FEATURE_MATRIX,
   CorpusMigrator: () => CorpusMigrator,
   BusPlanningEventEmitter: () => BusPlanningEventEmitter,
@@ -68793,9 +69719,13 @@ var init_src3 = __esm(() => {
   init_planning_write_service();
   init_process_inspector();
   init_process_inventory_service();
+  init_project_registry();
+  init_project_start();
   init_rule_service();
+  init_run_store_service();
   init_supervisor_service();
   init_system_event_emitter();
+  init_system_event_retention();
   init_system_event_tap();
   init_task_check();
   init_task_locator();
@@ -76082,6 +77012,8 @@ Font modified May 20, 2012 by patorjk to add the 0xCA0 character
 
 // src/commands/agent.ts
 init_src3();
+init_dist6();
+init_dist5();
 
 // src/output.ts
 init_dist();
@@ -76097,6 +77029,40 @@ function toJson2(value) {
   return JSON.stringify(value, null, 2);
 }
 
+// src/system-event-ledger.ts
+init_src3();
+init_src2();
+async function attachSystemEventLedger(bus, context4, options = {}) {
+  const logger3 = {
+    warn: (msg, data) => {
+      context4.output.error(`${msg}${data ? ` ${JSON.stringify(data)}` : ""}`);
+    }
+  };
+  let tap;
+  try {
+    const dao2 = new SystemEventDao(await context4.getDb());
+    tap = registerSystemEventTap(bus, dao2, logger3, {
+      diagnosticEnabled: options.diagnosticEnabled === true,
+      secretValues: configuredSecretValues(context4.env ?? {})
+    });
+  } catch (error51) {
+    context4.output.error(`system_events ledger attach: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    return {
+      unsubscribe: () => {},
+      flush: async () => {}
+    };
+  }
+  return {
+    unsubscribe: () => {
+      tap?.unsubscribe();
+      tap = undefined;
+    },
+    flush: async () => {
+      await tap?.flush();
+    }
+  };
+}
+
 // src/commands/agent.ts
 function registerAgentCommand(program2, context4) {
   const agent = program2.command("agent").summary("run and inspect supported coding agents");
@@ -76255,8 +77221,20 @@ async function runAgentEdit(id, context4) {
     context4.output.write(path9);
     return 0;
   }
-  const proc = Bun.spawn([...editorArgv, path9], { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
-  return await proc.exited;
+  const [editorCmd, ...editorArgs] = editorArgv;
+  if (editorCmd === undefined) {
+    context4.output.write(path9);
+    return 0;
+  }
+  const result = await new NodeProcessExecutor3({
+    output: { mode: "stream", isTTY: true }
+  }).run({
+    command: editorCmd,
+    args: [...editorArgs, path9],
+    forceBuffered: false,
+    rejectOnError: false
+  });
+  return result.exitCode ?? 1;
 }
 async function runAgentDelete(id, context4, flags) {
   if (id === undefined) {
@@ -76277,12 +77255,19 @@ async function runAgentDelete(id, context4, flags) {
   }
 }
 async function runAgentRun(prompt, context4, flags, deps) {
-  const svc = context4.agentService();
-  if (flags.drain === true) {
-    const { prompt: drained, flags: rewritten } = await drainIntoPrompt(prompt, context4, flags);
-    return svc.run(drained, rewritten, deps);
+  const bus = new EventBus;
+  const ledger = await attachSystemEventLedger(bus, context4);
+  const svc = context4.agentService({ events: bus });
+  try {
+    if (flags.drain === true) {
+      const { prompt: drained, flags: rewritten } = await drainIntoPrompt(prompt, context4, flags);
+      return await svc.run(drained, rewritten, deps);
+    }
+    return await svc.run(prompt, flags, deps);
+  } finally {
+    await ledger.flush();
+    ledger.unsubscribe();
   }
-  return svc.run(prompt, flags, deps);
 }
 async function drainIntoPrompt(prompt, context4, flags) {
   const recipient = typeof flags.agent === "string" ? flags.agent : "";
@@ -76313,15 +77298,15 @@ function parseLoopPoll(raw) {
   return Number.isFinite(n2) && n2 > 0 ? n2 : DEFAULT_LOOP_POLL_MS;
 }
 function loopSleep(ms, signal) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve5) => {
     if (signal?.aborted) {
-      resolve3();
+      resolve5();
       return;
     }
-    const timer = setTimeout(resolve3, ms);
+    const timer = setTimeout(resolve5, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve3();
+      resolve5();
     }, { once: true });
   });
 }
@@ -76366,7 +77351,7 @@ function makePlanningEmitter(context4) {
   return {
     async emit(event2) {
       try {
-        cached2 ??= new SystemEventEmitter(new SystemEventDao(await context4.getDb()), logger3);
+        cached2 ??= new SystemEventEmitter(new SystemEventDao(await context4.getDb()), logger3, {}, configuredSecretValues(context4.env ?? {}));
         await cached2.emit(event2);
       } catch (error51) {
         context4.output.error(`system_events emitter: ${error51 instanceof Error ? error51.message : String(error51)}`);
@@ -76379,14 +77364,14 @@ function makePlanningEmitter(context4) {
 init_src3();
 init_loader();
 init_src2();
-import { existsSync as existsSync8 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join15, resolve as resolve3 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join17, resolve as resolve5 } from "path";
 
 // src/workflow/resolve-spur-bin.ts
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 function resolveSpurBinFrom(launch) {
-  const runtime = basename2(launch.execPath).toLowerCase().replace(/\.exe$/, "");
+  const runtime = basename3(launch.execPath).toLowerCase().replace(/\.exe$/, "");
   const isJsRuntime = runtime === "bun" || runtime === "node";
   if (isJsRuntime && launch.mainModule) {
     return `${launch.execPath} ${launch.mainModule}`;
@@ -76399,23 +77384,23 @@ function resolveSpurBin() {
 }
 
 // src/workflow/make-lifecycle-adapter.ts
-var GLOBAL_CONFIG_DIR = join15(".config", "spur");
+var GLOBAL_CONFIG_DIR = join17(".config", "spur");
 function globalConfigRoot(context4) {
   const override = context4.env.SPUR_GLOBAL_RULES_DIR;
-  return override !== undefined && override.length > 0 ? resolve3(context4.cwd, override) : join15(homedir4(), GLOBAL_CONFIG_DIR);
+  return override !== undefined && override.length > 0 ? resolve5(context4.cwd, override) : join17(homedir6(), GLOBAL_CONFIG_DIR);
 }
 function resolveWorkflowPath(context4, profile) {
   const bundledRoot = bundledConfigRoot();
   if (bundledRoot !== null) {
-    const bundledPath = join15(bundledRoot, "workflows", `${profile.workflowName}.yaml`);
-    if (existsSync8(bundledPath))
+    const bundledPath = join17(bundledRoot, "workflows", `${profile.workflowName}.yaml`);
+    if (existsSync9(bundledPath))
       return bundledPath;
   }
-  const projectPath = join15(context4.cwd, ".spur", "workflows", `${profile.workflowName}.yaml`);
-  if (existsSync8(projectPath))
+  const projectPath = join17(context4.cwd, ".spur", "workflows", `${profile.workflowName}.yaml`);
+  if (existsSync9(projectPath))
     return projectPath;
-  const globalPath = join15(globalConfigRoot(context4), "workflows", `${profile.workflowName}.yaml`);
-  if (existsSync8(globalPath))
+  const globalPath = join17(globalConfigRoot(context4), "workflows", `${profile.workflowName}.yaml`);
+  if (existsSync9(globalPath))
     return globalPath;
   return null;
 }
@@ -76815,14 +77800,14 @@ function formatImportResult(r) {
 init_loader();
 init_src2();
 init_dist10();
-import { homedir as homedir5 } from "os";
-import { join as join16, resolve as resolve4 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join18, resolve as resolve6 } from "path";
 
 // src/config.ts
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.3.26",
+  binaryVersion: "0.3.27",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"
@@ -76873,8 +77858,8 @@ var SCAFFOLD_MANIFEST = [
 ];
 
 // src/commands/init.ts
-var GLOBAL_CONFIG_DIR2 = join16(".config", "spur");
-var GLOBAL_RULES_DIR2 = join16(GLOBAL_CONFIG_DIR2, "rules");
+var GLOBAL_CONFIG_DIR2 = join18(".config", "spur");
+var GLOBAL_RULES_DIR2 = join18(GLOBAL_CONFIG_DIR2, "rules");
 var GLOBAL_CONFIG_EXAMPLE = "config.example.yaml";
 var GLOBAL_CONFIG_FILE2 = "config.yaml";
 var INDEXED_CONTEXT_MARKER = "## Indexed context";
@@ -76905,7 +77890,7 @@ If \`.spur/context/\` is absent, proceed normally. Never block work on its absen
 `;
 function globalRulesRoot(context4) {
   const override = context4.env.SPUR_GLOBAL_RULES_DIR;
-  return override !== undefined && override.length > 0 ? resolve4(context4.cwd, override) : join16(homedir5(), GLOBAL_RULES_DIR2);
+  return override !== undefined && override.length > 0 ? resolve6(context4.cwd, override) : join18(homedir7(), GLOBAL_RULES_DIR2);
 }
 async function writeIfNew(context4, path9, content, force, result) {
   if (!force && await context4.fs.exists(path9)) {
@@ -76922,11 +77907,11 @@ async function seedGlobalRules(context4) {
   const target = globalRulesRoot(context4);
   let written = 0;
   for (const relPath of await listBundledRuleFiles()) {
-    const destination = join16(target, relPath);
+    const destination = join18(target, relPath);
     if (await context4.fs.exists(destination))
       continue;
-    await context4.fs.ensureDir(join16(target, ...relPath.split("/").slice(0, -1)));
-    await context4.fs.writeFile(destination, await context4.fs.readFile(join16(source, relPath)));
+    await context4.fs.ensureDir(join18(target, ...relPath.split("/").slice(0, -1)));
+    await context4.fs.writeFile(destination, await context4.fs.readFile(join18(source, relPath)));
     written += 1;
   }
   return written;
@@ -76936,20 +77921,20 @@ async function seedGlobalConfig(context4) {
   if (source === null)
     return 0;
   const globalOverride = context4.env.SPUR_GLOBAL_RULES_DIR;
-  const target = globalOverride !== undefined && globalOverride.length > 0 ? resolve4(context4.cwd, globalOverride) : join16(homedir5(), GLOBAL_CONFIG_DIR2);
+  const target = globalOverride !== undefined && globalOverride.length > 0 ? resolve6(context4.cwd, globalOverride) : join18(homedir7(), GLOBAL_CONFIG_DIR2);
   let written = 0;
   for (const relPath of listBundledConfigFiles()) {
     if (relPath === GLOBAL_CONFIG_EXAMPLE)
       continue;
-    const destination = join16(target, relPath);
+    const destination = join18(target, relPath);
     if (await context4.fs.exists(destination))
       continue;
-    await context4.fs.ensureDir(join16(target, ...relPath.split("/").slice(0, -1)));
-    await context4.fs.writeFile(destination, await context4.fs.readFile(join16(source, relPath)));
+    await context4.fs.ensureDir(join18(target, ...relPath.split("/").slice(0, -1)));
+    await context4.fs.writeFile(destination, await context4.fs.readFile(join18(source, relPath)));
     written += 1;
   }
-  const examplePath = join16(source, GLOBAL_CONFIG_EXAMPLE);
-  const globalConfigPath = join16(target, GLOBAL_CONFIG_FILE2);
+  const examplePath = join18(source, GLOBAL_CONFIG_EXAMPLE);
+  const globalConfigPath = join18(target, GLOBAL_CONFIG_FILE2);
   if (await context4.fs.exists(examplePath) && !await context4.fs.exists(globalConfigPath)) {
     await context4.fs.ensureDir(target);
     await context4.fs.writeFile(globalConfigPath, await context4.fs.readFile(examplePath));
@@ -76963,7 +77948,7 @@ function registerInitCommand(program2, context4) {
     const force = options.force === true;
     const minimal = options.minimal === true;
     const projectName = options.name ?? "default";
-    const configPath = join16(context4.cwd, CLI_CONFIG.configFile);
+    const configPath = join18(context4.cwd, CLI_CONFIG.configFile);
     if (!force && await context4.fs.exists(configPath)) {
       const message = `Already initialized: ${CLI_CONFIG.configFile}. Use --force to overwrite.`;
       context4.output.write(json3 ? toJson2({ ok: false, reason: "already-initialized", config: CLI_CONFIG.configFile }) : message);
@@ -76998,13 +77983,13 @@ function registerInitCommand(program2, context4) {
     ].join(`
 `)}
 `;
-    await context4.fs.ensureDir(join16(context4.cwd, CLI_CONFIG.configDir));
+    await context4.fs.ensureDir(join18(context4.cwd, CLI_CONFIG.configDir));
     await context4.fs.writeFile(configPath, configYaml);
     result.created.push(configPath);
-    const agentsDir = join16(context4.cwd, CLI_CONFIG.configDir, "agents");
+    const agentsDir = join18(context4.cwd, CLI_CONFIG.configDir, "agents");
     await context4.fs.ensureDir(agentsDir);
-    await writeIfNew(context4, join16(agentsDir, ".gitkeep"), "", force, result);
-    const gitignorePath = join16(context4.cwd, ".gitignore");
+    await writeIfNew(context4, join18(agentsDir, ".gitkeep"), "", force, result);
+    const gitignorePath = join18(context4.cwd, ".gitignore");
     const contextEntry = ".spur/context/";
     if (await context4.fs.exists(gitignorePath)) {
       const existing = await context4.fs.readFile(gitignorePath);
@@ -77026,20 +78011,20 @@ ${contextEntry}
         for (const relPath of listBundledProjectSeedFiles()) {
           if (relPath.startsWith("templates/docs/"))
             continue;
-          const sourcePath = join16(configRoot, relPath);
+          const sourcePath = join18(configRoot, relPath);
           if (!await context4.fs.exists(sourcePath))
             continue;
-          const targetPath = join16(context4.cwd, CLI_CONFIG.configDir, relPath);
-          await context4.fs.ensureDir(join16(targetPath, ".."));
+          const targetPath = join18(context4.cwd, CLI_CONFIG.configDir, relPath);
+          await context4.fs.ensureDir(join18(targetPath, ".."));
           await writeIfNew(context4, targetPath, await context4.fs.readFile(sourcePath), force, result);
         }
         for (const entry of SCAFFOLD_MANIFEST) {
-          const sourcePath = join16(configRoot, entry.source);
+          const sourcePath = join18(configRoot, entry.source);
           if (!await context4.fs.exists(sourcePath))
             continue;
-          const baseDir = entry.root === true ? context4.cwd : join16(context4.cwd, CLI_CONFIG.configDir);
-          const targetPath = join16(baseDir, entry.target);
-          await context4.fs.ensureDir(join16(targetPath, ".."));
+          const baseDir = entry.root === true ? context4.cwd : join18(context4.cwd, CLI_CONFIG.configDir);
+          const targetPath = join18(baseDir, entry.target);
+          await context4.fs.ensureDir(join18(targetPath, ".."));
           const entryForce = entry.preserve === true ? false : force;
           let body = await context4.fs.readFile(sourcePath);
           if (entry.target === "AGENTS.md") {
@@ -77052,7 +78037,7 @@ ${contextEntry}
         }
       }
     }
-    const agentsMdPath = join16(context4.cwd, "AGENTS.md");
+    const agentsMdPath = join18(context4.cwd, "AGENTS.md");
     if (await context4.fs.exists(agentsMdPath)) {
       const existing = await context4.fs.readFile(agentsMdPath);
       if (!existing.includes(INDEXED_CONTEXT_MARKER)) {
@@ -77209,15 +78194,15 @@ async function runMessageWatch(svc, output2, options, runtime = {}) {
   }
 }
 function defaultSleep(ms, signal) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve7) => {
     if (signal?.aborted) {
-      resolve5();
+      resolve7();
       return;
     }
-    const timer = setTimeout(resolve5, ms);
+    const timer = setTimeout(resolve7, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve5();
+      resolve7();
     }, { once: true });
   });
 }
@@ -77230,10 +78215,10 @@ function parseInterval2(raw) {
 
 // src/commands/migrate.ts
 init_src2();
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 function registerMigrateCommand(program2, context4) {
   program2.command("migrate").summary("apply CLI-owned schema migrations").option("--json", "Output machine-readable JSON").action(async (options) => {
-    const migrations = await loadSqlMigrations(join17(context4.cwd, "drizzle")).catch(() => {
+    const migrations = await loadSqlMigrations(join19(context4.cwd, "drizzle")).catch(() => {
       return;
     });
     const applied = await applyCliMigrations(await context4.getDb(), migrations);
@@ -77242,6 +78227,170 @@ function registerMigrateCommand(program2, context4) {
   });
 }
 
+// src/commands/projects.ts
+init_src3();
+init_dist5();
+import { basename as basename4, resolve as resolve7 } from "path";
+function registerProjectsCommand(program2, context4) {
+  const projectsCmd = program2.command("projects").summary("manage the Spur multi-project registry");
+  projectsCmd.command("add").argument("<path>", "Project root directory path").option("--name <name>", "Display name for the project").option("--json", "Output JSON response").action(async (pathArg, options) => {
+    try {
+      const absolutePath = resolve7(context4.cwd, pathArg);
+      if (!await context4.fs.exists(absolutePath)) {
+        throw new Error(`Directory does not exist: ${absolutePath}`);
+      }
+      const name = options.name ?? basename4(absolutePath);
+      const registry2 = new ProjectRegistry;
+      const entry = await registry2.upsert({ path: absolutePath, name, port: 0 });
+      if (options.json) {
+        context4.output.write(toJson2({ ok: true, project: entry }));
+      } else {
+        context4.output.write(`Registered project "${entry.name}" at ${entry.path}`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (options.json) {
+        context4.output.write(toJson2({ ok: false, error: message }));
+      } else {
+        context4.output.error(`Error: ${message}`);
+      }
+      context4.setExitCode(1);
+    }
+  });
+  projectsCmd.command("remove").argument("<target>", "Project display name or directory path").option("--json", "Output JSON response").action(async (target, options) => {
+    try {
+      const registry2 = new ProjectRegistry;
+      const removed = await registry2.remove(target);
+      if (!removed) {
+        throw new Error(`Project not found in registry: "${target}"`);
+      }
+      if (options.json) {
+        context4.output.write(toJson2({ ok: true, removed: target }));
+      } else {
+        context4.output.write(`Removed project "${target}" from registry`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (options.json) {
+        context4.output.write(toJson2({ ok: false, error: message }));
+      } else {
+        context4.output.error(`Error: ${message}`);
+      }
+      context4.setExitCode(1);
+    }
+  });
+  projectsCmd.command("list").option("--json", "Output JSON array of projects").action(async (options) => {
+    try {
+      const registry2 = new ProjectRegistry;
+      const rawProjects = await registry2.list();
+      const projects3 = await Promise.all(rawProjects.map(async (p) => ({
+        ...p,
+        running: p.port > 0 ? await isPortLive(p.port) : false
+      })));
+      if (options.json) {
+        context4.output.write(toJson2({ projects: projects3 }));
+      } else {
+        if (projects3.length === 0) {
+          context4.output.write("No projects registered.");
+          return;
+        }
+        context4.output.write(`Registered Projects:
+`);
+        for (const p of projects3) {
+          const status = p.running ? `[RUNNING: ${p.port}]` : "[STOPPED]";
+          context4.output.write(`- ${p.name} ${status} (${p.path})`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (options.json) {
+        context4.output.write(toJson2({ ok: false, error: message }));
+      } else {
+        context4.output.error(`Error: ${message}`);
+      }
+      context4.setExitCode(1);
+    }
+  });
+  projectsCmd.command("start").argument("<target>", "Project display name or path").option("--port <n>", "Explicit port to bind", parseInt).option("--json", "Output JSON response").action(async (target, options) => {
+    try {
+      const registry2 = new ProjectRegistry;
+      const result = await startRegisteredProject(registry2, target, {
+        port: typeof options.port === "number" && !Number.isNaN(options.port) ? options.port : undefined
+      });
+      if (options.json) {
+        context4.output.write(toJson2({
+          ok: true,
+          project: {
+            name: result.name,
+            path: result.path,
+            port: result.port
+          },
+          running: true,
+          alreadyRunning: result.alreadyRunning,
+          url: result.url
+        }));
+      } else if (result.alreadyRunning) {
+        context4.output.write(`Project "${result.name}" is already running at ${result.url}`);
+      } else {
+        context4.output.write(`Started project "${result.name}" on ${result.url}`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (options.json) {
+        context4.output.write(toJson2({ ok: false, error: message }));
+      } else {
+        context4.output.error(`Error: ${message}`);
+      }
+      context4.setExitCode(1);
+    }
+  });
+  projectsCmd.command("stop").argument("<target>", "Project display name or path").option("--json", "Output JSON response").action(async (target, options) => {
+    try {
+      const registry2 = new ProjectRegistry;
+      const entry = await registry2.getByName(target) ?? await registry2.getByPath(target);
+      if (!entry) {
+        throw new Error(`Project not found: "${target}"`);
+      }
+      if (entry.port > 0) {
+        try {
+          const result = await new NodeProcessExecutor3().run({
+            command: "fuser",
+            args: [`${entry.port}/tcp`],
+            forceBuffered: true,
+            rejectOnError: false
+          });
+          const outputStr = `${result.stdout}
+${result.stderr}`;
+          const pids = outputStr.trim().split(/\s+/).map(Number).filter((n2) => Number.isInteger(n2) && n2 > 1);
+          const self2 = process.pid;
+          const parent = process.ppid;
+          for (const pid of pids) {
+            if (pid === self2 || pid === parent)
+              continue;
+            try {
+              process.kill(pid, "SIGTERM");
+            } catch {}
+          }
+        } catch {}
+        await registry2.setPort(entry.path, 0);
+      }
+      if (options.json) {
+        context4.output.write(toJson2({ ok: true, stopped: entry.name }));
+      } else {
+        context4.output.write(`Stopped project "${entry.name}"`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (options.json) {
+        context4.output.write(toJson2({ ok: false, error: message }));
+      } else {
+        context4.output.error(`Error: ${message}`);
+      }
+      context4.setExitCode(1);
+    }
+  });
+}
+
 // src/commands/rule.ts
 init_src3();
 
@@ -77485,7 +78634,7 @@ function formatTraceDetail(detail) {
 
 // src/commands/serve.ts
 init_src();
-import { join as join21 } from "path";
+import { join as join23 } from "path";
 
 // ../server/src/index.ts
 init_src();
@@ -77495,11 +78644,11 @@ init_src3();
 init_src();
 init_loader();
 init_src2();
-import { dirname as dirname14, isAbsolute as isAbsolute3, join as join20 } from "path";
+import { basename as basename6, dirname as dirname15, isAbsolute as isAbsolute3, join as join22 } from "path";
 init_dist5();
 
 // ../server/src/bootstrap.ts
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 
 // ../../node_modules/.bun/radash@12.1.1/node_modules/radash/dist/esm/async.mjs
 var guard = (func, shouldGuard) => {
@@ -77772,8 +78921,8 @@ class EventPublisher {
       if (bufferedEvents.length > 0) {
         return { done: false, value: bufferedEvents.shift() };
       }
-      return new Promise((resolve5, reject) => {
-        pullResolvers.push([resolve5, reject]);
+      return new Promise((resolve8, reject) => {
+        pullResolvers.push([resolve8, reject]);
       });
     }, async () => {
       unsubscribe();
@@ -82906,6 +84055,56 @@ function enqueueSseFrame(closed, controller, encoder, frame) {
 init_event_names();
 
 // ../server/src/modules/events/index.ts
+var HISTORY_LIMIT_DEFAULT = 100;
+var HISTORY_LIMIT_MAX = 500;
+function encodeHistoryCursor(id, occurredAt) {
+  const payload = { id, occurredAt };
+  const bytes = new TextEncoder().encode(JSON.stringify(payload));
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function decodeHistoryCursor(encoded) {
+  if (encoded.length === 0 || encoded.length > 1024) {
+    return { ok: false, reason: "malformed cursor: empty or exceeds maximum length" };
+  }
+  let json3;
+  try {
+    const base643 = encoded.replaceAll("-", "+").replaceAll("_", "/");
+    const binary = atob(base643);
+    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+    json3 = new TextDecoder().decode(bytes);
+  } catch {
+    return { ok: false, reason: "malformed cursor: not valid base64url" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json3);
+  } catch {
+    return { ok: false, reason: "malformed cursor: payload is not JSON" };
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return { ok: false, reason: "malformed cursor: payload must be an object" };
+  }
+  const obj = parsed;
+  if (typeof obj.id !== "string" || obj.id.length === 0) {
+    return { ok: false, reason: "malformed cursor: missing or invalid id" };
+  }
+  if (typeof obj.occurredAt !== "string" || obj.occurredAt.length === 0) {
+    return { ok: false, reason: "malformed cursor: missing or invalid occurredAt" };
+  }
+  if (Number.isNaN(Date.parse(obj.occurredAt))) {
+    return { ok: false, reason: "malformed cursor: occurredAt is not a valid timestamp" };
+  }
+  return { ok: true, value: { id: obj.id, occurredAt: obj.occurredAt } };
+}
+function parseHistoryNamesParam(raw2) {
+  if (raw2 === undefined)
+    return;
+  const parts = (Array.isArray(raw2) ? raw2 : [raw2]).flatMap((chunk) => chunk.split(",")).map((s) => s.trim()).filter((s) => s.length > 0);
+  return parts.length > 0 ? parts : undefined;
+}
 function extractSystemEventActor2(event2) {
   if (event2 && typeof event2 === "object") {
     const obj = event2;
@@ -82913,6 +84112,8 @@ function extractSystemEventActor2(event2) {
       return obj.actor;
     if (typeof obj.agentId === "string" && obj.agentId.length > 0)
       return obj.agentId;
+    if (typeof obj.memberId === "string" && obj.memberId.length > 0)
+      return obj.memberId;
   }
   return null;
 }
@@ -83001,29 +84202,71 @@ var eventsModule = {
       const nameParam = c3.req.query("name");
       const sinceParam = c3.req.query("since");
       const limitParam = c3.req.query("limit");
-      let limit = 100;
+      const prefixParam = c3.req.query("prefix");
+      const runIdParam = c3.req.query("runId");
+      const actorParam = c3.req.query("actor");
+      const cursorParam = c3.req.query("cursor");
+      const namesRaw = c3.req.queries("names");
+      const namesParam = namesRaw && namesRaw.length > 0 ? parseHistoryNamesParam(namesRaw) : parseHistoryNamesParam(c3.req.query("names"));
+      let limit = HISTORY_LIMIT_DEFAULT;
       if (limitParam !== undefined) {
         const parsed = Number.parseInt(limitParam, 10);
         if (!Number.isNaN(parsed) && parsed > 0) {
-          limit = Math.min(parsed, 500);
+          limit = Math.min(parsed, HISTORY_LIMIT_MAX);
         }
       }
-      const dao2 = await ctx.systemEventDao();
-      const rows = await dao2.query({
+      if (prefixParam !== undefined && prefixParam.length > 0) {
+        if (!SYSTEM_EVENT_PREFIXES.includes(prefixParam)) {
+          return c3.json({
+            error: `unknown prefix: "${prefixParam}" is not a cataloged event family`,
+            code: "UNKNOWN_PREFIX"
+          }, 400);
+        }
+      }
+      let before;
+      if (cursorParam !== undefined && cursorParam.length > 0) {
+        const decoded = decodeHistoryCursor(cursorParam);
+        if (!decoded.ok) {
+          return c3.json({ error: decoded.reason, code: "MALFORMED_CURSOR" }, 400);
+        }
+        before = { occurred_at: decoded.value.occurredAt, id: decoded.value.id };
+      }
+      const query = {
         name: nameParam || undefined,
+        names: namesParam,
+        prefix: prefixParam || undefined,
         since: sinceParam || undefined,
-        limit
-      });
-      const events2 = rows.map((row) => ({
+        run_id: runIdParam || undefined,
+        actor: actorParam || undefined,
+        before,
+        limit: limit + 1
+      };
+      const dao2 = await ctx.systemEventDao();
+      const rows = await dao2.query(query);
+      const hasMore = rows.length > limit;
+      const page = hasMore ? rows.slice(0, limit) : rows;
+      const last = page.at(-1);
+      const nextCursor = hasMore && last ? encodeHistoryCursor(last.id, last.occurred_at) : null;
+      const events2 = page.map((row) => ({
         id: row.id,
         eventName: row.event_name,
         occurredAt: row.occurred_at,
         actor: row.actor,
         prefix: systemEventCatalogEntry(row.event_name)?.prefix ?? row.event_name.split(".")[0],
         renderer: systemEventCatalogEntry(row.event_name)?.renderer ?? "generic",
-        payload: row.payload_json ? JSON.parse(row.payload_json) : null
+        payload: row.payload_json ? JSON.parse(row.payload_json) : null,
+        runId: row.run_id,
+        entityKind: row.entity_kind,
+        entityId: row.entity_id,
+        sequence: row.sequence
       }));
-      return c3.json({ events: events2, count: events2.length, catalog: SYSTEM_EVENT_CATALOG_METADATA });
+      return c3.json({
+        events: events2,
+        count: events2.length,
+        catalog: SYSTEM_EVENT_CATALOG_METADATA,
+        nextCursor,
+        hasMore
+      });
     });
   }
 };
@@ -83128,7 +84371,12 @@ var featureActionInputSchema = exports_external.object({
   channel: featureActionChannelSchema.optional(),
   skipDeps: exports_external.boolean().optional()
 });
-var featureActionResponseSchema = apiSuccessSchema(exports_external.object({}));
+var featureActionResultSchema = exports_external.object({
+  runId: exports_external.string(),
+  action: exports_external.string(),
+  status: exports_external.literal("queued")
+});
+var featureActionResponseSchema = apiSuccessSchema(featureActionResultSchema);
 var featureCreateChildInputSchema = exports_external.object({
   id: featureIdSchema,
   name: exports_external.string().min(1)
@@ -83490,8 +84738,13 @@ function createFeatureHandlers(ctx) {
       await ctx.featureService().updateBody(input.id, input.body);
       return { ok: true, data: {} };
     }),
-    action: os2.feature.action.handler(async () => {
-      return { ok: true, data: {} };
+    action: os2.feature.action.handler(async ({ input }) => {
+      const jobQueue = await ctx.jobQueue();
+      const result = await ctx.featureService().fulfillAction(input.id, input.action, async (job) => {
+        const runId = await jobQueue.enqueue("feature-action", job);
+        return runId;
+      }, { channel: input.channel, skipDeps: input.skipDeps });
+      return { ok: true, data: result };
     }),
     children: os2.feature.children.handler(async ({ input }) => {
       const r2 = await ctx.featureService().create(input.name, input.id);
@@ -83535,7 +84788,8 @@ var featureModule = {
 };
 
 // ../server/src/modules/health/index.ts
-import { basename as basename3 } from "path";
+init_src3();
+import { basename as basename5 } from "path";
 var startedAt = Date.now();
 var healthModule = {
   name: "health",
@@ -83561,7 +84815,56 @@ var healthModule = {
       return c3.json({ status: "error", db: "unreachable" }, 503);
     });
     app.get("/api/project", (c3) => {
-      return c3.json({ name: ctx ? basename3(ctx.cwd) : null });
+      return c3.json({ name: ctx ? basename5(ctx.cwd) : null });
+    });
+    app.get("/api/projects", async (c3) => {
+      if (!ctx) {
+        return c3.json({ projects: [] });
+      }
+      const registry2 = new ProjectRegistry;
+      const rawProjects = await registry2.list();
+      const currentNorm = normalizeProjectPath(ctx.cwd);
+      const projects3 = await Promise.all(rawProjects.map(async (p2) => {
+        const normPath = normalizeProjectPath(p2.path);
+        const running = p2.port > 0 ? await isPortLive(p2.port) : false;
+        return {
+          name: p2.name,
+          path: p2.path,
+          port: p2.port,
+          running,
+          current: normPath === currentNorm
+        };
+      }));
+      return c3.json({ projects: projects3 });
+    });
+    app.post("/api/projects/start", async (c3) => {
+      if (!ctx) {
+        return c3.json({ error: "Multi-project registry unavailable on Cloudflare Workers" }, 501);
+      }
+      let body = {};
+      try {
+        body = await c3.req.json();
+      } catch {}
+      const target = body.name ?? body.path;
+      if (!target) {
+        return c3.json({ error: "Missing name or path in request body" }, 400);
+      }
+      try {
+        const registry2 = new ProjectRegistry;
+        const result = await startRegisteredProject(registry2, target);
+        return c3.json({
+          name: result.name,
+          path: result.path,
+          port: result.port,
+          running: true,
+          alreadyRunning: result.alreadyRunning,
+          url: result.url
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const status = message.includes("not found") ? 404 : 500;
+        return c3.json({ error: message }, status);
+      }
     });
   }
 };
@@ -83811,6 +85114,63 @@ var observabilityModule = {
   }
 };
 
+// ../server/src/modules/runs/index.ts
+init_src3();
+var runsModule = {
+  name: "runs",
+  mount(app, ctx) {
+    if (!ctx)
+      return;
+    app.get("/api/runs", async (c3) => {
+      const status = c3.req.query("status") || undefined;
+      const limitParam = c3.req.query("limit");
+      const cursor2 = c3.req.query("cursor") || undefined;
+      let limit;
+      if (limitParam !== undefined) {
+        const parsed = Number.parseInt(limitParam, 10);
+        if (!Number.isNaN(parsed))
+          limit = parsed;
+      }
+      try {
+        const service = ctx.runStoreService();
+        const result = await service.list({ status, limit, cursor: cursor2 });
+        return c3.json(result);
+      } catch (err) {
+        if (err instanceof RunStoreBadCursorError) {
+          return c3.json({ error: err.message, code: err.code }, 400);
+        }
+        throw err;
+      }
+    });
+    app.get("/api/runs/by-wbs/:wbs", async (c3) => {
+      const wbs = c3.req.param("wbs");
+      const limitParam = c3.req.query("limit");
+      let limit;
+      if (limitParam !== undefined) {
+        const parsed = Number.parseInt(limitParam, 10);
+        if (!Number.isNaN(parsed))
+          limit = parsed;
+      }
+      const service = ctx.runStoreService();
+      const result = await service.listByWbs(wbs, limit);
+      return c3.json(result);
+    });
+    app.get("/api/runs/:runId", async (c3) => {
+      const runId = c3.req.param("runId");
+      const service = ctx.runStoreService();
+      try {
+        const detail = await service.getDetail(runId);
+        return c3.json(detail);
+      } catch (err) {
+        if (err instanceof RunStoreNotFoundError) {
+          return c3.json({ error: err.message, code: err.code, runId: err.runId }, 404);
+        }
+        throw err;
+      }
+    });
+  }
+};
+
 // ../server/src/modules/task/handlers.ts
 init_schema6();
 var os3 = implement(contract);
@@ -83998,6 +85358,7 @@ var teamModule = {
       const closed = { current: false };
       const signal = c3.req.raw.signal;
       let heartbeatInterval;
+      let pollInterval;
       let closeController = () => {};
       const teardown = () => {
         if (closed.current)
@@ -84005,6 +85366,8 @@ var teamModule = {
         closed.current = true;
         if (heartbeatInterval)
           clearInterval(heartbeatInterval);
+        if (pollInterval)
+          clearInterval(pollInterval);
         signal.removeEventListener("abort", teardown);
         closeController();
       };
@@ -84035,29 +85398,24 @@ var teamModule = {
             line: "--replay-done--"
           }))
             return;
-          const pollInterval = setInterval(() => {
+          pollInterval = setInterval(() => {
             if (closed.current) {
-              clearInterval(pollInterval);
+              if (pollInterval)
+                clearInterval(pollInterval);
               return;
             }
             for (const frame of supervisor.getRingBuffer(id)) {
               if (frame.seq <= lastSeq)
                 continue;
               if (!enqueueFrame(closed, controller, encoder, frame)) {
-                clearInterval(pollInterval);
+                teardown();
                 return;
               }
               lastSeq = frame.seq;
             }
           }, 500);
-          const origClose = closeController;
-          closeController = () => {
-            clearInterval(pollInterval);
-            origClose();
-          };
         },
         cancel() {
-          closeController = () => {};
           teardown();
         }
       });
@@ -84153,7 +85511,8 @@ var builtins = [
   messagesModule,
   jobsModule,
   teamModule,
-  observabilityModule
+  observabilityModule,
+  runsModule
 ];
 function registerModules(app, ctx, modules = builtins) {
   for (const mod of modules) {
@@ -86100,21 +87459,55 @@ function createRouter2(ctx) {
   };
 }
 
-// ../server/src/bootstrap.ts
+// ../server/src/server-config.ts
 function serverBootstrapConfig(env) {
   const isTest = env.NODE_ENV === "test";
   const raw2 = env.SPUR_TEAM_AUTOSTART;
   const teamAutostart = raw2 ? raw2.split(",").map((s) => s.trim()).filter((s) => s.length > 0) : [];
   const diagnosticEvents = env.SPUR_DIAGNOSTIC_EVENTS === "1" || env.SPUR_DIAGNOSTIC_EVENTS === "true";
+  const retentionDefault = parseRetentionNumber(env.SPUR_EVENT_RETENTION_DEFAULT);
+  const retentionPrefixes = parseRetentionPrefixes(env);
   return {
     logging: { enabled: !isTest, level: env.SPUR_LOG_LEVEL ?? "info", console: false },
     telemetry: { enabled: false },
-    events: { enabled: true, diagnostic: diagnosticEvents },
+    events: {
+      enabled: true,
+      diagnostic: diagnosticEvents,
+      retention: {
+        ...retentionDefault !== undefined ? { default: retentionDefault } : {},
+        ...Object.keys(retentionPrefixes).length > 0 ? { prefixes: retentionPrefixes } : {}
+      }
+    },
     jobqueue: { enabled: !isTest },
     scheduler: { enabled: !isTest },
     teamAutostart
   };
 }
+function parseRetentionNumber(raw2) {
+  if (raw2 === undefined || raw2.trim() === "")
+    return;
+  const value2 = Number(raw2);
+  if (!Number.isInteger(value2) || value2 < 0)
+    return;
+  return value2;
+}
+function parseRetentionPrefixes(env) {
+  const prefixes = {};
+  for (const [key, value2] of Object.entries(env)) {
+    const match2 = /^SPUR_EVENT_RETENTION_(.+)$/.exec(key);
+    if (!match2 || match2[1] === "DEFAULT")
+      continue;
+    const prefix = match2[1];
+    if (!prefix)
+      continue;
+    const quota = parseRetentionNumber(value2);
+    if (quota !== undefined)
+      prefixes[prefix.toLowerCase()] = quota;
+  }
+  return prefixes;
+}
+
+// ../server/src/bootstrap.ts
 function createApp(appRt, opts) {
   const app = new Hono2;
   mountMiddleware(app, appRt);
@@ -86139,7 +87532,7 @@ function createApp(appRt, opts) {
     app.use("*", async (c3, next) => {
       const pathname = c3.req.path === "/" ? "/index.html" : c3.req.path;
       try {
-        const file2 = Bun.file(join18(webDistPath, pathname));
+        const file2 = Bun.file(join20(webDistPath, pathname));
         if (await file2.exists()) {
           const headers = new Headers({ "content-type": file2.type });
           return new Response(file2.stream(), { headers });
@@ -86152,7 +87545,7 @@ function createApp(appRt, opts) {
         return c3.json({ error: "Not Found" }, 404);
       }
       try {
-        const indexFile = Bun.file(join18(webDistPath, "index.html"));
+        const indexFile = Bun.file(join20(webDistPath, "index.html"));
         if (await indexFile.exists()) {
           return new Response(indexFile.stream(), {
             headers: { "content-type": "text/html; charset=utf-8" }
@@ -86173,7 +87566,7 @@ init_src3();
 init_src();
 init_src2();
 init_dist5();
-import { dirname as dirname13, join as join19 } from "path";
+import { dirname as dirname14, join as join21 } from "path";
 var NOOP_OUTPUT = { write: (_s) => {}, error: (_s) => {} };
 
 class LazyPlanningEventEmitter {
@@ -86208,7 +87601,7 @@ class NotConfiguredError extends Error {
 function createServerContext(appRt, options) {
   const cwd = options.cwd;
   const fs3 = options.fs;
-  const dbUrl = options.dbUrl ?? join19(cwd, DEFAULT_DATABASE_URL);
+  const dbUrl = options.dbUrl ?? join21(cwd, DEFAULT_DATABASE_URL);
   const eventsBus = options.eventsBus ?? appRt.events;
   const jobQueueEnabled = options.jobQueueEnabled ?? false;
   const folders = options.folders ?? DEFAULT_PLANNING_FOLDERS;
@@ -86231,6 +87624,7 @@ function createServerContext(appRt, options) {
   let agentSvc;
   let ruleSvc;
   let workflowSvc;
+  let runStoreSvc;
   let systemEventDaoPromise;
   let jobQueuePromise;
   let queueConsumerPromise;
@@ -86242,7 +87636,7 @@ function createServerContext(appRt, options) {
       if (!dbPromise) {
         const created = (async () => {
           if (dbUrl !== IN_MEMORY_DATABASE_URL) {
-            await fs3.ensureDir(dirname13(dbUrl));
+            await fs3.ensureDir(dirname14(dbUrl));
           }
           return createMigratedDbViaRuntime({ url: dbUrl });
         })();
@@ -86372,6 +87766,13 @@ function createServerContext(appRt, options) {
       systemEventDaoPromise ??= this.getDb().then((db2) => new SystemEventDao(db2));
       return systemEventDaoPromise;
     },
+    runStoreService() {
+      runStoreSvc ??= new RunStoreService({
+        getDb: this.getDb.bind(this),
+        secretValues: configuredSecretValues(options.env ?? process.env)
+      });
+      return runStoreSvc;
+    },
     planningFolders() {
       return folders;
     },
@@ -86416,15 +87817,23 @@ function createServerContext(appRt, options) {
 init_system_event_tap();
 
 // ../server/src/open-url.ts
-async function openUrl(url2) {
+init_dist5();
+async function openUrl(url2, deps = {}) {
   const argv = process.platform === "darwin" ? ["open", url2] : process.platform === "win32" ? ["cmd", "/c", "start", "", url2] : ["xdg-open", url2];
-  Bun.spawn(argv, { stdio: ["ignore", "ignore", "ignore"] });
+  const executor = deps.executor ?? new NodeProcessExecutor3;
+  await executor.run({
+    command: argv[0],
+    args: [...argv.slice(1)],
+    forceBuffered: true,
+    rejectOnError: false
+  });
 }
 
 // ../server/src/serve.ts
 var SYSTEM_EVENTS_PRUNE_JOB = "system-events-prune";
 var SMOKE_JOB = "smoke";
 var TASK_ACTION_JOB = "task-action";
+var FEATURE_ACTION_JOB = "feature-action";
 var SYSTEM_EVENTS_PRUNE_CRON = "300000";
 var SMOKE_CRON = "600000";
 var defaultDeps = {
@@ -86508,16 +87917,59 @@ async function runTaskActionJob(ctx, env, payload, createAgentService = createTa
     throw new Error(`Task action ${job.action} for ${job.wbs} failed with exit code ${exitCode}`);
   }
 }
+function parseFeatureActionJob(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    throw new Error("Invalid feature-action payload: expected object");
+  }
+  const candidate = payload;
+  if (typeof candidate.featureId !== "string" || typeof candidate.action !== "string") {
+    throw new Error("Invalid feature-action payload: missing featureId/action");
+  }
+  if (typeof candidate.command !== "string" || candidate.command.trim() === "") {
+    throw new Error("Invalid feature-action payload: missing command");
+  }
+  return {
+    featureId: candidate.featureId,
+    action: candidate.action,
+    command: candidate.command,
+    channel: typeof candidate.channel === "string" ? candidate.channel : undefined,
+    skipDeps: typeof candidate.skipDeps === "boolean" ? candidate.skipDeps : undefined
+  };
+}
+async function runFeatureActionJob(ctx, env, payload, createAgentService = createTaskActionAgentService) {
+  const job = parseFeatureActionJob(payload);
+  const agentService = createAgentService === createTaskActionAgentService ? ctx.agentService() : createAgentService({
+    cwd: ctx.cwd,
+    env,
+    events: ctx.eventBus(),
+    output: { write: () => {}, error: () => {} }
+  });
+  const flags = {
+    cwd: ctx.cwd,
+    json: true,
+    ...job.channel !== undefined ? { agent: job.channel } : {}
+  };
+  const exitCode = await agentService.run(job.command, flags);
+  if (exitCode !== 0) {
+    throw new Error(`Feature action ${job.action} for ${job.featureId} failed with exit code ${exitCode}`);
+  }
+}
+async function handleTaskActionJob(ctx, env, payload) {
+  await runTaskActionJob(ctx, env, payload);
+}
+async function handleFeatureActionJob(ctx, env, payload) {
+  await runFeatureActionJob(ctx, env, payload);
+}
 async function resolveWebDistPath(configuredPath) {
-  const candidates = configuredPath && configuredPath.trim() !== "" ? [isAbsolute3(configuredPath) ? configuredPath : join20(process.cwd(), configuredPath)] : [
-    join20(process.cwd(), "dist/web"),
-    join20(import.meta.dir, "web"),
-    join20(dirname14(process.execPath), "web"),
-    join20(dirname14(process.execPath), "../web"),
-    join20(import.meta.dir, "../../../dist/web")
+  const candidates = configuredPath && configuredPath.trim() !== "" ? [isAbsolute3(configuredPath) ? configuredPath : join22(process.cwd(), configuredPath)] : [
+    join22(process.cwd(), "dist/web"),
+    join22(import.meta.dir, "web"),
+    join22(dirname15(process.execPath), "web"),
+    join22(dirname15(process.execPath), "../web"),
+    join22(import.meta.dir, "../../../dist/web")
   ];
   for (const candidate of candidates) {
-    if (await Bun.file(join20(candidate, "index.html")).exists()) {
+    if (await Bun.file(join22(candidate, "index.html")).exists()) {
       return candidate;
     }
   }
@@ -86533,7 +87985,7 @@ async function startServer(options, deps = defaultDeps) {
     async start(appRt) {
       const fs3 = deps.createNodeFileSystem(process.cwd());
       if (options.dbUrl && options.dbUrl !== IN_MEMORY_DATABASE_URL) {
-        await fs3.ensureDir(dirname14(options.dbUrl));
+        await fs3.ensureDir(dirname15(options.dbUrl));
       }
       let scheduler3;
       if (bootConfig.scheduler.enabled) {
@@ -86573,7 +88025,9 @@ async function startServer(options, deps = defaultDeps) {
         try {
           const dao2 = new SystemEventDao(await ctx.getDb());
           registerSystemEventTap(ctx.eventBus(), dao2, appRt.logger, {
-            diagnosticEnabled: bootConfig.events.diagnostic === true
+            diagnosticEnabled: bootConfig.events.diagnostic === true,
+            retention: bootConfig.events.retention,
+            secretValues: configuredSecretValues(env)
           });
           appRt.logger.debug("system_events tap registered", {
             diagnostic: bootConfig.events.diagnostic === true
@@ -86585,14 +88039,14 @@ async function startServer(options, deps = defaultDeps) {
       const app = deps.createApp(appRt, { fs: fs3, ctx });
       if (bootConfig.jobqueue.enabled) {
         const registry2 = new JobHandlerRegistry;
+        const retentionQuotas = resolveRetentionQuotas(bootConfig.events.retention);
         registry2.register(SYSTEM_EVENTS_PRUNE_JOB, async () => {
           const dao2 = await ctx.systemEventDao();
-          await dao2.prune(SYSTEM_EVENTS_CAP);
+          await dao2.pruneQuotas(retentionQuotas);
         });
         registry2.register(SMOKE_JOB, async () => {});
-        registry2.register(TASK_ACTION_JOB, async (payload) => {
-          await runTaskActionJob(ctx, env, payload);
-        });
+        registry2.register(TASK_ACTION_JOB, (payload) => handleTaskActionJob(ctx, env, payload));
+        registry2.register(FEATURE_ACTION_JOB, (payload) => handleFeatureActionJob(ctx, env, payload));
         jobWorker = new JobWorkerService({
           consumer: await ctx.queueConsumer(),
           registry: registry2
@@ -86610,8 +88064,33 @@ async function startServer(options, deps = defaultDeps) {
         port: options.port,
         hostname: options.host
       });
+      const projectRegistry = new ProjectRegistry;
+      const projectCwd = process.cwd();
+      const projectName = basename6(projectCwd);
+      try {
+        await projectRegistry.upsert({ path: projectCwd, name: projectName, port: server.port });
+      } catch (err) {
+        appRt.logger.warn("Failed to register project in ProjectRegistry", { error: String(err) });
+      }
+      let shuttingDown = false;
+      const onSigInt = () => {
+        shutdown("SIGINT");
+      };
+      const onSigTerm = () => {
+        shutdown("SIGTERM");
+      };
       const shutdown = async (signal) => {
+        if (shuttingDown)
+          return;
+        shuttingDown = true;
+        process.off("SIGINT", onSigInt);
+        process.off("SIGTERM", onSigTerm);
         appRt.logger.info("Shutting down server", { signal });
+        try {
+          await projectRegistry.setPort(projectCwd, 0);
+        } catch (err) {
+          appRt.logger.warn("Failed to deregister project port in ProjectRegistry", { error: String(err) });
+        }
         if (scheduler3)
           await scheduler3.stop();
         if (jobWorker)
@@ -86625,8 +88104,8 @@ async function startServer(options, deps = defaultDeps) {
         await appRt.stop("shutdown");
         process.exit(0);
       };
-      process.on("SIGINT", () => void shutdown("SIGINT"));
-      process.on("SIGTERM", () => void shutdown("SIGTERM"));
+      process.on("SIGINT", onSigInt);
+      process.on("SIGTERM", onSigTerm);
       const url2 = `http://${options.host}:${options.port}`;
       appRt.logger.info("Server started", {
         port: options.port,
@@ -86642,12 +88121,14 @@ async function startServer(options, deps = defaultDeps) {
     }
   });
 }
+// ../server/src/worker-app.ts
+var startedAt2 = Date.now();
 // ../server/src/index.ts
 if (false) {}
 
 // src/commands/serve.ts
 function resolveServeDbUrl(cwd, env, configuredUrl) {
-  return env.DATABASE_URL === undefined ? join21(cwd, DEFAULT_DATABASE_URL) : configuredUrl;
+  return env.DATABASE_URL === undefined ? join23(cwd, DEFAULT_DATABASE_URL) : configuredUrl;
 }
 function registerServeCommand(program2, context4) {
   program2.command("serve").summary("start the Spur web server (local fallback)").option("--port <n>", "Server port (env: PORT, default: 3000)", parseInt).option("--host <addr>", "Bind address (env: HOST, default: localhost)").option("--no-open", "Skip opening the browser").option("--cwd <path>", "Working directory", context4.cwd).option("--json", "Output { port, url, pid } and exit").action(async (options) => {
@@ -86686,7 +88167,7 @@ function registerServeCommand(program2, context4) {
 }
 
 // src/commands/status.ts
-import { join as join22 } from "path";
+import { join as join24 } from "path";
 
 // src/errors.ts
 class CommandError extends Error {
@@ -86757,8 +88238,8 @@ function registerStatusCommand(program2, context4) {
 }
 async function runStatusCore(path9, options, context4) {
   const [packageJsonExists, spurConfigExists, git, agentSpecs] = await Promise.all([
-    context4.fs.exists(join22(context4.cwd, "package.json")),
-    context4.fs.exists(join22(context4.cwd, ".spur", "config.yaml")),
+    context4.fs.exists(join24(context4.cwd, "package.json")),
+    context4.fs.exists(join24(context4.cwd, ".spur", "config.yaml")),
     gitContext(context4.cwd),
     listAgentSpecIds(context4)
   ]);
@@ -86786,26 +88267,27 @@ async function runStatusCore(path9, options, context4) {
   return status.ok ? 0 : 1;
 }
 async function listAgentSpecIds(context4) {
-  const dir = join22(context4.cwd, ".spur", "agents");
+  const dir = join24(context4.cwd, ".spur", "agents");
   if (!await context4.fs.exists(dir))
     return [];
   const entries = await context4.fs.readDir(dir);
   return entries.filter((entry) => entry.endsWith(".yaml") || entry.endsWith(".yml")).map((entry) => entry.replace(/\.ya?ml$/, "")).sort();
 }
 async function readTargetStatus(context4, targetPath) {
-  const resolved = join22(context4.cwd, targetPath);
-  const stat2 = await context4.fs.stat(resolved);
-  if (stat2 === null)
+  const resolved = join24(context4.cwd, targetPath);
+  const stat = await context4.fs.stat(resolved);
+  if (stat === null)
     throw new CommandError(`status failed: path does not exist at ${resolved}`);
-  return { path: targetPath, size: stat2.size, isFile: stat2.isFile(), isDirectory: stat2.isDirectory() };
+  return { path: targetPath, size: stat.size, isFile: stat.isFile(), isDirectory: stat.isDirectory() };
 }
 
 // src/commands/task.ts
 init_src3();
 init_loader();
 init_src2();
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
-import { join as join23 } from "path";
+init_dist5();
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { join as join25 } from "path";
 // schemas/section-matrix.schema.json
 var section_matrix_schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
@@ -87489,7 +88971,7 @@ ${result.content}`);
         let forcedDoneVerdict;
         if (status === "done") {
           const current = await svc.show(wbs);
-          const verdictDir = options.verdictDir ?? join23(context4.cwd, ".spur", "run");
+          const verdictDir = options.verdictDir ?? join25(context4.cwd, ".spur", "run");
           const loaded = await readVerdictArtifact(context4.fs, verdictDir, wbs);
           const guardOutcome = evaluateDoneTransition({
             wbs,
@@ -87784,7 +89266,7 @@ ${result.content}`);
     const answerPath = options.fromAnswer ?? `.spur/run/${wbs}-verify-answer.txt`;
     let answerText;
     try {
-      answerText = readFileSync8(answerPath, "utf-8");
+      answerText = await context4.fs.readFile(context4.fs.resolve(answerPath));
     } catch {
       context4.output.error(`Answer file not found: ${answerPath}`);
       context4.setExitCode(1);
@@ -87793,9 +89275,8 @@ ${result.content}`);
     const taskCheckPassed = true;
     const result = deriveVerdict2(answerText, taskCheckPassed);
     const jsonOut = JSON.stringify({ wbs, ...result, source: "spur-task-verdict" }, null, 2);
-    const { mkdirSync: mkdirSync5, writeFileSync: writeFileSync4 } = await import("fs");
-    mkdirSync5(".spur/run", { recursive: true });
-    writeFileSync4(`.spur/run/${wbs}-verdict.json`, `${jsonOut}
+    await context4.fs.ensureDir(".spur/run");
+    await context4.fs.writeFile(`.spur/run/${wbs}-verdict.json`, `${jsonOut}
 `);
     if (options.json) {
       context4.output.write(jsonOut);
@@ -87810,7 +89291,7 @@ ${result.content}`);
     const inputPath = options.fromFile ?? ".spur/run/verifyall-batch-input.json";
     let raw2;
     try {
-      raw2 = readFileSync8(inputPath, "utf-8");
+      raw2 = await context4.fs.readFile(context4.fs.resolve(inputPath));
     } catch {
       context4.output.error(`Batch input file not found: ${inputPath}`);
       context4.setExitCode(1);
@@ -88030,17 +89511,17 @@ function loadTemplateContent(projectRoot, variant) {
     return templateContentCache.get(variant);
   if (templateMissSet.has(variant))
     return;
-  const localPath = join23(projectRoot, ".spur", "tasks", "templates", `${variant}.md`);
-  if (existsSync9(localPath)) {
-    const content = readFileSync8(localPath, "utf8");
+  const localPath = join25(projectRoot, ".spur", "tasks", "templates", `${variant}.md`);
+  if (existsSync10(localPath)) {
+    const content = readFileSync9(localPath, "utf8");
     templateContentCache.set(variant, content);
     return content;
   }
   const root = bundledConfigRoot();
   if (root !== null) {
-    const templatePath = join23(root, "templates", "task", `${variant}.md`);
-    if (existsSync9(templatePath)) {
-      const content = readFileSync8(templatePath, "utf8");
+    const templatePath = join25(root, "templates", "task", `${variant}.md`);
+    if (existsSync10(templatePath)) {
+      const content = readFileSync9(templatePath, "utf8");
       templateContentCache.set(variant, content);
       return content;
     }
@@ -88054,15 +89535,15 @@ function loadTemplateBodies(projectRoot, variant) {
   if (cached2 !== undefined)
     return cached2;
   let bodies = {};
-  const localPath = join23(projectRoot, ".spur", "tasks", "templates", `${variant}.md`);
-  if (existsSync9(localPath)) {
-    bodies = extractTemplateBodies(readFileSync8(localPath, "utf8"));
+  const localPath = join25(projectRoot, ".spur", "tasks", "templates", `${variant}.md`);
+  if (existsSync10(localPath)) {
+    bodies = extractTemplateBodies(readFileSync9(localPath, "utf8"));
   } else {
     const root = bundledConfigRoot();
     if (root !== null) {
-      const templatePath = join23(root, "templates", "task", `${variant}.md`);
-      if (existsSync9(templatePath)) {
-        bodies = extractTemplateBodies(readFileSync8(templatePath, "utf8"));
+      const templatePath = join25(root, "templates", "task", `${variant}.md`);
+      if (existsSync10(templatePath)) {
+        bodies = extractTemplateBodies(readFileSync9(templatePath, "utf8"));
       }
     }
   }
@@ -88102,8 +89583,9 @@ async function loadSectionMatrix(projectRoot) {
   return promise2;
 }
 async function loadSectionMatrixUncached(projectRoot) {
-  const localPath = join23(projectRoot, ".spur", "tasks", "section-matrix.yaml");
-  if (existsSync9(localPath)) {
+  const fs3 = createNodeFileSystem3(projectRoot);
+  const localPath = fs3.resolve(".spur", "tasks", "section-matrix.yaml");
+  if (await fs3.exists(localPath)) {
     const data = await loadStructuredSpurConfig(localPath, {
       validateJsonSchema: true,
       embeddedSchemas: EMBEDDED_SPUR_SCHEMAS
@@ -88112,8 +89594,8 @@ async function loadSectionMatrixUncached(projectRoot) {
   }
   const root = bundledConfigRoot();
   if (root !== null) {
-    const matrixPath = join23(root, "tasks", "section-matrix.yaml");
-    if (existsSync9(matrixPath)) {
+    const matrixPath = join25(root, "tasks", "section-matrix.yaml");
+    if (await fs3.exists(matrixPath)) {
       const data = await loadStructuredSpurConfig(matrixPath, {
         validateJsonSchema: true,
         embeddedSchemas: EMBEDDED_SPUR_SCHEMAS
@@ -88134,6 +89616,7 @@ var FALLBACK_MATRIX = {
 
 // src/commands/team.ts
 init_src3();
+init_dist6();
 var _testFetch;
 function teamFetch(url2, init) {
   const fetcher = _testFetch ?? fetch;
@@ -88168,10 +89651,15 @@ function registerTeamCommand(program2, context4) {
   });
 }
 async function runTeamAssign(taskId, agentId, context4) {
-  const svc = new TeamService(context4);
-  await svc.assignTask(taskId, agentId);
-  context4.output.write(`assigned ${taskId} \u2192 ${agentId}`);
-  return 0;
+  const { svc, ledger } = await makeTeamServiceWithLedger(context4);
+  try {
+    await svc.assignTask(taskId, agentId);
+    context4.output.write(`assigned ${taskId} \u2192 ${agentId}`);
+    return 0;
+  } finally {
+    await ledger.flush();
+    ledger.unsubscribe();
+  }
 }
 async function runTeamStatus(options, context4) {
   const svc = new TeamService(context4);
@@ -88314,55 +89802,74 @@ function formatTeamBlock(team) {
   return [header, ...rows].join(`
 `);
 }
+async function makeTeamServiceWithLedger(context4) {
+  const bus = new EventBus;
+  const ledger = await attachSystemEventLedger(bus, context4);
+  const svc = new TeamService({
+    ...context4,
+    eventBus: bus
+  });
+  return { svc, ledger };
+}
 async function runTeamUp(team, options, context4) {
-  const svc = new TeamService(context4);
-  let result;
+  const { svc, ledger } = await makeTeamServiceWithLedger(context4);
   try {
-    result = await svc.materializeTeam(team, { check: options.check === true });
-  } catch (error51) {
-    context4.output.error(error51 instanceof Error ? error51.message : String(error51));
-    return 1;
-  }
-  const started = [];
-  if (options.check !== true && result.upserted.length > 0) {
-    const specs = await svc.listAgentSpecs();
-    const autostart = specs.filter((spec) => spec.autoStart === true && result.upserted.includes(spec.id));
-    for (const spec of autostart) {
-      const res = await performTeamStart(spec.id, { server: options.server });
-      if ("ok" in res && res.ok === true)
-        started.push(spec.id);
+    let result;
+    try {
+      result = await svc.materializeTeam(team, { check: options.check === true });
+    } catch (error51) {
+      context4.output.error(error51 instanceof Error ? error51.message : String(error51));
+      return 1;
     }
+    const started = [];
+    if (options.check !== true && result.upserted.length > 0) {
+      const specs = await svc.listAgentSpecs();
+      const autostart = specs.filter((spec) => spec.autoStart === true && result.upserted.includes(spec.id));
+      for (const spec of autostart) {
+        const res = await performTeamStart(spec.id, { server: options.server });
+        if ("ok" in res && res.ok === true)
+          started.push(spec.id);
+      }
+    }
+    if (options.json === true) {
+      context4.output.write(toJson2({ ...result, started }));
+    } else {
+      const verb = options.check === true ? "would materialize" : "materialized";
+      const startNote = started.length > 0 ? `, started ${started.length}` : "";
+      context4.output.write(`team ${team}: ${verb} ${result.upserted.length} member(s), prune ${result.orphaned.length}${startNote}`);
+    }
+    return 0;
+  } finally {
+    await ledger.flush();
+    ledger.unsubscribe();
   }
-  if (options.json === true) {
-    context4.output.write(toJson2({ ...result, started }));
-  } else {
-    const verb = options.check === true ? "would materialize" : "materialized";
-    const startNote = started.length > 0 ? `, started ${started.length}` : "";
-    context4.output.write(`team ${team}: ${verb} ${result.upserted.length} member(s), prune ${result.orphaned.length}${startNote}`);
-  }
-  return 0;
 }
 async function runTeamDown(team, options, context4) {
-  const svc = new TeamService(context4);
-  let result;
+  const { svc, ledger } = await makeTeamServiceWithLedger(context4);
   try {
-    result = await svc.teardownTeam(team, { purge: options.purge === true });
-  } catch (error51) {
-    context4.output.error(error51 instanceof Error ? error51.message : String(error51));
-    return 1;
-  }
-  const stopped = [];
-  for (const id of result.stopped) {
-    const res = await performTeamStop(id, { server: options.server });
-    if ("ok" in res && res.ok === true)
-      stopped.push(id);
-  }
-  if (options.json === true) {
-    context4.output.write(toJson2({ ...result, stopped }));
-  } else {
-    context4.output.write(`team ${team}: stopped ${stopped.length}, purged ${result.purged.length}`);
+    let result;
+    try {
+      result = await svc.teardownTeam(team, { purge: options.purge === true });
+    } catch (error51) {
+      context4.output.error(error51 instanceof Error ? error51.message : String(error51));
+      return 1;
+    }
+    const stopped = [];
+    for (const id of result.stopped) {
+      const res = await performTeamStop(id, { server: options.server });
+      if ("ok" in res && res.ok === true)
+        stopped.push(id);
+    }
+    if (options.json === true) {
+      context4.output.write(toJson2({ ...result, stopped }));
+    } else {
+      context4.output.write(`team ${team}: stopped ${stopped.length}, purged ${result.purged.length}`);
+    }
+    return 0;
+  } finally {
+    await ledger.flush();
+    ledger.unsubscribe();
   }
-  return 0;
 }
 
 // src/commands/workflow.ts
@@ -88370,10 +89877,29 @@ init_src3();
 init_loader();
 init_dist7();
 init_dist6();
-import { spawn as spawn2 } from "child_process";
-import { resolve as resolve5 } from "path";
+init_dist5();
+import { resolve as resolve8 } from "path";
 import { createInterface } from "readline";
 import { setTimeout as sleep3 } from "timers/promises";
+function shQuote2(value2) {
+  return `'${value2.replace(/'/g, `'\\''`)}'`;
+}
+async function spawnAsyncWorkflowWorker(spurBin, cmd) {
+  const line = [spurBin, ...cmd].map(shQuote2).join(" ");
+  const env = {};
+  for (const [key, value2] of Object.entries(process.env)) {
+    if (value2 !== undefined)
+      env[key] = value2;
+  }
+  env.SPUR_ASYNC_WORKER = "1";
+  await new NodeProcessExecutor3().run({
+    command: process.platform === "win32" ? "cmd" : "/bin/sh",
+    args: process.platform === "win32" ? ["/c", `start /b "" ${[spurBin, ...cmd].map((c3) => `"${c3.replace(/"/g, '""')}"`).join(" ")}`] : ["-c", `nohup ${line} </dev/null >/dev/null 2>&1 &`],
+    env,
+    forceBuffered: true,
+    rejectOnError: false
+  });
+}
 function parseVars(raw2) {
   if (raw2 === undefined) {
     return;
@@ -88410,14 +89936,17 @@ async function resolveWorkflowPaths(cwd) {
   }
 }
 function registerWorkflowCommand(program2, context4) {
-  const makeSvc = (json3, observabilityBus) => new WorkflowAppService({
+  const makeSvc = (json3, bus) => new WorkflowAppService({
     cwd: context4.cwd,
     getDb: () => context4.getDb(),
     agentService: () => context4.agentService(),
     ruleService: () => context4.ruleService(),
     hitlResponder: () => context4.hitlResponder(json3),
     embeddedSchemas: () => EMBEDDED_SPUR_SCHEMAS,
-    ...observabilityBus ? { observabilityBus: () => observabilityBus } : {}
+    ...bus ? {
+      observabilityBus: () => bus,
+      events: () => bus
+    } : {}
   });
   const workflow = program2.command("workflow").summary("validate and execute workflow YAML files");
   workflow.command("validate").description("Validate a workflow definition.").argument("<file>", "Workflow YAML file").option("--no-schema", "Skip schema validation").option("--json", "Output machine-readable JSON where supported").action(async (file2, options) => {
@@ -88475,12 +90004,7 @@ ${result.errors.map((m) => `  - ${m}`).join(`
         cmd.push("--trace-file");
       }
       try {
-        const child = spawn2(spurBin, cmd, {
-          stdio: "ignore",
-          detached: true,
-          env: { ...process.env, SPUR_ASYNC_WORKER: "1" }
-        });
-        child.unref();
+        await spawnAsyncWorkflowWorker(spurBin, cmd);
       } catch {
         const result2 = await makeSvc(options.json).run(file2, {
           runId: runId2,
@@ -88508,21 +90032,19 @@ Monitor with: spur workflow trace ${runId2} --follow`);
     const vars = { spurBin: resolveSpurBin(), ...parseVars(options.vars) };
     const runId = options.runId || crypto.randomUUID();
     const humanProgress = !json3 && !quiet && !silent;
-    let bus;
+    const bus = new EventBus;
+    const ledger = await attachSystemEventLedger(bus, context4);
     let traceWriter;
     const heartbeats = new Map;
-    if (humanProgress || options.traceFile === true || options.steer === true) {
-      bus = new EventBus;
-    }
-    if (options.traceFile === true && bus !== undefined) {
+    if (options.traceFile === true) {
       traceWriter = new WorkflowTraceWriter(context4.cwd, runId);
       traceWriter.attach(bus);
     }
-    if (humanProgress && bus !== undefined) {
+    if (humanProgress) {
       context4.output.write(`Run: ${runId}`);
       if (options.plan !== false) {
         try {
-          const def = await loadWorkflowDef(resolve5(context4.cwd, file2), { validateSchema: false });
+          const def = await loadWorkflowDef(resolve8(context4.cwd, file2), { validateSchema: false });
           context4.output.write(renderRunPlan(def));
         } catch {}
       }
@@ -88536,9 +90058,9 @@ Monitor with: spur workflow trace ${runId2} --follow`);
         bus.on("workflow.transition", report);
       bus.on("workflow.action.started", (event2) => {
         report(event2);
-        const startedAt2 = Date.parse(event2.at);
+        const startedAt3 = Date.parse(event2.at);
         const timer = setInterval(() => {
-          const line = renderActionHeartbeat(event2, Math.max(0, Date.now() - startedAt2), { detail });
+          const line = renderActionHeartbeat(event2, Math.max(0, Date.now() - startedAt3), { detail });
           if (line !== null)
             context4.output.write(line);
         }, 30000);
@@ -88563,7 +90085,7 @@ Monitor with: spur workflow trace ${runId2} --follow`);
       });
     }
     const steeringController = options.steer === true ? new WorkflowSteeringController((ack) => {
-      bus?.emit("workflow.steering", ack);
+      bus.emit("workflow.steering", ack);
       context4.output.write(`[steer] ${ack.accepted ? "ack" : "nack"} ${ack.operation} \xB7 ${ack.reason ?? `version=${ack.version}`}`);
     }, configuredSecretValues(context4.env), new Set(["operator"]), (snapshot) => {
       if (snapshot.state === "boundary") {
@@ -88588,6 +90110,8 @@ Monitor with: spur workflow trace ${runId2} --follow`);
         clearInterval(timer);
       heartbeats.clear();
       await traceWriter?.flush();
+      await ledger.flush();
+      ledger.unsubscribe();
       steeringInput?.close();
     }
     if (json3)
@@ -88599,7 +90123,9 @@ Monitor with: spur workflow trace ${runId2} --follow`);
   });
   workflow.command("continue").description("Resume a paused (HITL) workflow run. Omit run-id to resume the most recent paused run.").argument("[run-id]", "Run ID to resume (default: the most recent paused run)").option("--yes", "Skip the CLI resume confirmation (does not set the persisted HITL answer)").option("--json", "Output machine-readable JSON where supported").action(async (runId, options) => {
     const json3 = options.json === true;
-    const svc = makeSvc(json3);
+    const bus = new EventBus;
+    const ledger = await attachSystemEventLedger(bus, context4);
+    const svc = makeSvc(json3, bus);
     try {
       let targetId = runId;
       if (targetId === undefined) {
@@ -88630,6 +90156,9 @@ Monitor with: spur workflow trace ${runId2} --follow`);
     } catch (err) {
       context4.output.error(String(err));
       context4.setExitCode(1);
+    } finally {
+      await ledger.flush();
+      ledger.unsubscribe();
     }
   });
   workflow.command("clean").description("Finalize orphaned runs stuck in running/pending past a staleness threshold (mark as failed). " + "To cancel a single live run by id, use `spur workflow cancel <run-id>` instead.").option("--older-than <minutes>", "Staleness threshold in minutes", "30").option("--force", "Clean ALL non-terminal runs regardless of age (overrides --older-than)").option("--dry-run", "List what would be cleaned without writing").option("--json", "Output machine-readable JSON where supported").action(async (options) => {
@@ -88864,7 +90393,7 @@ init_src3();
 init_src();
 init_src2();
 init_dist5();
-import { dirname as dirname15, join as join24, resolve as resolve6 } from "path";
+import { dirname as dirname16, join as join26, resolve as resolve9 } from "path";
 import { isatty as isatty4 } from "tty";
 
 // ../../node_modules/.bun/@clack+core@1.4.1/node_modules/@clack/core/dist/index.mjs
@@ -90247,7 +91776,7 @@ class DefaultHitlResponder {
 
 // src/context.ts
 function createCliContext(options) {
-  const cwd = resolve6(options.cwd ?? process.cwd());
+  const cwd = resolve9(options.cwd ?? process.cwd());
   const env = options.env ?? process.env;
   const fs3 = createNodeFileSystem3(cwd);
   let dbPromise;
@@ -90265,7 +91794,15 @@ function createCliContext(options) {
     setExitCode: options.setExitCode ?? noopSetExitCode,
     output: options.output,
     getDb,
-    agentService: () => new AgentService({ cwd, env, output: options.output, agentConfig: options.agentConfig }),
+    ...options.agentConfig !== undefined ? { agentConfig: options.agentConfig } : {},
+    agentService: (serviceOptions) => new AgentService({
+      cwd,
+      env,
+      output: options.output,
+      agentConfig: options.agentConfig,
+      ...serviceOptions?.events !== undefined ? { events: serviceOptions.events } : {},
+      ...serviceOptions?.processRegistry !== undefined ? { processRegistry: serviceOptions.processRegistry } : {}
+    }),
     ruleService: () => new RuleService({ cwd, env, fs: fs3, output: options.output, getDb }),
     hitlResponder: (json3) => {
       if (isatty4(1) && json3 !== true)
@@ -90278,10 +91815,10 @@ function createCliContext(options) {
 function noopSetExitCode(_code) {}
 async function createMigratedDbAdapter(cwd = process.cwd(), env = process.env, dbUrl) {
   const config4 = buildConfigFromEnv(env);
-  const configuredUrl = env.DATABASE_URL === undefined ? join24(cwd, DEFAULT_DATABASE_URL) : config4.database.url;
+  const configuredUrl = env.DATABASE_URL === undefined ? join26(cwd, DEFAULT_DATABASE_URL) : config4.database.url;
   const url2 = dbUrl ?? configuredUrl;
   if (url2 !== IN_MEMORY_DATABASE_URL) {
-    await createNodeFileSystem3().ensureDir(dirname15(url2));
+    await createNodeFileSystem3().ensureDir(dirname16(url2));
   }
   return createMigratedDb({ url: url2 });
 }
@@ -90343,6 +91880,7 @@ async function runCommandDispatch(argv, context4, output2) {
   registerInitCommand(program2, context4);
   registerMessageCommand(program2, context4);
   registerMigrateCommand(program2, context4);
+  registerProjectsCommand(program2, context4);
   registerRuleCommand(program2, context4);
   registerStatusCommand(program2, context4);
   registerServeCommand(program2, context4);