karajan-code 3.12.1 → 3.12.3

package/src/utils/templates-root.js

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isSea, getAsset } from "node:sea";
+import { getKarajanHome } from "./paths.js";
+
+// npm install / source tree: the real templates/ directory next to src/.
+const SOURCE_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+  "templates",
+);
+
+const INDEX_ASSET = "templates-index.json";
+
+/**
+ * Root directory of the built-in templates (KJC-BUG-0104).
+ *
+ * The SEA binary ships only the JS bundle — templates/ never travels as
+ * files, and `import.meta.dirname`-relative resolution lands on the
+ * binary's own directory (e.g. `$HOME/templates/skills` → ENOENT). In SEA
+ * builds the templates travel as SEA assets (see scripts/build-sea.mjs);
+ * they are extracted once per version into ~/.karajan/embedded-templates/
+ * and served from there, so every fs-based consumer keeps working.
+ */
+export function getTemplatesRoot() {
+  if (!isSeaRuntime()) return SOURCE_ROOT;
+  const index = JSON.parse(getAsset(INDEX_ASSET, "utf8"));
+  const destRoot = path.join(getKarajanHome(), "embedded-templates", index.version);
+  return extractEmbeddedTemplates({
+    destRoot,
+    files: index.files,
+    readAsset: (rel) => getAsset(`templates/${rel}`, "utf8"),
+  });
+}
+
+function isSeaRuntime() {
+  try {
+    return isSea();
+  } catch {
+    // isSea() unexpectedly threw ⇒ treat as npm / source tree, never block.
+    return false;
+  }
+}
+
+/**
+ * Extract the embedded template files into destRoot (idempotent: a
+ * .complete marker skips re-extraction). Exported for unit testing.
+ */
+export function extractEmbeddedTemplates({ destRoot, files, readAsset }) {
+  const marker = path.join(destRoot, ".complete");
+  if (fs.existsSync(marker)) return destRoot;
+  for (const rel of files) {
+    const dest = path.join(destRoot, rel);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, readAsset(rel));
+  }
+  fs.writeFileSync(marker, "");
+  return destRoot;
+}

package/src/utils/update-check.js

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { isSea } from "node:sea";
 import { getKarajanHome } from "./paths.js";
@@ -104,30 +105,46 @@ export async function printUpdateNotice(currentVersion) {
 }
 
 /**
- * Run the npm-channel self-update (`kj update`). Captures npm's output instead
- * of streaming it: a successful update shows only the progress + result line,
- * so npm's deprecation / allow-scripts / funding noise — build plumbing, not
- * actionable for whoever runs the command — never reaches the user. On failure
- * the captured stdout/stderr IS surfaced, so real errors (native build,
- * permissions) stay diagnosable — never a silent failure.
+ * Run the self-update (`kj update`), channel-aware (KJC-BUG-0106).
+ *
+ * npm channel: `npm install -g` with CAPTURED output — success shows only
+ * progress + result; npm's deprecation / allow-scripts / funding noise never
+ * reaches the user. On failure the captured output IS surfaced.
+ *
+ * sea channel (standalone binary): npm-installing would update a copy the
+ * PATH never resolves — the running binary stays old while `kj update`
+ * reports success. Instead the binary installer is re-run (downloaded to a
+ * temp file first, never piped from the network straight into a shell).
+ *
+ * Both channels end with a PATH probe: `kj --version` must report the new
+ * version, otherwise a stale copy shadows the update and the command fails
+ * LOUDLY naming the likely cause — never a silent "updated" that isn't.
  *
  * @param {Object} opts
  * @param {string} opts.currentVersion - version of the running kj
  * @param {(cmd: string, args: string[]) => Promise<{stdout: string, stderr: string}>} [opts.exec] - injectable runner (defaults to execa)
  * @param {Console} [opts.logger]
- * @returns {Promise<{ ok: boolean, alreadyLatest?: boolean, latest?: string }>}
+ * @param {"npm"|"sea"} [opts.channel] - injectable channel (defaults to detectInstallChannel())
+ * @param {typeof fetch} [opts.fetchFn] - injectable fetch (registry lookup + installer download)
+ * @returns {Promise<{ ok: boolean, alreadyLatest?: boolean, latest?: string, manual?: boolean }>}
  */
-export async function performSelfUpdate({ currentVersion, exec, logger = console } = {}) {
+export async function performSelfUpdate({ currentVersion, exec, logger = console, channel, fetchFn = fetch } = {}) {
   const run = exec || (async (cmd, args) => (await import("execa")).execa(cmd, args));
+  const ch = channel || detectInstallChannel();
   logger.log(`Current version: ${currentVersion}`);
   logger.log("Checking for updates...");
 
   let latest;
   try {
-    const { stdout } = await run("npm", ["view", PACKAGE_NAME, "version"]);
-    latest = stdout.trim();
+    // Registry over HTTP, not `npm view` — standalone-binary machines may
+    // not have npm at all.
+    const res = await fetchFn(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      headers: { Accept: "application/json" },
+    });
+    if (!res.ok) throw new Error(`registry responded ${res.status}`);
+    latest = (await res.json()).version;
   } catch (err) {
-    logger.error(`Update failed: ${err.shortMessage || err.message}`);
+    logger.error(`Update failed: could not check the registry (${err.message})`);
     return { ok: false };
   }
 
@@ -136,18 +153,64 @@ export async function performSelfUpdate({ currentVersion, exec, logger = console
     return { ok: true, alreadyLatest: true, latest };
   }
 
+  if (ch === "sea" && process.platform === "win32") {
+    // Executing a downloaded .ps1 from inside the binary is not supported
+    // yet — hand the user the exact command instead of half-updating.
+    logger.log(`Update available: ${currentVersion} → ${latest} (standalone binary).`);
+    logger.log(`${updateInstruction({ channel: "sea" })}`);
+    return { ok: true, latest, manual: true };
+  }
+
   logger.log(`Updating ${currentVersion} → ${latest}... (this can take a few minutes)`);
   try {
-    // No stdio:inherit — capture and drop npm's warnings on the success path.
-    await run("npm", ["install", "-g", `${PACKAGE_NAME}@latest`]);
-    logger.log(`Updated to ${latest}. Restart Claude to pick up the new MCP server.`);
-    return { ok: true, latest };
+    if (ch === "sea") {
+      // Re-run the binary installer: download to a temp file, then execute —
+      // never pipe the network straight into a shell.
+      const res = await fetchFn(INSTALL_SH_URL);
+      if (!res.ok) throw new Error(`installer download failed (${res.status})`);
+      const tmpScript = path.join(os.tmpdir(), `kj-install-${process.pid}.sh`);
+      await fs.writeFile(tmpScript, await res.text(), { mode: 0o700 });
+      try {
+        await run("sh", [tmpScript]);
+      } finally {
+        await fs.rm(tmpScript, { force: true });
+      }
+    } else {
+      // No stdio:inherit — capture and drop npm's warnings on the success path.
+      await run("npm", ["install", "-g", `${PACKAGE_NAME}@latest`]);
+    }
   } catch (err) {
     if (err.stdout) logger.error(err.stdout);
     if (err.stderr) logger.error(err.stderr);
     logger.error(`Update failed: ${err.shortMessage || err.message}`);
     return { ok: false };
   }
+
+  // The install succeeded — but is the kj the USER runs actually the new one?
+  const onPath = await verifyKjOnPath({ run, latest, logger });
+  if (!onPath) return { ok: false };
+  logger.log(`Updated to ${latest}. Restart Claude to pick up the new MCP server.`);
+  return { ok: true, latest };
+}
+
+/**
+ * Probe `kj --version` through the PATH and confirm it reports `latest`.
+ * A mismatch means a stale copy shadows the freshly installed one (e.g. a
+ * standalone binary in ~/.local/bin in front of the npm global prefix).
+ */
+async function verifyKjOnPath({ run, latest, logger }) {
+  let reported;
+  try {
+    const { stdout } = await run("kj", ["--version"]);
+    reported = String(stdout).trim();
+  } catch (err) {
+    logger.error(`Update installed ${latest}, but running \`kj --version\` failed: ${err.shortMessage || err.message}`);
+    return false;
+  }
+  if (reported.includes(latest)) return true;
+  logger.error(`Update installed ${latest}, but the \`kj\` on your PATH still reports ${reported}.`);
+  logger.error("A stale copy is shadowing the update. Check `which -a kj` and remove the old one, or update through the channel that owns the first entry.");
+  return false;
 }
 
 /** Simple semver compare: returns >0 if a > b, <0 if a < b, 0 if equal */

package/node_modules/@karajan/core/README.md

@@ -1,42 +0,0 @@
-# @karajan/core
-
-Shared modules for the Karajan Code CLI and `@karajan/hu-board`. Private
-workspace package — not published to npm.
-
-## Scope
-
-`@karajan/core` is the extraction destination for code that both the CLI
-package (`karajan-code`) and the HU Board package (`@karajan/hu-board`)
-need. Today it ships the atomic JSON writer; subsequent commits of
-KJC-TSK-0511 will land the shared paths, port-check, run-registry,
-process runner, plan validation, vector store, and plan/HU ops modules
-here.
-
-## Exports
-
-| Subpath | Module |
-| --- | --- |
-| `@karajan/core/atomic-write` | `writeJsonAtomic`, `writeJsonAtomicSync` |
-| `@karajan/core/shared-paths` | `SHARED_DIR_NAME`, `getSharedRoot`, `getSharedPlansDir`, `getSharedHuStoriesDir`, `isSharedPath` |
-| `@karajan/core/port-check` | `isPortAvailable`, `findAvailablePort` |
-| `@karajan/core/paths` | `resolveHome`, `getKarajanHome`, `getSessionRoot`, `getSonarComposePath`, `getOllamaComposePath`, `getWebperfDir`, `getRunsDir`, `getPromptsDir`, `__resetKjHomeWarningForTests` |
-| `@karajan/core/run-registry` | `runsDir`, `registerRun`, `unregisterRun`, `listActiveRuns` |
-| `@karajan/core/vec-store` | `dbPath`, `openVecStore`, `insertChunk`, `searchSimilar`, `searchBM25`, `projectSlug`, `deleteChunksBySource`, `findChunkByHash`, `getEmbeddingsByIds`, `getLastIndexedCommit`, `setLastIndexedCommit`, `countChunks` |
-| `@karajan/core/plan-id` | `generatePlanId`, `generateHuId`, `normaliseAlias` |
-| `@karajan/core/plan-hu-ops` | `addHu`, `removeHu`, `updateHu`, `updateHuStatus`, `setHuOutcome`, `setPlanOutcome`, `autoCertifyPendingHus`, `assertPlanRunnable`, `computePlanOutcome`, `certifyAllHus`, `reorderHus` |
-| `@karajan/core/plan-validation` | `validateBlockedByChange` |
-| `@karajan/core/process` | `runCommand` (execa wrapper with output streaming, silence/total timeouts, ENOENT enrichment) |
-| `@karajan/core/hu-snapshot` | `snapshotRefForHu`, `createHuSnapshot`, `hasHuSnapshot`, `restoreHuSnapshot`, `removeHuSnapshot` |
-| `@karajan/core/standby-store` | `persistStandby`, `loadStandby`, `listPendingStandby`, `markStandbyDone`, `acquireStandbyLock`, `buildStandbyState`, `standbyDir`, `standbyDoneDir` |
-| `@karajan/core/standby-scheduler` | `scheduleResume`, `cancelScheduled`, `reconcileAll`, `acquireStandbyLock`, `markStandbyDone`, `_resetScheduledForTests` |
-
-The root export (`@karajan/core`) re-exports everything via the barrel
-in `src/index.js`, but prefer the subpath form so the bundler can
-tree-shake unused modules.
-
-## Status
-
-KJC-TSK-0511 PR8 — `standby-store` + `standby-scheduler` extracted.
-With this PR `@karajan/hu-board` no longer reaches into `../../../src`
-from any static **or dynamic** import. PR9 will re-add
-`packages/hu-board` to the root `workspaces` array.

package/node_modules/@karajan/core/package.json

@@ -1,49 +0,0 @@
-{
-  "name": "@karajan/core",
-  "version": "0.1.0",
-  "description": "Shared modules for Karajan Code CLI and @karajan/hu-board (atomic-write, paths, RAG store, plan ops, process runner).",
-  "type": "module",
-  "private": true,
-  "engines": {
-    "node": ">=22.22.1"
-  },
-  "exports": {
-    "./atomic-write": "./src/atomic-write.js",
-    "./shared-paths": "./src/shared-paths.js",
-    "./port-check": "./src/port-check.js",
-    "./paths": "./src/paths.js",
-    "./run-registry": "./src/run-registry.js",
-    "./vec-store": "./src/vec-store.js",
-    "./plan-id": "./src/plan-id.js",
-    "./plan-hu-ops": "./src/plan-hu-ops.js",
-    "./plan-validation": "./src/plan-validation.js",
-    "./process": "./src/process.js",
-    "./hu-snapshot": "./src/hu-snapshot.js",
-    "./standby-store": "./src/standby-store.js",
-    "./standby-scheduler": "./src/standby-scheduler.js",
-    "./pricing": "./src/pricing/index.js",
-    "./cost": "./src/cost/index.js"
-  },
-  "scripts": {
-    "test": "vitest run"
-  },
-  "peerDependencies": {
-    "better-sqlite3": "^12.10.0",
-    "execa": "^9.6.0",
-    "sqlite-vec": "^0.1.9"
-  },
-  "peerDependenciesMeta": {
-    "better-sqlite3": {
-      "optional": true
-    },
-    "execa": {
-      "optional": true
-    },
-    "sqlite-vec": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "vitest": "^4.0.0"
-  }
-}

package/node_modules/@karajan/core/src/atomic-write.js

@@ -1,43 +0,0 @@
-// Atomic JSON writes for persistent state (resilience audit, Phase 2).
-//
-// A plain `writeFile(path, JSON.stringify(...))` truncates the live file
-// before the new content lands. If the process is killed mid-write
-// (SIGKILL, crash, power loss) the file is left truncated and the only
-// good copy is already gone — the plan / session / standby JSON
-// silently corrupts.
-//
-// write-temp + rename fixes it: `rename` is atomic on the same
-// filesystem, so a reader sees either the old file or the complete new
-// one, never a half-written one. The temp file sits next to the target
-// (same dir → same FS) and is uniquely named so concurrent writers do
-// not clobber each other's temp. A crash before the rename leaves an
-// orphan `.tmp` but never a corrupt target.
-
-import { writeFileSync, renameSync } from "node:fs";
-import { writeFile, rename } from "node:fs/promises";
-
-function tempPath(target) {
-  return `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-}
-
-/**
- * Atomically write `obj` as pretty JSON to `target` (synchronous).
- * @param {string} target - destination path; its directory must exist
- * @param {unknown} obj
- */
-export function writeJsonAtomicSync(target, obj) {
-  const tmp = tempPath(target);
-  writeFileSync(tmp, JSON.stringify(obj, null, 2), "utf-8");
-  renameSync(tmp, target);
-}
-
-/**
- * Atomically write `obj` as pretty JSON to `target` (async).
- * @param {string} target - destination path; its directory must exist
- * @param {unknown} obj
- */
-export async function writeJsonAtomic(target, obj) {
-  const tmp = tempPath(target);
-  await writeFile(tmp, JSON.stringify(obj, null, 2), "utf-8");
-  await rename(tmp, target);
-}

package/node_modules/@karajan/core/src/cost/index.js

@@ -1,102 +0,0 @@
-/**
- * Cost aggregator (Cost B — KJC-TSK-0513).
- *
- * Turns a list of token-usage events emitted by the orchestrator into
- * a USD breakdown for a single run / HU. The pipeline calls this once
- * when a HU finishes; the result is what Cost C will persist in
- * board.db and Cost E will expose as `/api/projects/:id/cost`.
- *
- * Inputs are deliberately permissive: any extra field on an event is
- * ignored. We only require `role`, `model`, `tokensIn`, `tokensOut`.
- *
- * Unknown models do NOT throw. Their token counts accumulate into
- * `unknownModelTokens` and the function returns a flag so the caller
- * can surface it in the UI (orange badge instead of `$X.XXXX`).
- */
-
-import { getModelPricing } from "../pricing/index.js";
-
-const DEFAULT_ROUND_DECIMALS = 4;
-
-function round(n, decimals = DEFAULT_ROUND_DECIMALS) {
-  const f = 10 ** decimals;
-  return Math.round(n * f) / f;
-}
-
-function priceTokens(pricing, tokensIn, tokensOut) {
-  const inUsd = (tokensIn / 1_000_000) * pricing.inputPerMTok;
-  const outUsd = (tokensOut / 1_000_000) * pricing.outputPerMTok;
-  return inUsd + outUsd;
-}
-
-/**
- * Aggregate cost of a run.
- *
- * @param {object} args
- * @param {Array<{role:string, model:string, tokensIn:number, tokensOut:number}>} args.events
- * @param {(level:"warn"|"info", msg:string, ctx?:object)=>void} [args.logger]
- *        Optional structured logger. When a model is unknown we call
- *        logger("warn", ...) so the user sees it once per run.
- * @returns {{
- *   totalUsd:number,
- *   byRole:Record<string,number>,
- *   byModel:Record<string,number>,
- *   unknownModelTokens:{ tokensIn:number, tokensOut:number, models:string[] },
- *   hasUnknown:boolean,
- *   currency:string
- * }}
- */
-export function aggregateRunCost({ events, logger } = {}) {
-  const safeEvents = Array.isArray(events) ? events : [];
-  const byRole = {};
-  const byModel = {};
-  const unknownModels = new Set();
-  let totalUsd = 0;
-  let unknownIn = 0;
-  let unknownOut = 0;
-
-  for (const ev of safeEvents) {
-    if (!ev || typeof ev !== "object") continue;
-    const role = typeof ev.role === "string" && ev.role.length > 0 ? ev.role : "unknown";
-    const model = typeof ev.model === "string" ? ev.model : "";
-    const tokensIn = Number.isFinite(ev.tokensIn) ? ev.tokensIn : 0;
-    const tokensOut = Number.isFinite(ev.tokensOut) ? ev.tokensOut : 0;
-    if (tokensIn === 0 && tokensOut === 0) continue;
-
-    const pricing = getModelPricing(model);
-    if (!pricing) {
-      unknownIn += tokensIn;
-      unknownOut += tokensOut;
-      if (model.length > 0) unknownModels.add(model);
-      if (typeof logger === "function") {
-        logger("warn", "cost-aggregator: unknown model pricing", { model, role, tokensIn, tokensOut });
-      }
-      continue;
-    }
-
-    const cost = priceTokens(pricing, tokensIn, tokensOut);
-    totalUsd += cost;
-    byRole[role] = (byRole[role] || 0) + cost;
-    byModel[model] = (byModel[model] || 0) + cost;
-  }
-
-  const roundedByRole = Object.fromEntries(
-    Object.entries(byRole).map(([k, v]) => [k, round(v)])
-  );
-  const roundedByModel = Object.fromEntries(
-    Object.entries(byModel).map(([k, v]) => [k, round(v)])
-  );
-
-  return {
-    totalUsd: round(totalUsd),
-    byRole: roundedByRole,
-    byModel: roundedByModel,
-    unknownModelTokens: {
-      tokensIn: unknownIn,
-      tokensOut: unknownOut,
-      models: Array.from(unknownModels).sort(),
-    },
-    hasUnknown: unknownIn > 0 || unknownOut > 0,
-    currency: "USD",
-  };
-}

package/node_modules/@karajan/core/src/hu-snapshot.js

@@ -1,105 +0,0 @@
-// KJC-TSK-0408: snapshots de ficheros por HU para soportar Undo.
-//
-// Antes de ejecutar una HU, guardamos un ref git apuntando al HEAD
-// actual (`refs/kj-snapshots/<huId>`). Si el usuario hace Undo después,
-// hacemos `git reset --hard <ref>` para volver al estado pre-run.
-//
-// Por qué refs en lugar de stash/tarball:
-//   - Refs son objetos git nativos. No mueven blobs (todos compartidos
-//     con HEAD), así que crear el snapshot es O(1).
-//   - El snapshot persiste a través de checkouts y rebases.
-//   - Si el ref ya apunta al SHA correcto, restore es no-op.
-//
-// El runner es inyectable para que los tests no necesiten un repo git real.
-
-import { runCommand } from "./process.js";
-
-const REF_PREFIX = "refs/kj-snapshots/";
-
-/**
- * Sanitiza un huId para uso como nombre de ref. Git rechaza:
- *   - `..`, `:`, `~`, `^`, `?`, `*`, `[`, `\`, espacios, control chars
- *   - segmentos que empiecen por `.` o terminen en `.lock`
- * Reemplazamos cualquier no [a-zA-Z0-9_-] por `_`.
- */
-export function snapshotRefForHu(huId) {
-  if (!huId) throw new Error("huId requerido");
-  const safe = String(huId).replaceAll(/[^a-zA-Z0-9_-]/g, "_").slice(0, 80);
-  return REF_PREFIX + safe;
-}
-
-async function defaultRunner(args, opts = {}) {
-  return runCommand("git", args, opts);
-}
-
-/**
- * Crea (o actualiza) el ref del snapshot apuntando al HEAD actual.
- *
- * @param {object} args
- * @param {string} args.projectDir
- * @param {string} args.huId
- * @param {Function} [args.runner] - sustituye git CLI en tests
- * @returns {Promise<{ ok: boolean, ref?: string, sha?: string, error?: string }>}
- */
-export async function createHuSnapshot({ projectDir, huId, runner }) {
-  const run = runner || defaultRunner;
-  const ref = snapshotRefForHu(huId);
-  const head = await run(["rev-parse", "HEAD"], { cwd: projectDir });
-  if (head.exitCode !== 0) {
-    return { ok: false, error: `rev-parse HEAD failed: ${(head.stderr || "").trim()}` };
-  }
-  const sha = (head.stdout || "").trim();
-  if (!sha) return { ok: false, error: "HEAD vacío" };
-  const update = await run(["update-ref", ref, sha], { cwd: projectDir });
-  if (update.exitCode !== 0) {
-    return { ok: false, error: `update-ref falló: ${(update.stderr || "").trim()}` };
-  }
-  return { ok: true, ref, sha };
-}
-
-/**
- * @param {object} args
- * @param {string} args.projectDir
- * @param {string} args.huId
- * @param {Function} [args.runner]
- * @returns {Promise<{ ok: boolean, sha?: string }>}
- */
-export async function hasHuSnapshot({ projectDir, huId, runner }) {
-  const run = runner || defaultRunner;
-  const ref = snapshotRefForHu(huId);
-  const r = await run(["rev-parse", "--verify", "--quiet", ref], { cwd: projectDir });
-  if (r.exitCode !== 0) return { ok: false };
-  return { ok: true, sha: (r.stdout || "").trim() };
-}
-
-/**
- * Restaura el workspace al snapshot. DESTRUCTIVO: hace `git reset --hard`,
- * lo que descarta cambios no committeados. Caller debe avisar al usuario.
- *
- * @returns {Promise<{ ok: boolean, sha?: string, error?: string }>}
- */
-export async function restoreHuSnapshot({ projectDir, huId, runner }) {
-  const run = runner || defaultRunner;
-  const ref = snapshotRefForHu(huId);
-  const has = await hasHuSnapshot({ projectDir, huId, runner: run });
-  if (!has.ok) return { ok: false, error: `snapshot no encontrado para HU ${huId}` };
-  const r = await run(["reset", "--hard", ref], { cwd: projectDir });
-  if (r.exitCode !== 0) {
-    return { ok: false, error: `reset --hard falló: ${(r.stderr || "").trim()}` };
-  }
-  return { ok: true, sha: has.sha };
-}
-
-/**
- * Borra el ref del snapshot. Idempotente: si no existe, devuelve ok:true.
- */
-export async function removeHuSnapshot({ projectDir, huId, runner }) {
-  const run = runner || defaultRunner;
-  const ref = snapshotRefForHu(huId);
-  const r = await run(["update-ref", "-d", ref], { cwd: projectDir });
-  // git update-ref -d devuelve 0 incluso si el ref no existía.
-  if (r.exitCode !== 0) {
-    return { ok: false, error: `update-ref -d falló: ${(r.stderr || "").trim()}` };
-  }
-  return { ok: true };
-}

package/node_modules/@karajan/core/src/index.js

@@ -1,18 +0,0 @@
-// Barrel export for @karajan/core. Subpath imports
-// (e.g. `@karajan/core/atomic-write`) are the preferred shape — this
-// barrel only exists so a single `import { writeJsonAtomic } from
-// "@karajan/core"` keeps working for callers that want the whole API.
-
-export * from "./atomic-write.js";
-export * from "./shared-paths.js";
-export * from "./port-check.js";
-export * from "./paths.js";
-export * from "./run-registry.js";
-export * from "./vec-store.js";
-export * from "./plan-id.js";
-export * from "./plan-hu-ops.js";
-export * from "./plan-validation.js";
-export * from "./process.js";
-export * from "./hu-snapshot.js";
-export * from "./standby-store.js";
-export * from "./standby-scheduler.js";