@iowarp/clio-coder 0.4.1 → 0.4.3

package/dist/{chunk-O42A54GG.js → chunk-5OIVVPHF.js}

@@ -2,7 +2,7 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   createEngineAi,
   getEngineSupportedThinkingLevels
-} from "./chunk-VXMFAE2W.js";
+} from "./chunk-YPC6ZR5L.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -162,4 +162,4 @@ export {
   catalogThinkingLevelsForRuntime,
   synthesizeCatalogBackedModel
 };
-//# sourceMappingURL=chunk-O42A54GG.js.map
+//# sourceMappingURL=chunk-5OIVVPHF.js.map

package/dist/{chunk-ABLSQ6JX.js → chunk-64I3JVYM.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-K6BSR66V.js";
 import {
   StringEnum
-} from "./chunk-VXMFAE2W.js";
+} from "./chunk-YPC6ZR5L.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -21,6 +21,12 @@ var codeNavToolSurface = {
   name: ToolNames.CodeNav,
   description: "Navigate the indexed codewiki: mode=symbol finds files by symbol, path finds files by glob/regex/substring, entries lists likely entry points, outline lists file symbols, deps lists imports, and dependents lists importers. mode=wiki without query lists generated Markdown wiki pages; with query it resolves a page id/title and returns its summary plus a path to open with read. For Clio's bundled product docs use context scope=docs.",
   parameters: typebox_exports.Object({
+    source: typebox_exports.Optional(
+      StringEnum(["workspace", "clio"], {
+        description: "Code map source (default workspace).",
+        default: "workspace"
+      })
+    ),
     mode: StringEnum(["symbol", "path", "entries", "outline", "deps", "dependents", "wiki"], {
       description: "Lookup mode."
     }),
@@ -43,4 +49,4 @@ export {
   CODE_NAV_MAX_LIMIT,
   codeNavToolSurface
 };
-//# sourceMappingURL=chunk-ABLSQ6JX.js.map
+//# sourceMappingURL=chunk-64I3JVYM.js.map

package/dist/{chunk-AFKWHWXF.js → chunk-6PTFB5VS.js}

@@ -17,17 +17,17 @@ import {
   toolSignatureOf
 } from "./chunk-VAVR4IJY.js";
 import {
-  enableClioCompileCache,
-  workerCompileCacheEnvironment
-} from "./chunk-2LEAKD4C.js";
+  readClioVersion,
+  resolvePackageRoot
+} from "./chunk-IWHMRKLL.js";
 import {
   AI_AGENT_NAME,
   withClioAgentEnvironment
 } from "./chunk-6EJMN2Y3.js";
 import {
-  readClioVersion,
-  resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+  enableClioCompileCache,
+  workerCompileCacheEnvironment
+} from "./chunk-2LEAKD4C.js";
 import {
   clioStateDir
 } from "./chunk-BYP5D4HI.js";
@@ -635,10 +635,22 @@ function localNodeIdentity() {
 var DEFAULT_SSH_CONNECT_TIMEOUT_SEC = 10;
 var DEFAULT_REMOTE_CLIO_ENTRY = "clio-coder worker";
 function remoteEnvAssignments(node) {
-  const residency = node.residency ?? "observe";
   const labels = (node.labels ?? []).map((label) => label.trim()).filter((label) => label.length > 0);
   const labelAssignment = labels.length > 0 ? ` CLIO_CODER_WORKER_LABELS=${shellQuote(labels.join(","))}` : "";
-  return `AI_AGENT=${AI_AGENT_NAME} CLIO_CODER_RESIDENCY=${residency} CLIO_CODER_WORKER_PGID=$$${labelAssignment}`;
+  return `AI_AGENT=${AI_AGENT_NAME} CLIO_CODER_WORKER_PGID=$$${labelAssignment}`;
+}
+function resolveSshTargetLifecycle(residency, targetLifecycle) {
+  if (targetLifecycle === "user-managed" || residency !== "manage") return "user-managed";
+  return "clio-coder-managed";
+}
+function workerSpecForSshNode(node, spec) {
+  return {
+    ...spec,
+    target: {
+      ...spec.target,
+      lifecycle: resolveSshTargetLifecycle(node.residency, spec.target.lifecycle)
+    }
+  };
 }
 function buildRemoteWorkerCommand(node, cwd) {
   const entry = node.clioCoderEntry !== void 0 && node.clioCoderEntry.trim().length > 0 ? node.clioCoderEntry.trim() : DEFAULT_REMOTE_CLIO_ENTRY;
@@ -684,20 +696,25 @@ function createSshWorkerTransport(node, opts) {
         }
       };
       const { cwd: _consumedCwd, onAnnounce, onForcedKill, ...forwarded } = spawnOpts ?? {};
-      return spawnWorkerProcess(sshBinary, buildSshArgs(node, buildRemoteWorkerCommand(node, cwd)), spec, {
-        ...opts?.shutdownGraceMs !== void 0 ? { shutdownGraceMs: opts.shutdownGraceMs } : {},
-        ...forwarded,
-        env: process.env,
-        onAnnounce: (attestation) => {
-          remote.pid = attestation.pid;
-          remote.processGroupId = attestation.processGroupId;
-          onAnnounce?.(attestation);
-        },
-        onForcedKill: () => {
-          killRemote();
-          onForcedKill?.();
+      return spawnWorkerProcess(
+        sshBinary,
+        buildSshArgs(node, buildRemoteWorkerCommand(node, cwd)),
+        workerSpecForSshNode(node, spec),
+        {
+          ...opts?.shutdownGraceMs !== void 0 ? { shutdownGraceMs: opts.shutdownGraceMs } : {},
+          ...forwarded,
+          env: process.env,
+          onAnnounce: (attestation) => {
+            remote.pid = attestation.pid;
+            remote.processGroupId = attestation.processGroupId;
+            onAnnounce?.(attestation);
+          },
+          onForcedKill: () => {
+            killRemote();
+            onForcedKill?.();
+          }
         }
-      });
+      );
     }
   };
 }
@@ -923,4 +940,4 @@ export {
   routeFactVerdict,
   runFleetNodePreflight
 };
-//# sourceMappingURL=chunk-AFKWHWXF.js.map
+//# sourceMappingURL=chunk-6PTFB5VS.js.map

package/dist/{chunk-VN3SHNBN.js → chunk-7DICMOS6.js}

@@ -5,7 +5,7 @@ import {
 import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   resolveSafeCwd
-} from "./chunk-HJWWJ6IL.js";
+} from "./chunk-JSC3U7TI.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -310,4 +310,4 @@ export {
   parseProjectVerifierCatalogText,
   packageDeclaredCheck
 };
-//# sourceMappingURL=chunk-VN3SHNBN.js.map
+//# sourceMappingURL=chunk-7DICMOS6.js.map

package/dist/chunk-7DRAWPTZ.js

@@ -0,0 +1,360 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  disableExtension,
+  discoverExtensionPackages,
+  enableExtension,
+  installExtension,
+  listInstalledExtensionRecords,
+  listInstalledExtensions,
+  removeExtension
+} from "./chunk-5MEZN6CB.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/extensions/manager.ts
+init_esm_shims();
+
+// src/domains/extensions/resources.ts
+init_esm_shims();
+import { realpathSync as realpathSync3 } from "node:fs";
+import path3 from "node:path";
+
+// src/domains/extensions/snapshot.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { createHash } from "node:crypto";
+import { realpathSync as realpathSync2 } from "node:fs";
+import path2 from "node:path";
+
+// src/domains/extensions/resource-path.ts
+init_esm_shims();
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
+function extensionResourcePath(rootPath, resourcePath) {
+  const root = path.resolve(rootPath);
+  const full = path.resolve(root, resourcePath);
+  const relative = path.relative(root, full);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    return null;
+  }
+  try {
+    const rootReal = realpathSync(root);
+    const fullReal = realpathSync(full);
+    const canonicalRelative = path.relative(rootReal, fullReal);
+    if (canonicalRelative === ".." || canonicalRelative.startsWith(`..${path.sep}`) || path.isAbsolute(canonicalRelative)) {
+      return null;
+    }
+    if (!statSync(fullReal).isDirectory()) return null;
+    return fullReal;
+  } catch {
+    return null;
+  }
+}
+
+// src/domains/extensions/types.ts
+init_esm_shims();
+function isLoadableExtension(entry) {
+  return entry.loadable && entry.provenance !== void 0;
+}
+
+// src/domains/extensions/snapshot.ts
+var EXTENSION_SNAPSHOT_DIAGNOSTIC_CAP = 200;
+var EXTENSION_SNAPSHOT_DIAGNOSTIC_PER_PACKAGE_CAP = 20;
+var EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP = 512;
+var RESOURCE_KINDS = ["skills", "prompts", "agents", "fleets", "themes"];
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function deepFreeze(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  for (const child of Object.values(value)) deepFreeze(child, seen);
+  return Object.freeze(value);
+}
+function boundedDiagnostics(records) {
+  const entries = [];
+  let truncated = 0;
+  for (const { entry } of records) {
+    let admittedForPackage = 0;
+    for (const diagnostic of entry.diagnostics) {
+      if (admittedForPackage >= EXTENSION_SNAPSHOT_DIAGNOSTIC_PER_PACKAGE_CAP || entries.length >= EXTENSION_SNAPSHOT_DIAGNOSTIC_CAP) {
+        truncated += 1;
+        continue;
+      }
+      entries.push({
+        type: diagnostic.type,
+        message: diagnostic.message.slice(0, EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP),
+        ...diagnostic.path ? { path: diagnostic.path } : {},
+        extensionId: entry.id
+      });
+      admittedForPackage += 1;
+    }
+  }
+  return { entries, truncated };
+}
+function buildExtensionSnapshot(input) {
+  const cwd = realpathSync2(path2.resolve(input.cwd));
+  const records = (input.listRecords ?? listInstalledExtensionRecords)(cwd, { all: true });
+  const resourceRoots = {
+    skills: [],
+    prompts: [],
+    agents: [],
+    fleets: [],
+    themes: []
+  };
+  const hookSources = [];
+  const digestPackages = [];
+  for (const record of records) {
+    const { entry } = record;
+    const packageRoots = [];
+    let hooksDigest;
+    if (isLoadableExtension(entry)) {
+      for (const kind of RESOURCE_KINDS) {
+        const relative = entry.resources[kind];
+        if (!relative) continue;
+        const resolved = extensionResourcePath(entry.rootPath, relative);
+        if (!resolved) continue;
+        resourceRoots[kind].push({
+          id: entry.id,
+          scope: entry.scope,
+          path: resolved,
+          rootPath: entry.rootPath,
+          source: `extension:${entry.scope}:${entry.id}`,
+          provenance: entry.provenance,
+          generation: input.generation
+        });
+        packageRoots.push({ kind, path: resolved });
+      }
+      const hookBytes = record.captured?.get("hooks.yaml");
+      if (hookBytes !== void 0) {
+        hooksDigest = createHash("sha256").update(hookBytes).digest("hex");
+        let declarations = [];
+        let parseError;
+        try {
+          declarations = (0, import_yaml.parse)(hookBytes.toString("utf8")) ?? [];
+        } catch (error) {
+          parseError = error instanceof Error ? error.message : String(error);
+        }
+        hookSources.push({
+          provenance: entry.provenance,
+          declarationsDigest: hooksDigest,
+          declarations,
+          ...parseError ? { parseError } : {}
+        });
+      }
+    }
+    digestPackages.push({
+      id: entry.id,
+      scope: entry.scope,
+      loadable: entry.loadable,
+      ...entry.provenance ? { provenance: entry.provenance } : {},
+      resourceRoots: packageRoots,
+      ...hooksDigest ? { hooksDigest } : {}
+    });
+  }
+  const snapshot = {
+    version: 1,
+    generation: input.generation,
+    cwd,
+    builtAt: (input.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    digest: createHash("sha256").update(canonicalJson(digestPackages)).digest("hex"),
+    packages: records.map((record) => record.entry),
+    resourceRoots,
+    hookSources,
+    diagnostics: boundedDiagnostics(records)
+  };
+  return deepFreeze(snapshot);
+}
+function packageFingerprints(snapshot) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of snapshot.packages) {
+    const list = grouped.get(entry.id) ?? [];
+    list.push({
+      scope: entry.scope,
+      loadable: entry.loadable,
+      provenance: entry.provenance ?? null,
+      resources: entry.resources
+    });
+    grouped.set(entry.id, list);
+  }
+  return new Map(
+    [...grouped].map(([id, values]) => [id, createHash("sha256").update(canonicalJson(values)).digest("hex")])
+  );
+}
+function diffExtensionSnapshots(previous, next) {
+  if (previous === null) {
+    return { changed: true, added: [...new Set(next.packages.map((entry) => entry.id))], removed: [], modified: [] };
+  }
+  const before = packageFingerprints(previous);
+  const after = packageFingerprints(next);
+  const added = [...after.keys()].filter((id) => !before.has(id));
+  const removed = [...before.keys()].filter((id) => !after.has(id));
+  const modified = [...after.keys()].filter((id) => before.has(id) && before.get(id) !== after.get(id));
+  return { changed: previous.digest !== next.digest, added, removed, modified };
+}
+
+// src/domains/extensions/snapshot-store.ts
+init_esm_shims();
+function createExtensionSnapshotStore() {
+  let committed = null;
+  let reservedGeneration = 0;
+  return {
+    current: () => committed,
+    publish(snapshot) {
+      committed = snapshot;
+    },
+    nextGeneration() {
+      reservedGeneration += 1;
+      return reservedGeneration;
+    }
+  };
+}
+var boundStore = null;
+function committedExtensionSnapshot() {
+  return boundStore?.current() ?? null;
+}
+function bindExtensionSnapshotStore(store) {
+  boundStore = store;
+}
+
+// src/domains/extensions/resources.ts
+function extensionSnapshotFor(cwd = process.cwd()) {
+  const committed = committedExtensionSnapshot();
+  try {
+    if (committed !== null && committed.cwd === realpathSync3(path3.resolve(cwd))) return committed;
+  } catch {
+  }
+  return buildExtensionSnapshot({ cwd, generation: 0 });
+}
+function enabledExtensionResourceRoots(kind, cwd = process.cwd()) {
+  return [...extensionSnapshotFor(cwd).resourceRoots[kind]];
+}
+
+// src/domains/extensions/index.ts
+init_esm_shims();
+
+// src/domains/extensions/extension.ts
+init_esm_shims();
+function failureDiagnostics(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    entries: [{ type: "error", message: message.slice(0, EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP) }],
+    truncated: 0
+  };
+}
+function createExtensionsBundle(_context, options = {}) {
+  const store = createExtensionSnapshotStore();
+  const cwd = options.cwd ?? (() => process.cwd());
+  const build = (generation) => buildExtensionSnapshot({
+    cwd: cwd(),
+    generation,
+    ...options.now !== void 0 ? { now: options.now } : {},
+    ...options.listRecords !== void 0 ? { listRecords: options.listRecords } : {}
+  });
+  let inFlight = null;
+  const rejected = (reason, diagnostics) => ({
+    status: "rejected",
+    reason,
+    generation: store.current()?.generation ?? 0,
+    diagnostics
+  });
+  const extension = {
+    start() {
+      bindExtensionSnapshotStore(store);
+    },
+    stop() {
+      inFlight = null;
+      bindExtensionSnapshotStore(null);
+    }
+  };
+  const contract = {
+    list(cwd2, options2 = {}) {
+      return listInstalledExtensions(cwd2, options2);
+    },
+    discover(root) {
+      return discoverExtensionPackages(root);
+    },
+    install(root, options2 = {}) {
+      return installExtension(root, options2);
+    },
+    enable(id, options2 = {}) {
+      return enableExtension(id, options2);
+    },
+    disable(id, options2 = {}) {
+      return disableExtension(id, options2);
+    },
+    remove(id, options2 = {}) {
+      return removeExtension(id, options2);
+    },
+    resourceRoots(kind, requestedCwd) {
+      return enabledExtensionResourceRoots(kind, requestedCwd ?? cwd());
+    },
+    snapshot() {
+      return store.current();
+    },
+    generation() {
+      return store.current()?.generation ?? 0;
+    },
+    prepareReload() {
+      if (inFlight !== null) return rejected("reentrant", { entries: [], truncated: 0 });
+      const previous = store.current();
+      const generation = store.nextGeneration();
+      let snapshot;
+      try {
+        snapshot = build(generation);
+      } catch (error) {
+        return rejected("build-failed", failureDiagnostics(error));
+      }
+      const candidate = {
+        generation,
+        previousGeneration: previous?.generation ?? 0,
+        snapshot,
+        ...diffExtensionSnapshots(previous, snapshot),
+        // Identity on the committed reference covers every intervening
+        // publish; the in-flight check covers discard and double publish.
+        current: () => inFlight === candidate && store.current() === previous,
+        publish() {
+          store.publish(snapshot);
+          inFlight = null;
+        },
+        discard() {
+          if (inFlight === candidate) inFlight = null;
+        }
+      };
+      inFlight = candidate;
+      return { status: "prepared", candidate };
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/extensions/manifest.ts
+init_esm_shims();
+var ExtensionsManifest = {
+  name: "extensions",
+  dependsOn: ["config"]
+};
+
+// src/domains/extensions/index.ts
+var ExtensionsDomainModule = {
+  manifest: ExtensionsManifest,
+  createExtension: createExtensionsBundle
+};
+
+export {
+  EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP,
+  extensionSnapshotFor,
+  enabledExtensionResourceRoots,
+  ExtensionsDomainModule
+};
+//# sourceMappingURL=chunk-7DRAWPTZ.js.map