@iowarp/clio-coder 0.4.4 → 0.4.5

package/dist/{chunk-6PAZTBPA.js → chunk-7HBHHVCK.js}

@@ -1,10 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   isSessionEntry
-} from "./chunk-54X7T7DK.js";
+} from "./chunk-5ZMXGW7P.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/session/task-board.ts
 init_esm_shims();
@@ -121,6 +121,15 @@ function foldSessionTaskHistory(entries) {
   }
   return [...boards.values()].sort((left, right) => right.lastIndex - left.lastIndex).map(({ lastIndex: _lastIndex, tasks, ...board }) => ({ ...board, tasks: [...tasks.values()] }));
 }
+function acceptanceRequirementDescription(check) {
+  return `Operator acceptance requirement: ${check} (declaration only; see verification receipts for execution status)`;
+}
+function acceptanceRequirement(item) {
+  if (item.status === "pending" && item.command && item.description === `Operator acceptance: ${item.command}` && item.observedAt === void 0) {
+    return { ...item, status: "required", description: acceptanceRequirementDescription(item.command) };
+  }
+  return { ...item };
+}
 function toEntryView(entry) {
   const boardGoal = entry.goals[0];
   if (!boardGoal) return null;
@@ -141,7 +150,7 @@ function toEntryView(entry) {
       };
       if (goal.userTaskId) task.userTaskId = goal.userTaskId;
       const required = entry.requiredValidationEvidence.filter((item) => item.id.startsWith(`${goal.id}.acceptance.`));
-      if (required.length > 0) task.requiredValidationEvidence = required.map((item) => ({ ...item }));
+      if (required.length > 0) task.requiredValidationEvidence = required.map(acceptanceRequirement);
       if (goal.description) task.reason = goal.description;
       const evidence = evidenceByTask.get(goal.id);
       if (evidence) task.evidence = evidence;
@@ -217,9 +226,9 @@ function applyMutation(board, mutation) {
     if (mutation.verification && mutation.verification.length > 0) {
       picked.requiredValidationEvidence = mutation.verification.map((item, index) => ({
         id: `${picked.id}.acceptance.${index}`,
-        description: `Operator acceptance: ${item.check}`,
+        description: acceptanceRequirementDescription(item.check),
         command: item.check,
-        status: "pending",
+        status: "required",
         notes: `timeoutMs=${item.timeoutMs}`
       }));
     }
@@ -383,4 +392,4 @@ export {
   foldSessionTaskHistory,
   createTaskBoardStore
 };
-//# sourceMappingURL=chunk-6PAZTBPA.js.map
+//# sourceMappingURL=chunk-7HBHHVCK.js.map

package/dist/{chunk-25QBEXRS.js → chunk-7TKWWPD7.js}

@@ -1,10 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   combineBashOutput
-} from "./chunk-W54I7H25.js";
+} from "./chunk-5A6XR3RJ.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/engine/tui.ts
 init_esm_shims();
@@ -946,7 +946,8 @@ function showClioOverlayFrame(tui, child, options) {
     // unchanged; the surface that gives the keyboard back to the composer
     // does it by hiding, which `setHidden` already reports.
     unfocus: (unfocusOptions) => unfocusOptions ? handle.unfocus(unfocusOptions) : handle.unfocus(),
-    isFocused: () => handle.isFocused()
+    isFocused: () => handle.isFocused(),
+    getBounds: () => handle.getBounds()
   };
 }
 function modalMarkerSink(tui) {
@@ -2504,4 +2505,4 @@ export {
   formatPlatformKeybindingNotice,
   createKeybindingManager
 };
-//# sourceMappingURL=chunk-25QBEXRS.js.map
+//# sourceMappingURL=chunk-7TKWWPD7.js.map

package/dist/{chunk-2VTFPG5O.js → chunk-7WLRF2U5.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/cli/output-guard.ts
 init_esm_shims();
@@ -45,4 +45,4 @@ export {
   writeRawStdout,
   flushRawStdout
 };
-//# sourceMappingURL=chunk-2VTFPG5O.js.map
+//# sourceMappingURL=chunk-7WLRF2U5.js.map

package/dist/chunk-7WUZEB2M.js

@@ -0,0 +1,165 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  codewikiNeedsBackfill,
+  codewikiPath,
+  readCodewiki,
+  writeCodewiki
+} from "./chunk-W2RJEH6Q.js";
+import {
+  withStateFileLock
+} from "./chunk-2QPI3TR3.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/context/codewiki/coordinator.ts
+init_esm_shims();
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { Worker } from "node:worker_threads";
+var BUILD_TIMEOUT_MS = 12e4;
+var workspaceTails = /* @__PURE__ */ new Map();
+var require2 = createRequire(import.meta.url);
+function buildWorkerUrl() {
+  if (!import.meta.url.endsWith(".ts")) return new URL("./codewiki/build-worker.js", import.meta.url);
+  const loaderApi = pathToFileURL(require2.resolve("tsx/esm/api")).href;
+  const source = new URL("./build-worker.ts", import.meta.url).href;
+  return new URL(
+    `data:text/javascript,${encodeURIComponent(`const { tsImport } = await import(${JSON.stringify(loaderApi)}); await tsImport(${JSON.stringify(source)}, import.meta.url);`)}`
+  );
+}
+function artifactRef(current) {
+  return {
+    source: "artifact",
+    needsBackfill: codewikiNeedsBackfill(current),
+    loc: current.files.reduce((sum, file) => file.lang === "config" ? sum : sum + file.loc, 0)
+  };
+}
+function byReference(request, held) {
+  if (request.kind === "build" || request.current === null || "source" in request.current) return request;
+  if (held === null || request.current !== held) return request;
+  return { ...request, current: artifactRef(held) };
+}
+async function executeInWorker(request) {
+  const worker = new Worker(buildWorkerUrl(), { workerData: request, execArgv: [] });
+  let exited = false;
+  const exit = new Promise((resolve2) => {
+    worker.once("exit", () => {
+      exited = true;
+      resolve2();
+    });
+  });
+  let timer;
+  try {
+    return await new Promise((resolve2, reject) => {
+      let settled = false;
+      const finish = (callback) => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        callback();
+      };
+      timer = setTimeout(() => {
+        finish(() => reject(new Error(`codewiki build worker exceeded ${BUILD_TIMEOUT_MS} ms`)));
+      }, BUILD_TIMEOUT_MS);
+      timer.unref();
+      worker.once("message", (message) => {
+        finish(() => {
+          if (message.ok) resolve2(message.result);
+          else {
+            const error = new Error(message.error);
+            if (message.stack) error.stack = message.stack;
+            reject(error);
+          }
+        });
+      });
+      worker.once(
+        "error",
+        (error) => finish(() => {
+          reject(error);
+        })
+      );
+      worker.once("exit", (code) => {
+        if (code !== 0)
+          finish(() => {
+            reject(new Error(`codewiki build worker exited with code ${code}`));
+          });
+      });
+    });
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (!exited) {
+      await Promise.race([
+        exit,
+        new Promise((resolve2) => {
+          const grace = setTimeout(resolve2, 250);
+          grace.unref();
+        })
+      ]);
+    }
+    if (!exited) await worker.terminate().catch(() => void 0);
+  }
+}
+function enqueueWorkspace(cwd, task) {
+  const key = codewikiPath(cwd);
+  const previous = workspaceTails.get(key) ?? Promise.resolve();
+  const result = previous.catch(() => void 0).then(task);
+  const tail = result.then(
+    () => void 0,
+    () => void 0
+  );
+  workspaceTails.set(key, tail);
+  void tail.finally(() => {
+    if (workspaceTails.get(key) === tail) workspaceTails.delete(key);
+  });
+  return result;
+}
+function coordinateCodewikiWrite(cwd, select, options = {}) {
+  const workspace = resolve(cwd);
+  return enqueueWorkspace(workspace, () => {
+    if (options.requireExisting && !existsSync(codewikiPath(workspace))) return Promise.resolve(null);
+    return withStateFileLock(codewikiPath(workspace), async () => {
+      if (options.requireExisting && !existsSync(codewikiPath(workspace))) return null;
+      const current = options.readCurrent?.(workspace) ?? readCodewiki(workspace);
+      const request = await select(current, workspace);
+      if (!request) return null;
+      const outcome = await executeInWorker(byReference({ ...request, cwd: workspace }, current));
+      const codewiki = outcome.codewiki ?? current;
+      if (!codewiki) throw new Error("codewiki reconciliation returned no artifact");
+      const worker = { codewiki, fingerprint: outcome.fingerprint, changed: outcome.changed };
+      await options.beforeCommit?.(worker, workspace);
+      const wrote = worker.changed || !existsSync(codewikiPath(workspace));
+      if (wrote) writeCodewiki(workspace, worker.codewiki);
+      await options.afterCommit?.(worker, workspace);
+      return { codewiki: !worker.changed && current ? current : worker.codewiki, worker, wrote };
+    });
+  });
+}
+function coordinateCodewikiExclusive(cwd, task) {
+  const workspace = resolve(cwd);
+  return enqueueWorkspace(workspace, () => withStateFileLock(codewikiPath(workspace), () => task(workspace)));
+}
+async function buildCodewikiCandidate(cwd, language) {
+  const outcome = await executeInWorker({ kind: "build", cwd: resolve(cwd), language });
+  if (!outcome.codewiki) throw new Error("codewiki build returned no artifact");
+  return { codewiki: outcome.codewiki, fingerprint: outcome.fingerprint, changed: outcome.changed };
+}
+async function drainCodewikiWrites(cwd) {
+  const workspace = resolve(cwd);
+  for (; ; ) {
+    const tail = workspaceTails.get(codewikiPath(workspace));
+    if (!tail) return;
+    await tail;
+    if (workspaceTails.get(codewikiPath(workspace)) === tail) return;
+  }
+}
+
+export {
+  coordinateCodewikiWrite,
+  coordinateCodewikiExclusive,
+  buildCodewikiCandidate,
+  drainCodewikiWrites
+};
+//# sourceMappingURL=chunk-7WUZEB2M.js.map

package/dist/{chunk-3UUXNFEX.js → chunk-7YJWEF2L.js}

@@ -1,4 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  shellQuote
+} from "./chunk-SD7SHNDW.js";
 import {
   WORKER_BULK_FRAME_MAX_BYTES,
   WORKER_EVENT_QUEUE_MAX_FRAMES,
@@ -12,25 +15,25 @@ import {
   parseBulkFrame,
   parseControlFrame,
   toolSignatureOf
-} from "./chunk-VAVR4IJY.js";
+} from "./chunk-VQD7NH7Z.js";
 import {
   readClioVersion,
   resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   AI_AGENT_NAME,
   withClioAgentEnvironment
-} from "./chunk-6EJMN2Y3.js";
+} from "./chunk-ZTNFYMIO.js";
 import {
   enableClioCompileCache,
   workerCompileCacheEnvironment
-} from "./chunk-2LEAKD4C.js";
+} from "./chunk-CKK25WN3.js";
 import {
   clioStateDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/dispatch/fleet-preflight.ts
 init_esm_shims();
@@ -39,12 +42,6 @@ import { existsSync, readFileSync } from "node:fs";
 import { join as join2 } from "node:path";
 import { performance as performance2 } from "node:perf_hooks";
 
-// src/core/shell-quote.ts
-init_esm_shims();
-function shellQuote(value) {
-  return `'${value.replace(/'/g, "'\\''")}'`;
-}
-
 // src/domains/dispatch/route-facts.ts
 init_esm_shims();
 var ROUTE_FACT_FRESHNESS_MS = 15 * 60 * 1e3;
@@ -526,26 +523,53 @@ function spawnWorkerProcess(command, args, spec, opts) {
       return this;
     }
   };
-  const promise = new Promise((resolve) => {
-    child.on("close", (code, signal) => {
+  let settled = false;
+  let abortStarted = false;
+  let killTimer = null;
+  let pendingClose = null;
+  function hasOwnedProcesses() {
+    if (pid === null) return false;
+    if (process.platform !== "win32") {
       try {
-        child.stdin?.end();
-      } catch {
-      }
-      end();
-      if (sawSpawnError) {
-        resolve({ exitCode: null, signal: null, ...diagnostics() });
-        return;
-      }
-      if (!announceAccepted && !announceFailed) {
-        announceFailed = true;
-        appendStderr("[worker] Missing worker attestation: peer exited before announcing its route identity\n");
+        process.kill(-pid, 0);
+        return true;
+      } catch (error) {
+        if (error.code === "EPERM") return true;
       }
-      if (announceFailed) {
-        resolve({ exitCode: code !== null && code !== 0 ? code : 1, signal: signal ?? null, ...diagnostics() });
+    }
+    return isAlive();
+  }
+  const promise = new Promise((resolve) => {
+    child.on("close", (code, signal) => {
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        try {
+          child.stdin?.end();
+        } catch {
+        }
+        end();
+        if (sawSpawnError) {
+          resolve({ exitCode: null, signal: null, ...diagnostics() });
+          return;
+        }
+        if (!announceAccepted && !announceFailed) {
+          announceFailed = true;
+          appendStderr("[worker] Missing worker attestation: peer exited before announcing its route identity\n");
+        }
+        if (announceFailed) {
+          resolve({ exitCode: code !== null && code !== 0 ? code : 1, signal: signal ?? null, ...diagnostics() });
+          return;
+        }
+        resolve({ exitCode: code ?? 0, signal: signal ?? null, ...diagnostics() });
+      };
+      if (killTimer !== null && hasOwnedProcesses()) {
+        pendingClose = finish;
         return;
       }
-      resolve({ exitCode: code ?? 0, signal: signal ?? null, ...diagnostics() });
+      if (killTimer !== null) clearTimeout(killTimer);
+      killTimer = null;
+      finish();
     });
   });
   function isAlive() {
@@ -589,22 +613,26 @@ function spawnWorkerProcess(command, args, spec, opts) {
     }
   };
   const abort = () => {
-    if (!isAlive()) return;
+    if (settled || abortStarted || !hasOwnedProcesses()) return;
+    abortStarted = true;
     try {
       child.stdin?.end();
     } catch {
     }
     signalProcessGroup(child, "SIGTERM");
-    const killTimer = setTimeout(() => {
-      if (isAlive()) {
+    killTimer = setTimeout(() => {
+      killTimer = null;
+      if (hasOwnedProcesses()) {
         signalProcessGroup(child, "SIGKILL");
         try {
           opts?.onForcedKill?.();
         } catch {
         }
       }
+      const finish = pendingClose;
+      pendingClose = null;
+      finish?.();
     }, shutdownGraceMs);
-    killTimer.unref?.();
   };
   return {
     pid,
@@ -932,7 +960,6 @@ async function runFleetNodePreflight(node, projectRoot, options) {
 }
 
 export {
-  shellQuote,
   computeSettingsFingerprint,
   receiptAttestationFields,
   spawnNativeWorker,
@@ -944,4 +971,4 @@ export {
   routeFactVerdict,
   runFleetNodePreflight
 };
-//# sourceMappingURL=chunk-3UUXNFEX.js.map
+//# sourceMappingURL=chunk-7YJWEF2L.js.map

package/dist/{chunk-3EBYEESD.js → chunk-A46ILRS2.js}

@@ -2,18 +2,18 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   PANES_PRESETS,
   resolvePanesPresetId
-} from "./chunk-35MSIRKH.js";
+} from "./chunk-QUIJZSDW.js";
 import {
   newestRunEventJournalRunId,
   runEventJournalPath,
   runEventJournalRoot
-} from "./chunk-VIA6RFQZ.js";
+} from "./chunk-UQIVHSE4.js";
 import {
   resolveBinary
-} from "./chunk-BMS5RKQY.js";
+} from "./chunk-JABWPKFY.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/interactive/panes-runtime.ts
 init_esm_shims();
@@ -311,4 +311,4 @@ export {
   describePanesLeftBehind,
   createPanesRuntime
 };
-//# sourceMappingURL=chunk-3EBYEESD.js.map
+//# sourceMappingURL=chunk-A46ILRS2.js.map

package/dist/{chunk-UOIZ7DA4.js → chunk-AP7HDJOP.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/lifecycle/install-method.ts
 init_esm_shims();
@@ -38,4 +38,4 @@ function sourceCheckoutRoot(entryPath = process.argv[1]) {
 export {
   detectInstallMethod
 };
-//# sourceMappingURL=chunk-UOIZ7DA4.js.map
+//# sourceMappingURL=chunk-AP7HDJOP.js.map