@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/{chunk-Q3RUPKEJ.js → chunk-V4RXGQ5Q.js}

@@ -1,185 +1,31 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  readLayeredSettings
-} from "./chunk-XYWBQRDM.js";
+  readStrictLayeredSettings,
+  updateLayeredSettings
+} from "./chunk-CBCAPZAA.js";
+import {
+  formatSettingsFailure,
+  settingsPath
+} from "./chunk-A3CYT5EX.js";
+import {
+  setGitCommitAttributionEnabled
+} from "./chunk-X75S7HFS.js";
+import {
+  resolveShutdownHookBudgetMs,
+  runWithBudget,
+  writeShutdownNotice
+} from "./chunk-TZTZS7QK.js";
 import {
   BusChannels,
   getSharedBus
-} from "./chunk-Q5WJOSJ7.js";
-import {
-  formatSettingsFailure,
-  readSettings,
-  settingsPath,
-  updateSettings
-} from "./chunk-KY56HMHH.js";
+} from "./chunk-OQ33BKR3.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
 // src/core/domain-loader.ts
 init_esm_shims();
-
-// src/core/termination.ts
-init_esm_shims();
-var DEFAULT_SHUTDOWN_HOOK_MS = 500;
-var SIGNAL_EXIT_CODES = {
-  SIGHUP: 129,
-  SIGINT: 130,
-  SIGTERM: 143
-};
-function resolveShutdownHookBudgetMs() {
-  const raw = process.env.CLIO_CODER_SHUTDOWN_HOOK_MS;
-  if (raw === void 0) return DEFAULT_SHUTDOWN_HOOK_MS;
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_SHUTDOWN_HOOK_MS;
-  return parsed;
-}
-async function runWithBudget(op, budgetMs, onError) {
-  let timer;
-  const timeout = new Promise((resolve) => {
-    timer = setTimeout(() => resolve("timeout"), budgetMs);
-  });
-  try {
-    const done = Promise.resolve().then(() => op()).then(() => "done").catch((err) => {
-      onError?.(err);
-      return "done";
-    });
-    const outcome = await Promise.race([done, timeout]);
-    return outcome === "done";
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-var TerminationCoordinator = class {
-  phase = "idle";
-  drainHooks = [];
-  terminateHooks = [];
-  persistHooks = [];
-  exitCode = 0;
-  started = false;
-  signalHandler = null;
-  getPhase() {
-    return this.phase;
-  }
-  /**
-   * The process exit code this shutdown will use. Set before any hook runs,
-   * so a hook sealing terminal accounting records the same status the process
-   * reports (130 for SIGINT, 143 for SIGTERM).
-   */
-  getExitCode() {
-    return this.exitCode;
-  }
-  onDrain(hook) {
-    this.drainHooks.push(hook);
-  }
-  onTerminate(hook) {
-    this.terminateHooks.push(hook);
-  }
-  onPersist(hook) {
-    this.persistHooks.push(hook);
-  }
-  async shutdown(code = 0) {
-    if (this.started) return;
-    this.started = true;
-    this.exitCode = code;
-    const bus = getSharedBus();
-    const debug = process.env.CLIO_CODER_DEBUG_SHUTDOWN === "1";
-    const budgetMs = resolveShutdownHookBudgetMs();
-    const mark = debug ? process.hrtime.bigint() : 0n;
-    const log = (msg) => {
-      if (!debug) return;
-      const ms = Number(process.hrtime.bigint() - mark) / 1e6;
-      process.stderr.write(`[clio:shutdown] +${ms.toFixed(1)}ms ${msg}
-`);
-    };
-    this.phase = "draining";
-    bus.emit(BusChannels.ShutdownRequested, { phase: this.phase });
-    log("drain:start");
-    await this.runHooks(this.drainHooks, "drain", budgetMs, log);
-    log("drain:end");
-    bus.emit(BusChannels.ShutdownDrained, {});
-    this.phase = "terminating";
-    log("terminate:start");
-    await this.runHooks(this.terminateHooks, "terminate", budgetMs, log);
-    log("terminate:end");
-    bus.emit(BusChannels.ShutdownTerminated, {});
-    this.phase = "persisting";
-    log("persist:start");
-    await this.runHooks(this.persistHooks, "persist", budgetMs, log);
-    log("persist:end");
-    bus.emit(BusChannels.ShutdownPersisted, {});
-    this.phase = "exiting";
-    bus.emit(BusChannels.SessionEnd, { exitCode: this.exitCode });
-    log("process.exit");
-    process.exit(this.exitCode);
-  }
-  async runHooks(hooks, phase, budgetMs, log) {
-    for (let i = 0; i < hooks.length; i++) {
-      const hook = hooks[i];
-      if (!hook) continue;
-      const t0 = process.hrtime.bigint();
-      const completed = await runWithBudget(hook, budgetMs, (err) => {
-        console.error("[clio:termination] hook failed:", err);
-      });
-      const dt = Number(process.hrtime.bigint() - t0) / 1e6;
-      if (!completed) {
-        process.stderr.write(
-          `[clio:termination] ${phase}[${i}] exceeded ${budgetMs}ms budget; abandoning and continuing shutdown
-`
-        );
-      }
-      log(`  ${phase}[${i}] ${dt.toFixed(1)}ms${completed ? "" : " (timed out)"}`);
-    }
-  }
-  /**
-   * SIGHUP is here for the same reason as SIGTERM. Without a listener Node
-   * takes its default action and the process dies with no shutdown at all,
-   * which on a TUI session means the terminal is never given back. Exit codes
-   * follow the 128+signal convention.
-   */
-  installSignalHandlers() {
-    if (this.signalHandler) return;
-    const handler = (signal) => {
-      process.stderr.write(`
-Clio Coder: received ${signal}, shutting down...
-`);
-      void this.shutdown(SIGNAL_EXIT_CODES[signal] ?? 143);
-    };
-    this.signalHandler = handler;
-    process.once("SIGINT", handler);
-    process.once("SIGTERM", handler);
-    process.once("SIGHUP", handler);
-  }
-  /**
-   * Hand SIGINT to a foreground owner and return the call that takes it back.
-   *
-   * Boot arms this coordinator before any interactive surface exists, and Node
-   * runs signal listeners in registration order, so a TUI that merely added its
-   * own listener would lose every first press to a shutdown already underway.
-   * One owner holds the interrupt at a time and the transfer is explicit.
-   * SIGTERM is not part of the handover; it is never an interactive gesture.
-   */
-  releaseInterruptOwnership() {
-    const handler = this.signalHandler;
-    if (!handler) return () => {
-    };
-    process.off("SIGINT", handler);
-    let restored = false;
-    return () => {
-      if (restored) return;
-      restored = true;
-      process.once("SIGINT", handler);
-    };
-  }
-};
-var coordinator = null;
-function getTerminationCoordinator() {
-  if (!coordinator) coordinator = new TerminationCoordinator();
-  return coordinator;
-}
-
-// src/core/domain-loader.ts
-async function loadDomains(modules) {
+async function loadDomains(modules, options = {}) {
   const order = topoSort(modules);
   const contracts = /* @__PURE__ */ new Map();
   const extensions = /* @__PURE__ */ new Map();
@@ -206,8 +52,10 @@ async function loadDomains(modules) {
       failed.push({ name, error });
       bus.emit(BusChannels.DomainFailed, { name, error });
       const message = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[clio:domain] load failed: ${name}: ${message}
-`);
+      (options.diagnostic ?? ((text) => process.stderr.write(text)))(
+        `[clio:domain] load failed: ${name}: ${message}
+`
+      );
       throw new DomainLoadError(name, error);
     }
   }
@@ -220,11 +68,13 @@ async function loadDomains(modules) {
       const stopFn = ext.stop.bind(ext);
       const t0 = debug ? process.hrtime.bigint() : 0n;
       const completed = await runWithBudget(stopFn, budgetMs, (err) => {
-        console.error(`[clio:domain-loader] ${name}.stop() failed:`, err);
+        const message = err instanceof Error ? err.message : String(err);
+        writeShutdownNotice(`[clio:domain-loader] ${name}.stop() failed: ${message}`);
+        if (debug && err instanceof Error && err.stack) process.stderr.write(`${err.stack}
+`);
       });
       if (!completed) {
-        process.stderr.write(`[clio:domain-loader] ${name}.stop() exceeded ${budgetMs}ms budget; abandoning
-`);
+        writeShutdownNotice(`[clio:domain-loader] ${name}.stop() exceeded ${budgetMs}ms budget; abandoning`);
       }
       if (debug) {
         const dt = Number(process.hrtime.bigint() - t0) / 1e6;
@@ -300,7 +150,14 @@ function assertAgentIdNamespace(nativeRecipes, acpDelegates) {
 
 // src/domains/config/classify.ts
 init_esm_shims();
-var HOT_RELOAD_FIELDS = /* @__PURE__ */ new Set(["theme", "keybindings", "autonomy", "modelSelector"]);
+var HOT_RELOAD_FIELDS = /* @__PURE__ */ new Set([
+  "theme",
+  "keybindings",
+  "autonomy",
+  "modelSelector",
+  "terminal.smoothStreaming",
+  "attribution.gitCommits"
+]);
 var NEXT_TURN_FIELDS = /* @__PURE__ */ new Set([
   "identity",
   "targets",
@@ -329,7 +186,12 @@ var NEXT_TURN_FIELDS = /* @__PURE__ */ new Set([
   "compaction",
   "retry"
 ]);
-var RESTART_REQUIRED_FIELDS = /* @__PURE__ */ new Set(["budget.concurrency", "runtimePlugins"]);
+var RESTART_REQUIRED_FIELDS = /* @__PURE__ */ new Set([
+  "budget.concurrency",
+  "runtimePlugins",
+  "terminal.tuiMode",
+  "terminal.fullscreenScrollbar"
+]);
 function matchesPrefix(path, fields) {
   if (fields.has(path)) return true;
   for (const field of fields) {
@@ -342,8 +204,8 @@ function diffSettings(prev, next) {
   const diff = { hotReload: [], nextTurn: [], restartRequired: [] };
   for (const p of changed) {
     if (matchesPrefix(p, HOT_RELOAD_FIELDS)) diff.hotReload.push(p);
-    else if (matchesPrefix(p, NEXT_TURN_FIELDS)) diff.nextTurn.push(p);
     else if (matchesPrefix(p, RESTART_REQUIRED_FIELDS)) diff.restartRequired.push(p);
+    else if (matchesPrefix(p, NEXT_TURN_FIELDS)) diff.nextTurn.push(p);
     else {
       diff.restartRequired.push(p);
     }
@@ -396,7 +258,7 @@ function startConfigWatcher(cb) {
 }
 
 // src/domains/config/extension.ts
-function createConfigBundle(context) {
+function createConfigBundle(context, initialSettings) {
   let watcher = null;
   let snapshot = null;
   let reloadFailure = null;
@@ -429,8 +291,7 @@ function createConfigBundle(context) {
   function onWatcherFire() {
     let next;
     try {
-      readSettings();
-      next = readLayeredSettings(process.cwd()).settings;
+      next = readStrictLayeredSettings(process.cwd()).settings;
     } catch (err) {
       publishReloadFailure(formatSettingsFailure(err));
       return;
@@ -444,6 +305,7 @@ function createConfigBundle(context) {
     }
     publishReloadFailure(null);
     snapshot = next;
+    setGitCommitAttributionEnabled(next.attribution.gitCommits);
     if (!prev) return;
     const diff = diffSettings(prev, next);
     if (diff.hotReload.length > 0) dispatch("hotReload", { diff, settings: next });
@@ -452,8 +314,9 @@ function createConfigBundle(context) {
   }
   const extension = {
     async start() {
-      readSettings();
-      snapshot = readLayeredSettings(process.cwd()).settings;
+      if (initialSettings) snapshot = structuredClone(initialSettings);
+      else snapshot = readStrictLayeredSettings(process.cwd()).settings;
+      setGitCommitAttributionEnabled(snapshot.attribution.gitCommits);
       watcher = startConfigWatcher(() => onWatcherFire());
     },
     async stop() {
@@ -475,9 +338,9 @@ function createConfigBundle(context) {
       const candidate = structuredClone(previous);
       mutate(candidate);
       assertAgentNamespace(candidate);
-      updateSettings(mutate);
-      const normalized = readLayeredSettings(process.cwd()).settings;
+      const normalized = updateLayeredSettings(process.cwd(), mutate);
       snapshot = normalized;
+      setGitCommitAttributionEnabled(normalized.attribution.gitCommits);
       const diff = diffSettings(previous, normalized);
       if (diff.hotReload.length > 0) dispatch("hotReload", { diff, settings: normalized });
       if (diff.nextTurn.length > 0) dispatch("nextTurn", { diff, settings: normalized });
@@ -505,11 +368,17 @@ var ConfigDomainModule = {
   manifest: ConfigManifest,
   createExtension: createConfigBundle
 };
+function createConfigDomainModule(initialSettings) {
+  return {
+    manifest: ConfigManifest,
+    createExtension: (context) => createConfigBundle(context, initialSettings)
+  };
+}
 
 export {
-  getTerminationCoordinator,
   loadDomains,
   assertAgentIdNamespace,
-  ConfigDomainModule
+  ConfigDomainModule,
+  createConfigDomainModule
 };
-//# sourceMappingURL=chunk-Q3RUPKEJ.js.map
+//# sourceMappingURL=chunk-V4RXGQ5Q.js.map