@iowarp/clio-coder 0.3.0 → 0.3.1

package/dist/{chunk-AMFR5YA3.js → chunk-KKNLWXI6.js}

@@ -1,28 +1,37 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   readSettings,
   settingsPath,
   updateSettings
-} from "./chunk-JWHCJDCI.js";
+} from "./chunk-KY56HMHH.js";
 import {
   DEFAULT_SETTINGS
-} from "./chunk-UHTSULZS.js";
+} from "./chunk-NMOX6HFD.js";
+import {
+  require_dist
+} from "./chunk-GB6QRBXN.js";
 import {
   safeResourceBackupPath,
   safeResourceWrite
-} from "./chunk-VPAWTYLY.js";
+} from "./chunk-WEPFGWHJ.js";
 import {
   clioConfigDir,
   resolveClioDirs
-} from "./chunk-X3NE4WVW.js";
+} from "./chunk-BNAZZHFG.js";
 import {
   readClioVersion
-} from "./chunk-DXQNI4PC.js";
+} from "./chunk-IWHMRKLL.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
 
 // src/domains/share/archive.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
 import { createHash } from "node:crypto";
 import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 var PROJECT_CONTEXT_FILES = ["CLIO-CODER.md", "AGENTS.md", "CODEX.md", "GEMINI.md", "CLAUDE.md"];
 var SETTINGS_FRAGMENT_PATH = "settings.fragment.yaml";
 function sha256(buffer) {
@@ -153,7 +162,7 @@ function createShareArchive(options = {}) {
     }
   }
   if (includes.includeSettings) {
-    const buffer = Buffer.from(stringifyYaml(settingsFragment(readSettings())), "utf8");
+    const buffer = Buffer.from((0, import_yaml.stringify)(settingsFragment(readSettings())), "utf8");
     addBufferFile(files, {
       type: "settings",
       scope: "user",
@@ -348,7 +357,7 @@ function versionDiagnostics(archive) {
   return [];
 }
 function settingsPlan(buffer, options) {
-  const parsed = parseYaml(buffer.toString("utf8"));
+  const parsed = (0, import_yaml.parse)(buffer.toString("utf8"));
   if (!isRecord(parsed)) return [{ type: "error", message: "settings fragment must be a YAML object" }];
   const settingsTarget = settingsFilePath();
   const current = settingsFragment(existsSync(settingsTarget) ? readSettings() : DEFAULT_SETTINGS);
@@ -417,7 +426,7 @@ function planShareImport(filePath, options = {}) {
   return publicImportPlan(prepareShareImport(filePath, options));
 }
 function mergeSettingsFragment(buffer) {
-  const parsed = parseYaml(buffer.toString("utf8"));
+  const parsed = (0, import_yaml.parse)(buffer.toString("utf8"));
   if (!isRecord(parsed)) throw new Error("settings fragment must be a YAML object");
   updateSettings((settings) => {
     const next = settings;
@@ -496,7 +505,11 @@ function importShareArchive(filePath, options = {}) {
   }
 }
 
+// src/domains/share/index.ts
+init_esm_shims();
+
 // src/domains/share/extension.ts
+init_esm_shims();
 function createShareBundle(_context) {
   const extension = {
     start() {
@@ -521,6 +534,7 @@ function createShareBundle(_context) {
 }
 
 // src/domains/share/manifest.ts
+init_esm_shims();
 var ShareManifest = {
   name: "share",
   dependsOn: ["config", "extensions", "resources"]
@@ -538,4 +552,4 @@ export {
   importShareArchive,
   ShareDomainModule
 };
-//# sourceMappingURL=chunk-AMFR5YA3.js.map
+//# sourceMappingURL=chunk-KKNLWXI6.js.map

package/dist/{chunk-JWHCJDCI.js → chunk-KY56HMHH.js}

@@ -1,24 +1,35 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   ACTIVE_AGENT_AUTOMATION_ROLES,
   ACTIVE_ROUTING_POSTURES,
   ACTIVE_ROUTING_ROLES,
   DEFAULT_SETTINGS,
   THINKING_LEVELS
-} from "./chunk-UHTSULZS.js";
+} from "./chunk-NMOX6HFD.js";
+import {
+  require_dist,
+  withStateFileLockSync
+} from "./chunk-GB6QRBXN.js";
 import {
   safeResourceWrite
-} from "./chunk-VPAWTYLY.js";
+} from "./chunk-WEPFGWHJ.js";
 import {
   clioConfigDir,
   resolveClioDirs
-} from "./chunk-X3NE4WVW.js";
+} from "./chunk-BNAZZHFG.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
 
 // src/core/config.ts
-import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 
 // src/core/timers.ts
+init_esm_shims();
 var MAX_TIMER_DELAY_MS = 2147483647;
 function clampTimerDelayMs(value) {
   if (Number.isNaN(value) || value <= 0) return 0;
@@ -27,6 +38,12 @@ function clampTimerDelayMs(value) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+var negativeDurations = 0;
+function rawDurationMs(start, end) {
+  const elapsed = end - start;
+  if (elapsed < 0) negativeDurations += 1;
+  return elapsed;
+}
 
 // src/core/config.ts
 function settingsPath() {
@@ -413,13 +430,13 @@ function normalizeModelRefs(refs, targets) {
   }
   return out;
 }
-function normalizeScope(refs, targets) {
-  const byId = new Set(targets.map((target) => target.id));
+function normalizeScope(refs) {
   const out = [];
   for (const ref of refs) {
-    const [targetId] = ref.split("/");
-    if (!targetId || !byId.has(targetId)) continue;
-    if (!out.includes(ref)) out.push(ref);
+    const trimmed = ref.trim();
+    const [targetId] = trimmed.split("/");
+    if (!targetId) continue;
+    if (!out.includes(trimmed)) out.push(trimmed);
   }
   return out;
 }
@@ -554,6 +571,8 @@ function validateFleetNode(issues, path, value, seen) {
     "user",
     "port",
     "identityFile",
+    "clioCoderEntry",
+    // Pre-0.3.1 spelling, still read.
     "clioEntry",
     "labels",
     "maxWorkers",
@@ -593,7 +612,11 @@ function validateFleetNode(issues, path, value, seen) {
   }
   if ("clioEntry" in value) {
     const v = expectString(issues, `${path}.clioEntry`, value.clioEntry);
-    if (v !== void 0) node.clioEntry = v;
+    if (v !== void 0) node.clioCoderEntry = v;
+  }
+  if ("clioCoderEntry" in value) {
+    const v = expectString(issues, `${path}.clioCoderEntry`, value.clioCoderEntry);
+    if (v !== void 0) node.clioCoderEntry = v;
   }
   if ("labels" in value) {
     const v = expectStringArray(issues, `${path}.labels`, value.labels);
@@ -681,6 +704,9 @@ function validateKeybindings(issues, value) {
 }
 var TOP_LEVEL_KEYS = [
   "version",
+  // Accepted and ignored. Settings files generated before 0.3.1 carry an
+  // `identity:` line for a control nothing ever read; listing it here keeps
+  // those files loading without an unknown-key issue.
   "identity",
   "autonomy",
   "targets",
@@ -715,10 +741,6 @@ function validateSettings(raw) {
   if ("version" in raw && raw.version !== 1) {
     issues.add("version", `expected 1, got ${describe(raw.version)}`);
   }
-  if ("identity" in raw) {
-    const v = expectString(issues, "identity", raw.identity);
-    if (v !== void 0) settings.identity = v;
-  }
   if ("autonomy" in raw) {
     const v = expectEnum(issues, "autonomy", raw.autonomy, AUTONOMY_LEVELS);
     if (v !== void 0) settings.autonomy = v;
@@ -961,7 +983,7 @@ function validateSettings(raw) {
   }
   if ("scope" in raw) {
     const v = expectStringArray(issues, "scope", raw.scope);
-    if (v !== void 0) settings.scope = normalizeScope(v, settings.targets);
+    if (v !== void 0) settings.scope = normalizeScope(v);
   }
   if ("modelSelector" in raw) {
     if (!isPlainObject(raw.modelSelector)) {
@@ -1076,12 +1098,12 @@ function validateSettings(raw) {
     if (!isPlainObject(raw.retry)) {
       issues.add("retry", `expected a map, got ${describe(raw.retry)}`);
     } else {
-      issues.unknownKeys("retry", raw.retry, ["enabled", "maxRetries", "baseDelayMs", "maxDelayMs"]);
+      issues.unknownKeys("retry", raw.retry, ["enabled", "maxRetries", "baseDelayMs", "maxDelayMs", "streamStallMs"]);
       if ("enabled" in raw.retry) {
         const v = expectBoolean(issues, "retry.enabled", raw.retry.enabled);
         if (v !== void 0) settings.retry.enabled = v;
       }
-      for (const key of ["maxRetries", "baseDelayMs", "maxDelayMs"]) {
+      for (const key of ["maxRetries", "baseDelayMs", "maxDelayMs", "streamStallMs"]) {
         if (key in raw.retry) {
           const v = expectInteger(issues, `retry.${key}`, raw.retry[key], { min: 0 });
           if (v !== void 0) settings.retry[key] = v;
@@ -1128,7 +1150,7 @@ function validateSettingsFile() {
   }
   let parsed;
   try {
-    parsed = parseYaml(text);
+    parsed = (0, import_yaml.parse)(text);
   } catch (err) {
     return {
       settings: cloneValue(DEFAULT_SETTINGS),
@@ -1142,74 +1164,136 @@ function readSettings() {
   if (result.issues.length > 0) throw new SettingsValidationError(result.issues);
   return result.settings;
 }
-function persistSettings(settings) {
-  safeResourceWrite(settingsPath(), stringifyYaml(settings), { encoding: "utf8", mode: 420 });
-}
-function settingsLockPath() {
-  return `${settingsPath()}.lock`;
+function persistSettings(document) {
+  safeResourceWrite(settingsPath(), (0, import_yaml.stringify)(document), { encoding: "utf8", mode: 420 });
 }
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.max(1, ms));
-}
-function tryAcquireSettingsLock(lockPath, staleLockMs) {
-  try {
-    writeFileSync(lockPath, `${JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() })}
-`, {
-      encoding: "utf8",
-      flag: "wx",
-      mode: 420
-    });
-    return true;
-  } catch (err) {
-    if (err.code !== "EEXIST") throw err;
-  }
+function readSavedDocument() {
+  const path = settingsPath();
+  if (!existsSync(path)) return {};
   try {
-    if (Date.now() - statSync(lockPath).mtimeMs > staleLockMs) rmSync(lockPath, { force: true });
+    return (0, import_yaml.parse)(readFileSync(path, "utf8")) ?? {};
   } catch {
+    return {};
   }
-  return false;
 }
-function withSettingsLock(fn, options = {}) {
-  const timeoutMs = options.timeoutMs ?? 1e4;
-  const staleLockMs = options.staleLockMs ?? 5e3;
-  const pollIntervalMs = options.pollIntervalMs ?? 25;
-  const lockPath = settingsLockPath();
-  const deadline = Date.now() + timeoutMs;
-  while (!tryAcquireSettingsLock(lockPath, staleLockMs)) {
-    if (Date.now() >= deadline) {
-      throw new Error(
-        `timed out after ${timeoutMs}ms waiting for ${lockPath}; delete it if no other clio process is running`
-      );
-    }
-    sleepSync(pollIntervalMs);
+function applySettingsDelta(saved, before, after) {
+  if (!isPlainObject(before) || !isPlainObject(after)) return cloneValue(after);
+  const out = isPlainObject(saved) ? { ...saved } : {};
+  for (const [key, next] of Object.entries(after)) {
+    if (deepEquals(before[key], next)) continue;
+    out[key] = applySettingsDelta(out[key], before[key], next);
   }
-  try {
-    return fn();
-  } finally {
-    rmSync(lockPath, { force: true });
+  for (const key of Object.keys(out)) {
+    if (!(key in after)) delete out[key];
   }
+  return out;
+}
+function deepEquals(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((entry, index) => deepEquals(entry, b[index]));
+  }
+  if (!isPlainObject(a) || !isPlainObject(b)) return false;
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  return keys.every((key) => key in b && deepEquals(a[key], b[key]));
+}
+function withSettingsLock(fn, options = {}) {
+  return withStateFileLockSync(settingsPath(), fn, { timeoutMs: options.timeoutMs ?? 1e4 });
 }
 function updateSettings(mutate, options = {}) {
   return withSettingsLock(() => {
+    const saved = readSavedDocument();
     const current = readSettings();
+    const before = cloneValue(current);
     const next = mutate(current) ?? current;
     const revalidated = validateSettings(JSON.parse(JSON.stringify(next)));
     if (revalidated.issues.length > 0) throw new SettingsValidationError(revalidated.issues);
-    persistSettings(revalidated.settings);
+    persistSettings(applySettingsDelta(saved, before, revalidated.settings));
     return revalidated.settings;
   }, options);
 }
+function useTargetInSettings(settings, targetId, options = {}) {
+  const target = settings.targets.find((entry) => entry.id === targetId);
+  if (!target) return null;
+  const workerTarget = options.workerTargetId !== void 0 && options.workerTargetId !== target.id ? settings.targets.find((entry) => entry.id === options.workerTargetId) : target;
+  if (!workerTarget) return null;
+  const sharedModel = options.model ?? target.defaultModel ?? null;
+  settings.orchestrator.target = target.id;
+  settings.orchestrator.model = options.orchestratorModel ?? sharedModel;
+  settings.workers.default.target = workerTarget.id;
+  settings.workers.default.model = options.workerModel ?? (workerTarget === target ? sharedModel : workerTarget.defaultModel ?? null);
+  if (options.backgroundModel !== void 0) {
+    settings.background.target = target.id;
+    settings.background.model = options.backgroundModel;
+  }
+  return { workerTargetId: workerTarget.id };
+}
+function removeTargetFromSettings(settings, id) {
+  if (!settings.targets.some((entry) => entry.id === id)) return false;
+  settings.targets = settings.targets.filter((entry) => entry.id !== id);
+  if (settings.orchestrator.target === id) {
+    settings.orchestrator.target = null;
+    settings.orchestrator.model = null;
+  }
+  if (settings.background.target === id) {
+    settings.background.target = null;
+    settings.background.model = null;
+  }
+  if (settings.workers.default.target === id) {
+    settings.workers.default.target = null;
+    settings.workers.default.model = null;
+  }
+  for (const [name, profile] of Object.entries(settings.workers.profiles)) {
+    if (profile.target === id) delete settings.workers.profiles[name];
+  }
+  settings.scope = settings.scope.filter((entry) => entry.split("/")[0] !== id);
+  return true;
+}
+function setFleetProfileInSettings(settings, name, targetId, options = {}) {
+  const target = settings.targets.find((entry) => entry.id === targetId);
+  if (!target) return false;
+  const existing = settings.workers.profiles[name];
+  settings.workers.profiles[name] = {
+    target: target.id,
+    model: options.model ?? target.defaultModel ?? null,
+    thinkingLevel: options.thinkingLevel ?? existing?.thinkingLevel ?? "off"
+  };
+  return true;
+}
+function removeFleetProfileFromSettings(settings, name) {
+  delete settings.workers.profiles[name];
+  let removedBindings = 0;
+  for (const [agentId, profileName] of Object.entries(settings.workers.agentBindings)) {
+    if (profileName !== name) continue;
+    delete settings.workers.agentBindings[agentId];
+    removedBindings += 1;
+  }
+  return removedBindings;
+}
+function bindAgentProfileInSettings(settings, agentId, profileName) {
+  if (settings.delegation.agents.some((agent) => agent.id === agentId)) return false;
+  settings.workers.agentBindings[agentId] = profileName;
+  return true;
+}
 
 export {
   MAX_TIMER_DELAY_MS,
   clampTimerDelayMs,
   sleep,
+  rawDurationMs,
   settingsPath,
   formatSettingsIssues,
   formatSettingsFailure,
   validateSettings,
   validateSettingsFile,
   readSettings,
-  updateSettings
+  updateSettings,
+  useTargetInSettings,
+  removeTargetFromSettings,
+  setFleetProfileInSettings,
+  removeFleetProfileFromSettings,
+  bindAgentProfileInSettings
 };
-//# sourceMappingURL=chunk-JWHCJDCI.js.map
+//# sourceMappingURL=chunk-KY56HMHH.js.map

package/dist/{chunk-E3NYWENM.js → chunk-LU4TK2PR.js}

@@ -1,10 +1,22 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  processAlive,
+  processBirthToken
+} from "./chunk-3I7MS7N2.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
 // src/domains/observability/trace-store.ts
+init_esm_shims();
 import { createHash } from "node:crypto";
 import { mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
+import { hostname } from "node:os";
 import { dirname, join } from "node:path";
 
 // src/domains/evidence/redact.ts
+init_esm_shims();
 function createRedactionTally() {
   return { count: 0 };
 }
@@ -228,10 +240,34 @@ CREATE TABLE processes (
   command TEXT NOT NULL,
   command_digest TEXT NOT NULL,
   started_at TEXT NOT NULL,
-  ended_at TEXT
+  ended_at TEXT,
+  host TEXT,
+  birth_token TEXT
 );
 CREATE INDEX processes_run_live ON processes(run_id, ended_at);
 `;
+function ensureProcessOwnerColumns(db) {
+  const columns = db.prepare("PRAGMA table_info(processes)").all();
+  if (columns.some((column) => column.name === "host")) return;
+  db.exec("ALTER TABLE processes ADD COLUMN host TEXT; ALTER TABLE processes ADD COLUMN birth_token TEXT;");
+}
+function reconcileAbandonedRuns(db) {
+  const owners = db.prepare(`SELECT r.run_id, r.started_at, p.pid, p.host, p.birth_token FROM runs r
+      JOIN processes p ON p.id = (SELECT MAX(id) FROM processes WHERE run_id = r.run_id AND host IS NOT NULL)
+      WHERE r.status = 'running'`).all();
+  const lastEvent = db.prepare(
+    "SELECT COALESCE(ended_at, started_at) AS at FROM events WHERE run_id = ? ORDER BY rowid DESC LIMIT 1"
+  );
+  for (const owner of owners) {
+    if (owner.host !== hostname()) continue;
+    if (processAlive(owner.pid) && (owner.birth_token === null || processBirthToken(owner.pid) === owner.birth_token))
+      continue;
+    const endedAt = lastEvent.get(owner.run_id)?.at ?? owner.started_at;
+    db.prepare("UPDATE runs SET status='fail', ended_at=? WHERE run_id=?").run(endedAt, owner.run_id);
+    db.prepare("UPDATE phases SET status='fail', ended_at=?, error=? WHERE run_id=? AND status='running'").run(endedAt, "abandoned: owner process exited before the run finalized", owner.run_id);
+    db.prepare("UPDATE processes SET ended_at=? WHERE run_id=? AND ended_at IS NULL").run(endedAt, owner.run_id);
+  }
+}
 var TraceStore = class {
   constructor(path) {
     this.path = path;
@@ -241,6 +277,10 @@ var TraceStore = class {
     const version = readVersion(this.db);
     if (version === null) this.db.exec(`BEGIN IMMEDIATE; ${SCHEMA_SQL} COMMIT;`);
     else if (version !== TRACE_SCHEMA_VERSION) throw new TraceSchemaVersionError(version);
+    this.transaction(() => {
+      ensureProcessOwnerColumns(this.db);
+      reconcileAbandonedRuns(this.db);
+    });
   }
   path;
   db;
@@ -301,14 +341,16 @@ var TraceStore = class {
         startedAt: at
       });
       if (input.pid !== null) {
-        this.db.prepare(`INSERT INTO processes(run_id, kind, name, pid, command, command_digest, started_at)
-            VALUES (?, 'worker', ?, ?, ?, ?, ?)`).run(
+        this.db.prepare(`INSERT INTO processes(run_id, kind, name, pid, command, command_digest, started_at, host, birth_token)
+            VALUES (?, 'worker', ?, ?, ?, ?, ?, ?, ?)`).run(
           input.runId,
           input.agentId,
           input.pid,
           traceText(input.processCommand ?? "[]", 2e3),
           sha256(input.processCommand ?? "[]"),
-          at
+          at,
+          hostname(),
+          processBirthToken(input.pid)
         );
       }
       this.db.prepare(`INSERT INTO agent_sessions
@@ -818,7 +860,10 @@ function recordProgress(store, payload, starts, seen, contextWindows, gateRuns,
     const key = `${payload.runId}:${toolCallId}`;
     const start = starts.get(key);
     const duration = finiteNonNegative(event.durationMs);
-    const startedAt = start?.startedAt ?? (duration === null ? at : new Date(Date.parse(at) - duration).toISOString());
+    const observedStart = start?.startedAt;
+    const startedAt = observedStart ?? (duration === null ? at : new Date(Date.parse(at) - duration).toISOString());
+    const startedAtMs = Date.parse(startedAt);
+    const endedAt = duration !== null && observedStart !== void 0 && Number.isFinite(startedAtMs) ? new Date(startedAtMs + duration).toISOString() : at;
     const tool = start?.tool ?? stringValue(event.toolName) ?? stringValue(event.tool) ?? "tool";
     const args = start?.args ?? event.args ?? null;
     const result = event.result ?? event.resultSnippet ?? null;
@@ -840,7 +885,7 @@ function recordProgress(store, payload, starts, seen, contextWindows, gateRuns,
         agent: payload.agentId
       },
       startedAt,
-      endedAt: at
+      endedAt
     });
     starts.delete(key);
     return;
@@ -1001,4 +1046,4 @@ export {
   TraceReader,
   createDispatchTraceMirror
 };
-//# sourceMappingURL=chunk-E3NYWENM.js.map
+//# sourceMappingURL=chunk-LU4TK2PR.js.map