akm-cli 0.8.1 → 0.9.0-beta.0

package/dist/tasks/backends/exec-utils.js

@@ -2,6 +2,38 @@
 // 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 { spawnSync } from "node:child_process";
+import fs from "node:fs";
+/**
+ * Default exec strategy: run commands synchronously via {@link spawnCommand}.
+ *
+ * This is the shared default for every task backend's `exec` seam. Backends
+ * that need extra fields (e.g. launchd's `uid()`) spread this and add them.
+ */
+export function nodeExec() {
+    return {
+        run(args) {
+            return spawnCommand(args);
+        },
+    };
+}
+/**
+ * Default filesystem strategy for the shared subset of the backend `fs` seam
+ * (`writeFile` + `ensureDir`), backed by `node:fs`.
+ *
+ * Backends spread this and add their own members. Note `removeFile` is NOT
+ * shared here: the launchd and schtasks defaults differ observably (schtasks
+ * swallows errors; launchd does not), so each keeps its own.
+ */
+export function nodeFs() {
+    return {
+        writeFile(file, content) {
+            fs.writeFileSync(file, content, { encoding: "utf8" });
+        },
+        ensureDir(dir) {
+            fs.mkdirSync(dir, { recursive: true });
+        },
+    };
+}
 /**
  * Run a command synchronously, normalizing null results to safe defaults.
  * args[0] is the binary; args[1..] are its arguments.

package/dist/tasks/backends/index.js

@@ -1,9 +1,9 @@
 // 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 { CRON_BACKEND } from "./cron";
-import { LAUNCHD_BACKEND } from "./launchd";
-import { SCHTASKS_BACKEND } from "./schtasks";
+import { CRON_BACKEND } from "./cron.js";
+import { LAUNCHD_BACKEND } from "./launchd.js";
+import { SCHTASKS_BACKEND } from "./schtasks.js";
 export function selectBackend(options = {}) {
     const platform = options.platform ?? process.platform;
     switch (platform) {

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

@@ -24,19 +24,21 @@
  */
 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 { 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;
@@ -111,7 +113,7 @@ async function runCommandTask(input) {
     let stderr = "";
     let exitCode = null;
     try {
-        const proc = Bun.spawn(cmd, {
+        const proc = spawn(cmd, {
             stdin: "ignore",
             stdout: "pipe",
             stderr: "pipe",
@@ -222,8 +224,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,7 +244,7 @@ function mapWorkflowStatus(status) {
         case "active":
             return status;
         default:
-            return "completed";
+            return assertNever(status, "mapWorkflowStatus");
     }
 }
 function renderWorkflowLog(input) {

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",

package/dist/workflows/db.js

@@ -1,10 +1,11 @@
 // 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 { Database } from "bun:sqlite";
 import fs from "node:fs";
 import path from "node:path";
-import { getWorkflowDbPath } from "../core/paths";
+import { getWorkflowDbPath } from "../core/paths.js";
+import { openDatabase } from "../storage/database.js";
+import { runMigrations as runSqliteMigrations } from "../storage/engines/sqlite-migrations.js";
 /**
  * workflow.db — Durable SQLite database for workflow run state.
  *
@@ -44,7 +45,7 @@ export function openWorkflowDatabase(dbPath = getWorkflowDbPath()) {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
-    const db = new Database(dbPath);
+    const db = openDatabase(dbPath);
     db.exec("PRAGMA journal_mode = WAL");
     db.exec("PRAGMA foreign_keys = ON");
     ensureBaseSchema(db);
@@ -102,6 +103,13 @@ function ensureBaseSchema(db) {
       ON workflow_run_steps(run_id, sequence_index);
   `);
 }
+// ── Migration engine ─────────────────────────────────────────────────────────
+//
+// The runner itself (ensureMigrationsTable + runMigrations) lives in the shared
+// engine at src/storage/engines/sqlite-migrations.ts. This module owns its own
+// MIGRATIONS array plus the pre-versioning `bootstrap` hook, and delegates
+// application to that shared runner. The {@link Migration} interface is imported
+// from there.
 /**
  * All workflow.db migrations in application order. New migrations are
  * APPENDED — never inserted in the middle or reordered.
@@ -121,29 +129,50 @@ const MIGRATIONS = [
         ON workflow_runs(scope_key, workflow_ref, status);
     `,
     },
+    // ── Migration 002 — record agent harness + session identity ──────────────────
+    //
+    // Persists the agent harness identifier (e.g. "claude-code", "opencode") and
+    // the platform-native session id that owns each workflow run. This is the
+    // first concrete slice of #501 / #506: capturing *who* is driving a run so a
+    // future (separately-approved) monitor can correlate workflow runs with
+    // session activity. Both columns are nullable — runs started outside an agent
+    // harness, and all pre-existing runs, simply have NULL identity.
+    {
+        id: "002-add-agent-identity",
+        up: `
+      ALTER TABLE workflow_runs ADD COLUMN agent_harness TEXT;
+      ALTER TABLE workflow_runs ADD COLUMN agent_session_id TEXT;
+
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_agent_session
+        ON workflow_runs(agent_harness, agent_session_id);
+    `,
+    },
+    // ── Migration 003 — check-in arming + per-step summary (#506) ────────────────
+    //
+    // Builds on the agent identity recorded by migration 002. Arms a file-signal
+    // check-in (a timestamp, NOT a background thread — see
+    // docs/technical/workflow-agent-checkin-adr.md) so a stalled run can be
+    // re-targeted with a `continue` directive, and adds a per-step `summary`
+    // column so step/workflow completion can capture and validate a required
+    // summary of work done. Both columns are nullable.
+    {
+        id: "003-checkin-and-step-summary",
+        up: `
+      ALTER TABLE workflow_runs ADD COLUMN checkin_armed_at TEXT;
+      ALTER TABLE workflow_run_steps ADD COLUMN summary TEXT;
+    `,
+    },
 ];
 /**
  * Stable id of the scope_key migration. Exported for bootstrap detection and
  * tests.
  */
 const SCOPE_KEY_MIGRATION_ID = "001-add-scope-key";
-/**
- * Create the migrations table if it does not exist. Called unconditionally on
- * every open so a fresh database bootstraps correctly.
- */
-function ensureMigrationsTable(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS schema_migrations (
-      id         TEXT    PRIMARY KEY,
-      applied_at TEXT    NOT NULL DEFAULT (datetime('now'))
-    );
-  `);
-}
 /**
  * Detect whether a column exists on a given table.
  */
 function hasColumn(db, table, column) {
-    const rows = db.query(`PRAGMA table_info(${table})`).all();
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
     return rows.some((r) => r.name === column);
 }
 /**
@@ -171,24 +200,13 @@ function bootstrapPreVersioningDb(db) {
 /**
  * Apply every pending migration in a single transaction per migration.
  *
- * Each migration is applied in its own transaction so a failure in migration N
- * does not roll back already-applied migrations 1..N-1. The migration row is
- * inserted AFTER the DDL succeeds — a crash mid-migration leaves no row and
- * the migration is retried on next open.
+ * Delegates to the shared SQLite migration engine, passing the
+ * `bootstrapPreVersioningDb` hook so databases created before this file gained
+ * migration tracking back-fill their scope_key row instead of re-running the
+ * ALTER.
  *
  * Called automatically by {@link openWorkflowDatabase}.
  */
 export function runMigrations(db) {
-    ensureMigrationsTable(db);
-    bootstrapPreVersioningDb(db);
-    const appliedRows = db.prepare("SELECT id FROM schema_migrations").all();
-    const applied = new Set(appliedRows.map((r) => r.id));
-    for (const migration of MIGRATIONS) {
-        if (applied.has(migration.id))
-            continue;
-        db.transaction(() => {
-            db.exec(migration.up);
-            db.prepare("INSERT INTO schema_migrations (id) VALUES (?)").run(migration.id);
-        })();
-    }
+    runSqliteMigrations(db, MIGRATIONS, { bootstrap: bootstrapPreVersioningDb });
 }

package/dist/workflows/parser.js

@@ -11,10 +11,10 @@
  * line spans, accumulating `WorkflowError`s rather than throwing.
  */
 import { parse as yamlParse } from "yaml";
-import { parseFrontmatterBlock } from "../core/frontmatter";
-import { parseMarkdownToc } from "../core/markdown";
-import { WORKFLOW_SCHEMA_VERSION, } from "./schema";
-import { runSemanticChecks } from "./validator";
+import { parseFrontmatterBlock } from "../core/asset/frontmatter.js";
+import { parseMarkdownToc } from "../core/asset/markdown.js";
+import { WORKFLOW_SCHEMA_VERSION, } from "./schema.js";
+import { runSemanticChecks } from "./validator.js";
 const WORKFLOW_TITLE_PREFIX = "Workflow:";
 const STEP_PREFIX = "Step:";
 const STEP_ID_LINE = /^Step ID:\s+(.+?)\s*$/;

package/dist/workflows/renderer.js

@@ -9,11 +9,11 @@
  * uses the flat `WorkflowStepDefinition` type for backwards compatibility)
  * and into search hints for the indexer.
  */
-import { makeAssetRef } from "../core/asset-ref";
-import { UsageError } from "../core/errors";
-import { registerMetadataContributor } from "../indexer/metadata-contributors";
-import { cacheWorkflowDocument } from "./document-cache";
-import { parseWorkflow } from "./parser";
+import { makeAssetRef } from "../core/asset/asset-ref.js";
+import { UsageError } from "../core/errors.js";
+import { registerMetadataContributor } from "../indexer/passes/metadata-contributors.js";
+import { parseWorkflow } from "./parser.js";
+import { cacheWorkflowDocument } from "./runtime/document-cache.js";
 function shellQuote(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }