akm-cli 0.8.6 → 0.8.14

package/dist/tasks/backends/launchd.js

@@ -25,11 +25,11 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import launchdTemplate from "../../assets/backends/launchd-template.xml" with { type: "text" };
-import { ConfigError } from "../../core/errors";
-import { getTaskLogDir } from "../../core/paths";
-import { resolveAkmInvocation } from "../resolveAkmBin";
-import { parseSchedule, translateToLaunchd } from "../schedule";
-import { escapeXml, spawnCommand } from "./exec-utils";
+import { ConfigError } from "../../core/errors.js";
+import { getTaskLogDir } from "../../core/paths.js";
+import { resolveAkmInvocation } from "../resolveAkmBin.js";
+import { parseSchedule, translateToLaunchd } from "../schedule.js";
+import { escapeXml, nodeExec, nodeFs } from "./exec-utils.js";
 export const LAUNCHD_LABEL_PREFIX = "com.akm.task.";
 export function LAUNCHD_BACKEND(options = {}) {
     const exec = options.exec ?? defaultLaunchdExec();
@@ -152,9 +152,7 @@ function defaultAgentsDir() {
 }
 function defaultLaunchdExec() {
     return {
-        run(args) {
-            return spawnCommand(args);
-        },
+        ...nodeExec(),
         uid() {
             const fn = process.getuid;
             return typeof fn === "function" ? fn.call(process) : 0;
@@ -163,15 +161,10 @@ function defaultLaunchdExec() {
 }
 function defaultLaunchdFs() {
     return {
-        writeFile(file, content) {
-            fs.writeFileSync(file, content, { encoding: "utf8" });
-        },
+        ...nodeFs(),
         removeFile(file) {
             fs.rmSync(file, { force: true });
         },
-        ensureDir(dir) {
-            fs.mkdirSync(dir, { recursive: true });
-        },
         list(dir) {
             try {
                 return fs.readdirSync(dir);

package/dist/tasks/backends/schtasks.js

@@ -33,11 +33,11 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import schtasksTemplate from "../../assets/backends/schtasks-template.xml" with { type: "text" };
-import { ConfigError } from "../../core/errors";
-import { getTaskLogDir } from "../../core/paths";
-import { resolveAkmInvocation } from "../resolveAkmBin";
-import { parseSchedule, translateToSchtasks } from "../schedule";
-import { escapeXml, spawnCommand } from "./exec-utils";
+import { ConfigError } from "../../core/errors.js";
+import { getTaskLogDir } from "../../core/paths.js";
+import { resolveAkmInvocation } from "../resolveAkmBin.js";
+import { parseSchedule, translateToSchtasks } from "../schedule.js";
+import { escapeXml, nodeExec, nodeFs } from "./exec-utils.js";
 export const DEFAULT_FOLDER_PREFIX = "\\akm\\";
 export function SCHTASKS_BACKEND(options = {}) {
     const exec = options.exec ?? defaultSchtasksExec();
@@ -186,17 +186,11 @@ function quoteArg(s) {
     return `"${s.replace(/"/g, '\\"')}"`;
 }
 function defaultSchtasksExec() {
-    return {
-        run(args) {
-            return spawnCommand(args);
-        },
-    };
+    return nodeExec();
 }
 function defaultSchtasksFs() {
     return {
-        writeFile(file, content) {
-            fs.writeFileSync(file, content, { encoding: "utf8" });
-        },
+        ...nodeFs(),
         removeFile(file) {
             try {
                 fs.rmSync(file, { force: true });
@@ -205,9 +199,6 @@ function defaultSchtasksFs() {
                 /* ignore */
             }
         },
-        ensureDir(dir) {
-            fs.mkdirSync(dir, { recursive: true });
-        },
         tmpdir() {
             return os.tmpdir();
         },

package/dist/tasks/embedded.js

@@ -0,0 +1,71 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Embedded core task templates.
+ *
+ * A curated set of read-only YAML task templates ships inside the akm binary
+ * under `src/assets/tasks/core/`. They are resolved at runtime via
+ * `import.meta.dir` (mirroring `SKELETON_DIR` in
+ * src/commands/stash-skeleton.ts) and are NOT written to any stash at
+ * install/init time — the `akm setup` wizard copies a template into the
+ * primary stash only when the user opts in (copy-on-enable).
+ *
+ * Each entry exposes the parsed `command`, `schedule`, and `description`
+ * alongside the raw `yaml`, so the wizard can both render a choice and write
+ * the file verbatim (with an optional schedule edit applied).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { parse as yamlParse } from "yaml";
+import { getDirname } from "../runtime.js";
+/** Directory holding the bundled core task templates. */
+const CORE_TASKS_DIR = path.join(getDirname(import.meta.url), "../assets/tasks/core");
+/**
+ * Enumerate the embedded core task templates from the bundled assets
+ * directory. Sorted by id for deterministic ordering. Returns an empty array
+ * if the directory is missing (defensive — a build without assets should not
+ * crash the wizard).
+ */
+export function listEmbeddedTasks() {
+    let entries;
+    try {
+        entries = fs.readdirSync(CORE_TASKS_DIR);
+    }
+    catch {
+        return [];
+    }
+    const tasks = [];
+    for (const entry of entries.sort()) {
+        if (!entry.endsWith(".yml"))
+            continue;
+        const id = entry.slice(0, -4);
+        const filePath = path.join(CORE_TASKS_DIR, entry);
+        let yaml;
+        try {
+            yaml = fs.readFileSync(filePath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        let doc;
+        try {
+            doc = yamlParse(yaml) ?? {};
+        }
+        catch {
+            continue;
+        }
+        const command = typeof doc.command === "string" ? doc.command : "";
+        const schedule = typeof doc.schedule === "string" ? doc.schedule : "";
+        const description = typeof doc.description === "string" ? doc.description : "";
+        tasks.push({
+            id,
+            label: `core/${id}`,
+            command,
+            schedule,
+            description,
+            yaml,
+        });
+    }
+    return tasks;
+}

package/dist/tasks/parser.js

@@ -35,8 +35,8 @@
  */
 import path from "node:path";
 import { parse as parseYaml } from "yaml";
-import { UsageError } from "../core/errors";
-import { TASK_SCHEMA_VERSION } from "./schema";
+import { UsageError } from "../core/errors.js";
+import { TASK_SCHEMA_VERSION } from "./schema.js";
 export function parseTaskDocument(input) {
     const { yaml, filePath, id } = input;
     let data;

package/dist/tasks/resolveAkmBin.js

@@ -24,7 +24,7 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { ConfigError } from "../core/errors";
+import { ConfigError } from "../core/errors.js";
 export function resolveAkmInvocation(options = {}) {
     const env = options.env ?? process.env;
     const override = env.AKM_BIN?.trim();

package/dist/tasks/runner.js

@@ -16,7 +16,9 @@
  *   4. Dispatch by target kind:
  *        • workflow → `startWorkflowRun(ref, params)`
  *        • prompt   → `runAgent(profile, prompt, { stdio: "captured" })`
- *   5. Capture stdout / stderr to `<cacheDir>/tasks/logs/<id>/<ts>.log`.
+ *   5. Capture stdout / stderr as structured rows in logs.db (task_logs) and,
+ *      transitionally, as a flat text tail at `<cacheDir>/tasks/logs/<id>/<ts>.log`
+ *      (see docs/technical/logs-audit.md).
  *   6. Write a history row to state.db task_history table.
  *
  * Returns a structured result so the CLI handler can shape it for `output()`
@@ -24,19 +26,22 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { parseAssetRef } from "../core/asset-ref";
-import { resolveStashDir } from "../core/common";
-import { loadConfig } from "../core/config";
-import { NotFoundError, rethrowIfTestIsolationError } from "../core/errors";
-import { getTaskLogDir } from "../core/paths";
-import { getTaskHistory, openStateDatabase, queryTaskHistory, upsertTaskHistory } from "../core/state-db";
-import { error } from "../core/warn";
-import { requireAgentProfile, runAgent } from "../integrations/agent";
-import { resolveProcessAgentProfile } from "../integrations/agent/config";
-import { resolveRunner } from "../integrations/agent/runner";
-import { resolveAssetPath } from "../sources/resolve";
-import { startWorkflowRun } from "../workflows/runs";
-import { parseTaskDocument } from "./parser";
+import { assertNever } from "../core/assert.js";
+import { parseAssetRef } from "../core/asset/asset-ref.js";
+import { resolveStashDir } from "../core/common.js";
+import { loadConfig } from "../core/config/config.js";
+import { NotFoundError, rethrowIfTestIsolationError } from "../core/errors.js";
+import { buildTaskRunId, insertTaskLogLines, openLogsDatabase, } from "../core/logs-db.js";
+import { getTaskLogDir } from "../core/paths.js";
+import { getTaskHistory, openStateDatabase, queryTaskHistory, upsertTaskHistory } from "../core/state-db.js";
+import { error } from "../core/warn.js";
+import { requireAgentProfile, runAgent } from "../integrations/agent/index.js";
+import { resolveProcessAgentProfile } from "../integrations/agent/config.js";
+import { resolveRunner } from "../integrations/agent/runner.js";
+import { spawn } from "../runtime.js";
+import { resolveAssetPath } from "../sources/resolve.js";
+import { startWorkflowRun } from "../workflows/runtime/runs.js";
+import { parseTaskDocument } from "./parser.js";
 export async function runTask(id, options = {}) {
     const stashDir = options.stashDir ?? resolveStashDir();
     const runAgentImpl = options.runAgentImpl ?? runAgent;
@@ -68,7 +73,15 @@ export async function runTask(id, options = {}) {
             log: logPath,
             target: disabledTarget,
         };
-        fs.writeFileSync(logPath, `[akm tasks] task "${id}" is disabled — skipping run.\n`);
+        const disabledLine = `[akm tasks] task "${id}" is disabled — skipping run.`;
+        persistRunLog({
+            taskId: id,
+            startedAtIso: startedIso,
+            finishedAtIso: result.finishedAt,
+            logPath,
+            fileText: `${disabledLine}\n`,
+            dbLines: [{ line: disabledLine }],
+        });
         appendHistory(result);
         return result;
     }
@@ -106,12 +119,14 @@ async function runCommandTask(input) {
         throw new Error("invariant: command target");
     const { cmd } = task.target;
     const timeoutMs = task.timeoutMs !== undefined ? task.timeoutMs : null;
-    const logLines = [`[akm tasks] task=${task.id} kind=command cmd=${cmd.join(" ")}`];
+    const header = `[akm tasks] task=${task.id} kind=command cmd=${cmd.join(" ")}`;
+    const logLines = [header];
+    const dbLines = [{ line: header }];
     let stdout = "";
     let stderr = "";
     let exitCode = null;
     try {
-        const proc = Bun.spawn(cmd, {
+        const proc = spawn(cmd, {
             stdin: "ignore",
             stdout: "pipe",
             stderr: "pipe",
@@ -142,24 +157,36 @@ async function runCommandTask(input) {
         exitCode = proc.exitCode ?? (timedOut ? 143 : 1);
         if (timedOut) {
             logLines.push(`timed_out=true timeout_ms=${timeoutMs}`);
+            dbLines.push({ level: "error", line: `timed_out=true timeout_ms=${timeoutMs}` });
         }
         logLines.push(`exit_code=${exitCode}`);
+        dbLines.push({ level: exitCode === 0 ? "info" : "error", line: `exit_code=${exitCode}` });
         if (stdout) {
             logLines.push("--- stdout ---");
             logLines.push(stdout);
+            dbLines.push(...streamLines(stdout, "stdout", "info"));
         }
         if (stderr) {
             logLines.push("--- stderr ---");
             logLines.push(stderr);
+            dbLines.push(...streamLines(stderr, "stderr", "error"));
         }
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
         logLines.push(`spawn_error=${msg}`);
+        dbLines.push({ level: "error", line: `spawn_error=${msg}` });
         exitCode = 1;
     }
-    fs.writeFileSync(logPath, `${logLines.join("\n")}\n`);
     const finishedAt = now();
+    persistRunLog({
+        taskId: task.id,
+        startedAtIso: startedAt.toISOString(),
+        finishedAtIso: finishedAt.toISOString(),
+        logPath,
+        fileText: `${logLines.join("\n")}\n`,
+        dbLines,
+    });
     const status = exitCode === 0 ? "completed" : "failed";
     const result = {
         id: task.id,
@@ -194,7 +221,14 @@ async function runWorkflowTask(input) {
     const finishedAt = now();
     const status = error ? "failed" : mapWorkflowStatus(detail?.run.status);
     const log = renderWorkflowLog({ task, detail, error });
-    fs.writeFileSync(logPath, log);
+    persistRunLog({
+        taskId: task.id,
+        startedAtIso: startedAt.toISOString(),
+        finishedAtIso: finishedAt.toISOString(),
+        logPath,
+        fileText: log.fileText,
+        dbLines: log.dbLines,
+    });
     const result = {
         id: task.id,
         status,
@@ -222,8 +256,19 @@ async function runWorkflowTask(input) {
  * returns (multi-step workflows pause for user input); recording them as
  * "completed" would be misleading. We preserve "active" as a first-class
  * task status with exit code 0 — the OS scheduler treats it as success.
+ *
+ * The parameter is typed as the runtime's `WorkflowRunStatus` union (plus the
+ * `undefined` that `detail?.run.status` can produce when no detail is present).
+ * Every union member is handled explicitly and the `default` arm calls
+ * `assertNever`, so adding a new `WorkflowRunStatus` variant without mapping it
+ * here is a *compile* error rather than silently collapsing to "completed".
+ * The previous silent `default: "completed"` is preserved only for the
+ * `undefined` (no-detail) case, which is handled up front.
  */
 function mapWorkflowStatus(status) {
+    // No run detail → treat as completed (unchanged from the prior silent default).
+    if (status === undefined)
+        return "completed";
     switch (status) {
         case "completed":
         case "blocked":
@@ -231,20 +276,21 @@ function mapWorkflowStatus(status) {
         case "active":
             return status;
         default:
-            return "completed";
+            return assertNever(status, "mapWorkflowStatus");
     }
 }
 function renderWorkflowLog(input) {
-    const lines = [];
-    lines.push(`[akm tasks] task=${input.task.id} kind=workflow ref=${input.task.target.ref}`);
+    const dbLines = [
+        { line: `[akm tasks] task=${input.task.id} kind=workflow ref=${input.task.target.ref}` },
+    ];
     if (input.detail) {
-        lines.push(`run_id=${input.detail.run.id} status=${input.detail.run.status}`);
-        lines.push(`workflow_title=${input.detail.run.workflowTitle}`);
+        dbLines.push({ line: `run_id=${input.detail.run.id} status=${input.detail.run.status}` });
+        dbLines.push({ line: `workflow_title=${input.detail.run.workflowTitle}` });
     }
     if (input.error) {
-        lines.push(`error=${input.error.message}`);
+        dbLines.push({ level: "error", line: `error=${input.error.message}` });
     }
-    return `${lines.join("\n")}\n`;
+    return { fileText: `${dbLines.map((entry) => entry.line).join("\n")}\n`, dbLines };
 }
 // ── prompt target ───────────────────────────────────────────────────────────
 async function runPromptTask(input) {
@@ -308,7 +354,14 @@ async function runPromptTask(input) {
     });
     const finishedAt = now();
     const log = renderPromptLog({ task, profileName: profile.name, result });
-    fs.writeFileSync(logPath, log);
+    persistRunLog({
+        taskId: task.id,
+        startedAtIso: startedAt.toISOString(),
+        finishedAtIso: finishedAt.toISOString(),
+        logPath,
+        fileText: log.fileText,
+        dbLines: log.dbLines,
+    });
     const status = result.ok ? "completed" : "failed";
     const out = {
         id: task.id,
@@ -346,20 +399,63 @@ async function resolvePromptText(task, stashDir) {
 }
 function renderPromptLog(input) {
     const lines = [];
-    lines.push(`[akm tasks] task=${input.task.id} kind=prompt profile=${input.profileName}`);
-    lines.push(`ok=${input.result.ok} exit_code=${input.result.exitCode ?? "null"} duration_ms=${input.result.durationMs}`);
+    const dbLines = [];
+    const header = `[akm tasks] task=${input.task.id} kind=prompt profile=${input.profileName}`;
+    const summary = `ok=${input.result.ok} exit_code=${input.result.exitCode ?? "null"} duration_ms=${input.result.durationMs}`;
+    lines.push(header, summary);
+    dbLines.push({ line: header }, { level: input.result.ok ? "info" : "error", line: summary });
     if (!input.result.ok) {
-        lines.push(`reason=${input.result.reason ?? ""} error=${input.result.error ?? ""}`);
+        const failure = `reason=${input.result.reason ?? ""} error=${input.result.error ?? ""}`;
+        lines.push(failure);
+        dbLines.push({ level: "error", line: failure });
     }
     if (input.result.stdout) {
         lines.push("--- agent stdout ---");
         lines.push(input.result.stdout);
+        dbLines.push(...streamLines(input.result.stdout, "stdout", "info"));
     }
     if (input.result.stderr) {
         lines.push("--- agent stderr ---");
         lines.push(input.result.stderr);
+        dbLines.push(...streamLines(input.result.stderr, "stderr", "error"));
+    }
+    return { fileText: `${lines.join("\n")}\n`, dbLines };
+}
+/** Split captured pipe output into per-line logs.db rows (blank lines dropped). */
+function streamLines(text, stream, level) {
+    return text
+        .split("\n")
+        .filter((line) => line.length > 0)
+        .map((line) => ({ stream, level, line }));
+}
+/**
+ * Persist a finished run's log: the flat text file (so `log_path` in
+ * task_history keeps resolving for humans and older consumers) plus
+ * structured rows in logs.db keyed by `buildTaskRunId(taskId, startedAt)`.
+ *
+ * The DB write is best-effort, mirroring {@link appendHistory}: an unwritable
+ * logs.db must never fail a task run.
+ */
+function persistRunLog(input) {
+    fs.writeFileSync(input.logPath, input.fileText);
+    try {
+        const db = openLogsDatabase();
+        try {
+            insertTaskLogLines(db, {
+                taskId: input.taskId,
+                runId: buildTaskRunId(input.taskId, input.startedAtIso),
+                ts: input.finishedAtIso,
+                lines: input.dbLines,
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        error(`[akm] task log DB write failed: ${String(err)}`);
     }
-    return `${lines.join("\n")}\n`;
 }
 // ── history ─────────────────────────────────────────────────────────────────
 function appendHistory(result) {

package/dist/tasks/schedule.js

@@ -26,7 +26,7 @@
  * Linux may fail to translate when copied to macOS/Windows. `tasks sync`
  * re-validates against the local backend and surfaces any incompatibility.
  */
-import { UsageError } from "../core/errors";
+import { UsageError } from "../core/errors.js";
 const ALIAS_TO_CRON = {
     "@hourly": "0 * * * *",
     "@daily": "0 0 * * *",

package/dist/tasks/validator.js

@@ -16,13 +16,13 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { parseAssetRef } from "../core/asset-ref";
-import { resolveStashDir } from "../core/common";
-import { loadConfig } from "../core/config";
-import { NotFoundError } from "../core/errors";
-import { requireAgentProfile } from "../integrations/agent";
-import { resolveAssetPath } from "../sources/resolve";
-import { parseSchedule } from "./schedule";
+import { parseAssetRef } from "../core/asset/asset-ref.js";
+import { resolveStashDir } from "../core/common.js";
+import { loadConfig } from "../core/config/config.js";
+import { NotFoundError } from "../core/errors.js";
+import { requireAgentProfile } from "../integrations/agent/index.js";
+import { resolveAssetPath } from "../sources/resolve.js";
+import { parseSchedule } from "./schedule.js";
 export async function validateTaskDocument(task, options) {
     // Schedule must parse and translate.
     parseSchedule(task.schedule, options.backend);

package/dist/text-import-hook.mjs

@@ -0,0 +1,51 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// Node ESM loader hook: support `import x from "./foo.md" with { type: "text" }`.
+//
+// Bun has a built-in text loader; Node does not (it only understands
+// `type: "json"`). akm embeds prompt/template assets via `with { type: "text" }`
+// imports that are statically hoisted into the module graph, so Node fails at
+// load time with ERR_UNKNOWN_FILE_EXTENSION / unsupported import attribute
+// before any command runs. This hook makes Node treat those imports as a module
+// whose default export is the file's UTF-8 contents — byte-identical to Bun's
+// text loader. It is ONLY registered on the Node entry path (see cli-node.mjs);
+// Bun never loads it, so the Bun runtime is untouched.
+
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+const TEXT_EXTENSIONS = new Set([".md", ".xml", ".txt", ".sql"]);
+
+function isTextImport(url, importAttributes) {
+  if (importAttributes && importAttributes.type === "text") return true;
+  const i = url.lastIndexOf(".");
+  if (i === -1) return false;
+  return TEXT_EXTENSIONS.has(url.slice(i).toLowerCase().split("?")[0]);
+}
+
+export async function load(url, context, nextLoad) {
+  if (url.startsWith("file:") && isTextImport(url, context.importAttributes)) {
+    const text = await readFile(fileURLToPath(url), "utf8");
+    return {
+      format: "module",
+      shortCircuit: true,
+      source: `export default ${JSON.stringify(text)};`,
+    };
+  }
+  return nextLoad(url, context);
+}
+
+// Node validates import attributes against the resolved format and rejects an
+// unknown `type: "text"` during resolution. Strip the attribute here so our
+// `load` hook (above) can take over; the assertion has already served its
+// purpose of routing to text handling.
+export async function resolve(specifier, context, nextResolve) {
+  const result = await nextResolve(specifier, context);
+  if (result.importAttributes && result.importAttributes.type === "text") {
+    const { type, ...rest } = result.importAttributes;
+    return { ...result, importAttributes: rest };
+  }
+  return result;
+}

package/dist/version.js

@@ -3,13 +3,14 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
+import { getDirname } from "./runtime.js";
 // Version: prefer compile-time define, then package.json, then fallback
 export const pkgVersion = (() => {
     // Injected at compile time via `bun build --define`
     if (typeof AKM_VERSION !== "undefined")
         return AKM_VERSION;
     try {
-        const pkgPath = path.resolve(import.meta.dir ?? __dirname, "../package.json");
+        const pkgPath = path.resolve(getDirname(import.meta.url), "../package.json");
         if (fs.existsSync(pkgPath)) {
             const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
             if (typeof pkg.version === "string")

package/dist/wiki/wiki.js

@@ -45,13 +45,13 @@ import fs from "node:fs";
 import path from "node:path";
 import { parse as yamlParse } from "yaml";
 import ingestWorkflowTemplate from "../assets/wiki/ingest-workflow-template.md" with { type: "text" };
-import { akmSearch } from "../commands/search";
-import { isWithin, todayIso } from "../core/common";
-import { getSources, loadUserConfig, saveConfig } from "../core/config";
-import { NotFoundError, UsageError } from "../core/errors";
-import { parseFrontmatter, parseFrontmatterBlock } from "../core/frontmatter";
-import { resolveSourceEntries } from "../indexer/search-source";
-import { buildIndexMd, buildLogMd, buildSchemaMd } from "./wiki-templates";
+import { akmSearch } from "../commands/read/search.js";
+import { parseFrontmatter, parseFrontmatterBlock } from "../core/asset/frontmatter.js";
+import { isWithin, todayIso } from "../core/common.js";
+import { getSources, loadUserConfig, saveConfig } from "../core/config/config.js";
+import { NotFoundError, UsageError } from "../core/errors.js";
+import { resolveSourceEntries } from "../indexer/search/search-source.js";
+import { buildIndexMd, buildLogMd, buildSchemaMd } from "./wiki-templates.js";
 // ── Constants ───────────────────────────────────────────────────────────────
 export const WIKIS_SUBDIR = "wikis";
 export const SCHEMA_MD = "schema.md";

package/dist/workflows/{authoring.js → authoring/authoring.js}

@@ -3,12 +3,12 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
-import workflowTemplate from "../assets/workflows/workflow-template.md" with { type: "text" };
-import { resolveAssetPathFromName } from "../core/asset-spec";
-import { isWithin, resolveStashDir } from "../core/common";
-import { UsageError } from "../core/errors";
-import { warn } from "../core/warn";
-import { parseWorkflow } from "./parser";
+import workflowTemplate from "../../assets/workflows/workflow-template.md" with { type: "text" };
+import { resolveAssetPathFromName } from "../../core/asset/asset-spec.js";
+import { isWithin, resolveStashDir } from "../../core/common.js";
+import { UsageError } from "../../core/errors.js";
+import { warn } from "../../core/warn.js";
+import { parseWorkflow } from "../parser.js";
 const DEFAULT_WORKFLOW_TEMPLATE = renderWorkflowTemplate({
     title: "Example Workflow",
     firstStepTitle: "First Step",

package/dist/workflows/{scope-key.js → authoring/scope-key.js}

@@ -4,7 +4,7 @@
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { isWithin, resolveStashDir, safeRealpath, toPosix } from "../core/common";
+import { isWithin, resolveStashDir, safeRealpath, toPosix } from "../../core/common.js";
 const PROJECT_CONFIG_RELATIVE_PATH = path.join(".akm", "config.json");
 export function getCurrentWorkflowScopeKey() {
     const anchor = resolveWorkflowScopeAnchor(process.cwd());

package/dist/workflows/cli.js

@@ -1,7 +1,7 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { UsageError } from "../core/errors";
+import { UsageError } from "../core/errors.js";
 export const WORKFLOW_STEP_STATES = [
     "completed",
     "blocked",