@anhlp/alp-core 0.0.0-beta.1 → 0.10.0

package/dist/hook-run.d.ts

@@ -1,5 +1,5 @@
 /**
- * Runs a hook's command once (ALPD §43): through /bin/sh (cmd.exe on Windows) in `cwd`, with the event as JSON
+ * Runs a hook's command once (ALPD §43): through /bin/sh in `cwd`, with the event as JSON
  * on stdin and `env` added to ALP's environment. It runs in its own process group, so
  * past its timeout the whole group gets SIGTERM, then SIGKILL two seconds later; a
  * shell's children do not outlive it. Output beyond 64 KiB per stream is cut.

package/dist/hook-run.js

@@ -1,13 +1,19 @@
 // packages/core/src/hook-run.js
-import { signalShell, spawnShell } from "./shell.js";
+import { spawn } from "node:child_process";
 var OUTPUT_LIMIT = 64 * 1024;
 var GRACE_MS = 2e3;
 function runHook(hook, payload, { cwd, env = {}, timeoutMs } = {}) {
   const limit = timeoutMs ?? (hook.timeoutSec ?? 60) * 1e3;
   const started = Date.now();
   return new Promise((resolve, reject) => {
-    const child = spawnShell(hook.command, { cwd, env: { ...process.env, ...env }, stdio: ["pipe", "pipe", "pipe"] });
-    const signal = (name) => signalShell(child, name);
+    const child = spawn("/bin/sh", ["-c", hook.command], { cwd, env: { ...process.env, ...env }, stdio: ["pipe", "pipe", "pipe"], detached: true });
+    const signal = (name) => {
+      try {
+        process.kill(-child.pid, name);
+      } catch {
+        child.kill(name);
+      }
+    };
     const output = { stdout: "", stderr: "" };
     for (const stream of ["stdout", "stderr"]) {
       child[stream].setEncoding("utf8");

package/dist/index.d.ts

@@ -1,6 +1,4 @@
 export * as adapter from "./adapter.js";
-export * as atomic from "./atomic.js";
-export * as backup from "./backup.js";
 export * as beads from "./beads.js";
 export * as delegation from "./delegation.js";
 export * as errors from "./errors.js";
@@ -10,15 +8,12 @@ export * as hooks from "./hooks.js";
 export * as init from "./init.js";
 export * as library_edit from "./library-edit.js";
 export * as library from "./library.js";
-export * as log from "./log.js";
-export * as migrations from "./migrations.js";
 export * as models from "./models.js";
 export * as permissions from "./permissions.js";
 export * as profiles from "./profiles.js";
 export * as promptsafe from "./promptsafe.js";
 export * as providers from "./providers.js";
 export * as resolver from "./resolver.js";
-export * as state_schema from "./state-schema.js";
 export * as task_rows from "./task-rows.js";
 export * as tasks from "./tasks.js";
 export * as teams from "./teams.js";

package/dist/index.js

@@ -1,7 +1,5 @@
 // packages/core/src/index.js
 import * as adapter from "./adapter.js";
-import * as atomic from "./atomic.js";
-import * as backup from "./backup.js";
 import * as beads from "./beads.js";
 import * as delegation from "./delegation.js";
 import * as errors from "./errors.js";
@@ -11,15 +9,12 @@ import * as hooks from "./hooks.js";
 import * as init from "./init.js";
 import * as library_edit from "./library-edit.js";
 import * as library from "./library.js";
-import * as log from "./log.js";
-import * as migrations from "./migrations.js";
 import * as models from "./models.js";
 import * as permissions from "./permissions.js";
 import * as profiles from "./profiles.js";
 import * as promptsafe from "./promptsafe.js";
 import * as providers from "./providers.js";
 import * as resolver from "./resolver.js";
-import * as state_schema from "./state-schema.js";
 import * as task_rows from "./task-rows.js";
 import * as tasks from "./tasks.js";
 import * as teams from "./teams.js";
@@ -31,8 +26,6 @@ import * as verify from "./verify.js";
 import * as workflow from "./workflow.js";
 export {
   adapter,
-  atomic,
-  backup,
   beads,
   delegation,
   errors,
@@ -42,15 +35,12 @@ export {
   init,
   library,
   library_edit,
-  log,
-  migrations,
   models,
   permissions,
   profiles,
   promptsafe,
   providers,
   resolver,
-  state_schema,
   task_rows,
   tasks,
   teams,

package/dist/library-edit.js

@@ -2,9 +2,7 @@
 import { mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
-import { moveFile } from "./atomic.js";
 import { AlpError } from "./errors.js";
-import { assertNoSymlinks } from "./safe-path.js";
 import { agentSources, builtinText, jsonObject, libraryEntries, optionalText } from "./resolver.js";
 import { teamSources, validateTeam } from "./teams.js";
 import { normalizeMcp, validateAgentConfig, validateHook } from "./validation.js";
@@ -39,13 +37,7 @@ function base(scope, { root, library }, kind) {
   return fail("INVALID_SCOPE", `Scope must be library or project, not '${scope}'`);
 }
 var revisionOf = (content) => content === void 0 ? null : createHash("sha256").update(JSON.stringify(content)).digest("hex").slice(0, 16);
-async function safeEntryPaths(directory, kind, name) {
-  for (const [file] of FILES[kind](name)) {
-    await assertNoSymlinks(directory, path.join(kind, file));
-  }
-}
 async function readLayer(kind, name, directory) {
-  await safeEntryPaths(directory, kind, name);
   const content = {};
   let found = false;
   for (const [file, key, type] of FILES[kind](name)) {
@@ -233,20 +225,18 @@ async function writeAtomic(file, text) {
   await mkdir(path.dirname(file), { recursive: true });
   const temporary = `${file}.${randomUUID().slice(0, 8)}.tmp`;
   await writeFile(temporary, text);
-  await moveFile(temporary, file);
+  await rename(temporary, file);
 }
 var exists = (target) => stat(target).then(() => true, () => false);
 async function saveEntry(kind, name, content, { scope, root, library, templates, revision } = {}) {
   kindOf(kind);
   nameOf(name);
   const directory = base(scope, { root, library }, kind);
-  await safeEntryPaths(directory, kind, name);
   await check(kind, name, content, { scope, root, library, templates });
   const current = await readLayer(kind, name, directory);
   if (revision !== void 0 && revision !== revisionOf(current)) {
     fail("REVISION_CONFLICT", current === void 0 ? `${kind} '${name}' was removed from the ${scope} since you opened it` : revision === null ? `${kind} '${name}' already exists in the ${scope}` : `${kind} '${name}' changed in the ${scope} since you opened it; reload it and apply your change again`);
   }
-  if (scope === "library") await mkdir(directory, { recursive: true, mode: 448 });
   for (const [file, key, type] of FILES[kind](name)) {
     const target = path.join(directory, kind, file);
     const value = content[key];

package/dist/library.js

@@ -1,7 +1,6 @@
 // packages/core/src/library.js
 import { shippedTemplateRoot } from "./template-path.js";
-import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
-import { moveFile } from "./atomic.js";
+import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
@@ -35,7 +34,6 @@ async function shippedFiles({ templateRoot, templates }) {
 }
 async function seedLibrary(home, options = {}) {
   const shipped = await shippedFiles(options);
-  await mkdir(home, { recursive: true, mode: 448 });
   const manifestPath = path.join(home, MANIFEST);
   const manifestText = await optional(manifestPath);
   const manifest = manifestText ? JSON.parse(manifestText) : { files: {} };
@@ -63,7 +61,7 @@ async function seedLibrary(home, options = {}) {
     await mkdir(home, { recursive: true });
     const temporary = `${manifestPath}.${randomUUID().slice(0, 8)}.tmp`;
     await writeFile(temporary, JSON.stringify(manifest, null, 2) + "\n");
-    await moveFile(temporary, manifestPath);
+    await rename(temporary, manifestPath);
   }
   return { created, updated };
 }

package/dist/permissions.js

@@ -1,8 +1,7 @@
 // packages/core/src/permissions.js
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { readFile, writeFile } from "node:fs/promises";
-import { moveFile } from "./atomic.js";
+import { readFile, rename, writeFile } from "node:fs/promises";
 import { AlpError } from "./errors.js";
 var BASES = ["read-only", "workspace-write", "full-access"];
 var RANK = { "read-only": 0, "workspace-write": 1, "full-access": 2 };
@@ -11,8 +10,6 @@ var MAX_RULES = 200;
 var NAME = /^[\w.-]{1,64}$/;
 var RULE = /^([A-Za-z][\w-]*)(?:\((.*)\))?$/s;
 var TOOLS = ["Bash", "Read", "Edit", "Write", "MultiEdit", "NotebookEdit", "Glob", "Grep", "WebFetch", "WebSearch", "Skill"];
-var own = (value, key) => Object.hasOwn(value, key) ? value[key] : void 0;
-var setOwn = (value, key, entry) => Object.defineProperty(value, key, { value: entry, enumerable: true, writable: true, configurable: true });
 var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var fail = (source, message) => {
   throw new AlpError("INVALID_SETTINGS", `${source}: ${message}`);
@@ -49,7 +46,7 @@ function validatePermissions(value, source) {
         for (const rule of list) parseRule(rule, `${source}: ${where}.${kind}`);
         rules[kind] = list.map((rule) => rule.trim());
       }
-      setOwn(profiles, name, { ...profile.base ? { base: profile.base } : {}, ...profile.beyondMode ? { beyondMode: profile.beyondMode } : {}, ...profile.workdir ? { workdir: profile.workdir } : {}, ...rules });
+      profiles[name] = { ...profile.base ? { base: profile.base } : {}, ...profile.beyondMode ? { beyondMode: profile.beyondMode } : {}, ...profile.workdir ? { workdir: profile.workdir } : {}, ...rules };
     }
   }
   const agents = {};
@@ -57,7 +54,7 @@ function validatePermissions(value, source) {
     if (!object(value.agents)) fail(source, "permissions.agents must be an object");
     for (const [agent, profile] of Object.entries(value.agents)) {
       if (typeof profile !== "string" || !NAME.test(profile)) fail(source, `permissions.agents.${agent} must name a profile`);
-      setOwn(agents, agent, profile);
+      agents[agent] = profile;
     }
   }
   return { profiles, agents };
@@ -82,10 +79,10 @@ async function settingsPermissions(file) {
 async function profileFor(projectRoot, home, agent) {
   const project = await settingsPermissions(path.join(projectRoot, ".alp", "settings.json"));
   const user = home ? await settingsPermissions(path.join(home, "settings.json")) : { profiles: {}, agents: {} };
-  const name = own(project.agents, agent) ?? own(user.agents, agent);
+  const name = project.agents[agent] ?? user.agents[agent];
   const advisor = ADVISORS.includes(agent);
   if (!name) return advisor ? { name: "read-only", base: "read-only", allow: [], ask: [], deny: [], beyondMode: "refuse" } : null;
-  const defined = [own(project.profiles, name), own(user.profiles, name)].filter(Boolean);
+  const defined = [project.profiles[name], user.profiles[name]].filter(Boolean);
   if (!defined.length && !BASES.includes(name)) {
     throw new AlpError("INVALID_SETTINGS", `permissions.agents.${agent} names profile '${name}', which no settings file defines`);
   }
@@ -120,7 +117,7 @@ async function addAllowRule(projectRoot, home, profileName, rule) {
     const temporary = `${file}.${randomUUID().slice(0, 8)}.tmp`;
     await writeFile(temporary, `${JSON.stringify(settings, null, 2)}
 `);
-    await moveFile(temporary, file);
+    await rename(temporary, file);
     return file;
   }
   throw new AlpError("INVALID_SETTINGS", `No settings file defines profile ${profileName}`);

package/dist/providers.d.ts

@@ -57,18 +57,6 @@ export function acpModel(model: any): {
     provider: any;
     model: any;
 };
-/**
- * How to start a command without a shell. On Windows a bare name installed with npm is a
- * `<name>.cmd` shim, which spawn refuses to run without one; its target runs instead: the
- * native executable it calls, or the Node script, under this Node. A bare name with an .exe or
- * .com on PATH, any other command, and every command elsewhere are returned as they are.
- * @param {string} command @param {string[]} [args] @param {Record<string, string | undefined>} [env]
- * @returns {{ command: string, args: string[] }}
- */
-export function launchCommand(command: string, args?: string[], env?: Record<string, string | undefined>): {
-    command: string;
-    args: string[];
-};
 /**
  * ACP providers (ALPD §46): agents that speak the Agent Client Protocol, such as Gemini
  * CLI or opencode, defined in the user's library as providers/<id>.json. An agent runs

package/dist/providers.js

@@ -1,5 +1,4 @@
 // packages/core/src/providers.js
-import { existsSync, readFileSync } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { AlpError } from "./errors.js";
@@ -73,28 +72,11 @@ function acpModel(model) {
   const slash = model.indexOf("/");
   return slash < 0 ? { provider: model, model: void 0 } : { provider: model.slice(0, slash), model: model.slice(slash + 1) || void 0 };
 }
-function launchCommand(command, args = [], env = process.env) {
-  if (process.platform !== "win32" || /[\\/]/.test(command) || path.extname(command)) return { command, args };
-  const key = Object.keys(env).find((name) => name.toUpperCase() === "PATH");
-  for (const directory of (key ? env[key] ?? "" : "").split(";").filter(Boolean)) {
-    if ([".exe", ".com"].some((extension) => existsSync(path.join(directory, command + extension)))) break;
-    const shim = path.join(directory, `${command}.cmd`);
-    if (!existsSync(shim)) continue;
-    const text = readFileSync(shim, "utf8");
-    const script = /"%_prog%"((?:\s+[^\s"]+)*)\s+"%~?dp0%\\?([^"]+)"\s+%\*/i.exec(text);
-    if (script) return { command: process.execPath, args: [...script[1].split(/\s+/).filter(Boolean), path.join(directory, script[2]), ...args] };
-    const native = /^\s*"%~?dp0%\\?([^"]+\.(?:exe|com))"\s+%\*/im.exec(text);
-    if (native) return { command: path.join(directory, native[1]), args };
-    break;
-  }
-  return { command, args };
-}
 export {
   BUILTIN_RUNTIMES,
   PROVIDER_SETTINGS,
   RESERVED_PROVIDERS,
   acpModel,
-  launchCommand,
   listProviders,
   loadProvider,
   validateProvider

package/dist/task-rows.d.ts

@@ -38,7 +38,6 @@ export function taskRows(projectRoot: string): Promise<{
         type: import("./tasks.js").TaskType;
         priority: number;
         status: import("./tasks.js").TaskStatus;
-        rev: number;
     }[];
     unreadable: {
         file: string;

package/dist/task-rows.js

@@ -21,7 +21,6 @@ async function taskRows(projectRoot) {
       type: task.type,
       priority: task.priority,
       status: task.status,
-      rev: task.rev,
       ...task.parent ? { parent: task.parent } : {},
       ...task.assignee ? { assignee: task.assignee.agent } : {},
       ready: ready.has(task.id),

package/dist/tasks.d.ts

@@ -108,7 +108,7 @@ export function gateOpen(gate: TaskGate, now?: number): boolean;
 export function describeGate(gate: TaskGate): string;
 export function gatesOf(task: Task, tasks: Task[]): string[];
 export function addGate(projectRoot: string, id: string, gate: { kind: GateKind; note?: string; until?: string; ref?: string | number }, by: string): Promise<Task>;
-export function resolveGate(projectRoot: string, id: string, gateId: string, resolve: { by: string; note?: string; remove?: boolean; ifRev?: number }): Promise<Task>;
+export function resolveGate(projectRoot: string, id: string, gateId: string, resolve: { by: string; note?: string; remove?: boolean }): Promise<Task>;
 export function checkGates(projectRoot: string, gh: (args: string[], options: { cwd: string }) => Promise<string>): Promise<{ cleared: Array<{ task: string; gate: string; detail: string }>; pending: Array<{ task: string; gate: string; detail: string }>; errors: Array<{ task: string; gate: string; error: string }> }>;
 export function compactTasks(projectRoot: string, options: { days?: number; dryRun?: boolean }, by: string): Promise<Array<{ id: string; before: number; after: number }>>;
 export type TaskBatch = {
@@ -125,4 +125,3 @@ export type TaskVerification = { at: string; by: string; passed: boolean; where?
 export type EpicReport = { id: string; title: string; status: TaskStatus; tasks: number; closed: number; durationMs: number; reworked: number; verification: { passed: number; failed: number; skipped: number; none: number }; unverified: string[]; lines: string[]; text: string };
 export function epicReport(id: string, tasks: Task[]): EpicReport;
 export function landedParents(tasks: Task[]): Array<{ task: Task; children: number }>;
-export function withTaskLock<T>(projectRoot: string, work: () => Promise<T>): Promise<T>;

package/dist/tasks.js

@@ -1,12 +1,10 @@
 // packages/core/src/tasks.js
-import { mkdir, readFile, readdir, rmdir, stat, writeFile } from "node:fs/promises";
-import { moveFile } from "./atomic.js";
+import { mkdir, readFile, readdir, rename, rmdir, stat, writeFile } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
 import { AlpError } from "./errors.js";
-import { assertNoSymlinks } from "./safe-path.js";
 import { describeVerification } from "./verify.js";
-var TASKS_DIR = ".alp/tasks";
+var TASKS_DIR = path.join(".alp", "tasks");
 var TASK_TYPES = ["task", "bug", "feature", "chore", "epic"];
 var TASK_STATUSES = ["open", "in_progress", "review", "closed"];
 var CLOSE_REASONS = ["done", "wontfix", "duplicate", "superseded"];
@@ -33,24 +31,15 @@ var now = () => (/* @__PURE__ */ new Date()).toISOString();
 var fail = (code, message) => {
   throw new AlpError(code, message);
 };
-async function taskNames(projectRoot) {
-  const scope = path.join(path.resolve(projectRoot), ".alp");
-  await assertNoSymlinks(scope, "tasks");
+async function loadTasks(projectRoot) {
+  const dir = tasksDir(projectRoot);
   let names;
   try {
-    names = await readdir(tasksDir(projectRoot));
+    names = await readdir(dir);
   } catch (error) {
-    if (error.code === "ENOENT") return [];
+    if (error.code === "ENOENT") return { tasks: [], errors: [] };
     throw error;
   }
-  for (const name of [...names.filter((name2) => name2.endsWith(".json")), LOCK, ".gitignore"]) {
-    await assertNoSymlinks(scope, path.join("tasks", name));
-  }
-  return names;
-}
-async function loadTasks(projectRoot) {
-  const dir = tasksDir(projectRoot);
-  const names = await taskNames(projectRoot);
   const tasks = [];
   const errors = [];
   for (const name of names.filter((name2) => name2.endsWith(".json")).sort()) {
@@ -222,7 +211,6 @@ async function locked(projectRoot, work) {
   const previous = queues.get(dir) ?? Promise.resolve();
   const run = previous.catch(() => {
   }).then(async () => {
-    await taskNames(projectRoot);
     await prepare(dir);
     const lock = path.join(dir, LOCK);
     const deadline = Date.now() + LOCK_WAIT_MS;
@@ -252,7 +240,6 @@ async function locked(projectRoot, work) {
   queues.set(dir, run);
   return run;
 }
-var withTaskLock = (projectRoot, work) => locked(projectRoot, work);
 async function prepare(dir) {
   await mkdir(dir, { recursive: true });
   await writeFile(path.join(dir, ".gitignore"), GITIGNORE, { flag: "wx" }).catch((error) => {
@@ -261,10 +248,9 @@ async function prepare(dir) {
 }
 async function save(projectRoot, task) {
   const file = taskFile(projectRoot, task.id);
-  await assertNoSymlinks(path.join(path.resolve(projectRoot), ".alp"), path.join("tasks", `${task.id}.json`));
   const temporary = `${file}.${randomUUID().slice(0, 8)}.tmp`;
   await writeFile(temporary, JSON.stringify(task, null, 2) + "\n");
-  await moveFile(temporary, file);
+  await rename(temporary, file);
   return task;
 }
 function newId(tasks, title, parent) {
@@ -630,7 +616,7 @@ function addGate(projectRoot, id, { kind, note, until, ref } = {}, by) {
     addLog(task, by, "gated", { gate: describeGate(gate) });
   });
 }
-function resolveGate(projectRoot, id, gateId, { by, note, remove = false, ifRev } = {}) {
+function resolveGate(projectRoot, id, gateId, { by, note, remove = false } = {}) {
   return mutate(projectRoot, id, (task) => {
     const gate = (task.gates ?? []).find((entry) => entry.id === gateId) ?? fail("INVALID_TASK", `${id} has no gate ${gateId}`);
     if (remove) {
@@ -649,7 +635,7 @@ function resolveGate(projectRoot, id, gateId, { by, note, remove = false, ifRev
       task.closed = { at: now(), by, reason: "done", summary };
       addLog(task, by, "closed", { reason: "done", summary });
     }
-  }, { ifRev });
+  });
 }
 async function checkGates(projectRoot, gh) {
   const { tasks } = await loadTasks(projectRoot);
@@ -830,6 +816,5 @@ export {
   taskDigest,
   tasksDir,
   updateTask,
-  verificationFailed,
-  withTaskLock
+  verificationFailed
 };

package/dist/trust.js

@@ -1,6 +1,5 @@
 // packages/core/src/trust.js
-import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
-import { moveFile } from "./atomic.js";
+import { mkdir, readFile, realpath, rename, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 var file = (home) => path.join(home, "state", "trust.json");
@@ -18,7 +17,7 @@ async function store(home, value) {
   await mkdir(path.dirname(file(home)), { recursive: true });
   const temporary = `${file(home)}.${randomUUID().slice(0, 8)}.tmp`;
   await writeFile(temporary, JSON.stringify(value, null, 2) + "\n");
-  await moveFile(temporary, file(home));
+  await rename(temporary, file(home));
 }
 async function isTrusted(home, projectRoot) {
   return Object.hasOwn((await load(home)).projects, await key(projectRoot));

package/dist/user-settings.js

@@ -1,6 +1,5 @@
 // packages/core/src/user-settings.js
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { moveFile } from "./atomic.js";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { AlpError } from "./errors.js";
@@ -46,20 +45,20 @@ async function setLanguage(home, language) {
   if (language === null) delete next.language;
   else next.language = language.trim();
   validateUserSettings(next, file);
-  await mkdir(home, { recursive: true, mode: 448 });
+  await mkdir(home, { recursive: true });
   const temporary = `${file}.${randomUUID().slice(0, 8)}.tmp`;
   await writeFile(temporary, JSON.stringify(next, null, 2) + "\n");
-  await moveFile(temporary, file);
+  await rename(temporary, file);
   return languageSetting(home);
 }
 async function setWebRelay(home, patch) {
   const { file, settings } = await readSettings(home);
   const next = { ...settings, web: { ...settings.web, relay: { ...settings.web?.relay, ...patch } } };
   validateUserSettings(next, file);
-  await mkdir(home, { recursive: true, mode: 448 });
+  await mkdir(home, { recursive: true });
   const temporary = `${file}.${randomUUID().slice(0, 8)}.tmp`;
   await writeFile(temporary, JSON.stringify(next, null, 2) + "\n");
-  await moveFile(temporary, file);
+  await rename(temporary, file);
   return next.web.relay;
 }
 export {

package/dist/verify.js

@@ -1,8 +1,8 @@
 // packages/core/src/verify.js
+import { spawn } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { AlpError } from "./errors.js";
-import { signalShell, spawnShell } from "./shell.js";
 var VERIFY_STEPS = ["setup", "typecheck", "test"];
 var VERIFY_TIMEOUT_SEC = 600;
 var VERIFY_GRACE_MS = 5e3;
@@ -50,11 +50,23 @@ async function verifyConfig(projectRoot) {
 function runCommand(command, cwd, { timeoutMs, idleMs }, env) {
   return new Promise((resolve) => {
     const started = Date.now();
-    const child = spawnShell(command, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    const windows = process.platform === "win32";
+    const child = spawn(windows ? process.env.ComSpec ?? "cmd.exe" : "/bin/sh", windows ? ["/d", "/s", "/c", command] : ["-c", command], {
+      cwd,
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: !windows,
+      windowsHide: true
+    });
     let output = "";
     let stopped;
     let idle;
-    const signal = (name) => signalShell(child, name);
+    const signal = (name) => {
+      try {
+        windows ? child.kill() : process.kill(-child.pid, name);
+      } catch {
+      }
+    };
     const stop = (reason) => {
       if (stopped) return;
       stopped = reason;

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@anhlp/alp-core",
-  "version": "0.0.0-beta.1",
+  "version": "0.10.0",
   "type": "module",
   "description": "ALP core module",
   "files": [
     "src",
     "dist",
-    "templates",
-    "NOTICE"
+    "templates"
   ],
   "exports": {
     "./adapter": {
@@ -18,22 +17,6 @@
       "types": "./dist/adapter.d.ts",
       "default": "./src/adapter.js"
     },
-    "./atomic": {
-      "alp-source": {
-        "types": "./src/atomic.js",
-        "default": "./src/atomic.js"
-      },
-      "types": "./dist/atomic.d.ts",
-      "default": "./src/atomic.js"
-    },
-    "./backup": {
-      "alp-source": {
-        "types": "./src/backup.js",
-        "default": "./src/backup.js"
-      },
-      "types": "./dist/backup.d.ts",
-      "default": "./src/backup.js"
-    },
     "./beads": {
       "alp-source": {
         "types": "./src/beads.js",
@@ -122,22 +105,6 @@
       "types": "./dist/library.d.ts",
       "default": "./src/library.js"
     },
-    "./log": {
-      "alp-source": {
-        "types": "./src/log.js",
-        "default": "./src/log.js"
-      },
-      "types": "./dist/log.d.ts",
-      "default": "./src/log.js"
-    },
-    "./migrations": {
-      "alp-source": {
-        "types": "./src/migrations.js",
-        "default": "./src/migrations.js"
-      },
-      "types": "./dist/migrations.d.ts",
-      "default": "./src/migrations.js"
-    },
     "./models": {
       "alp-source": {
         "types": "./src/models.js",
@@ -186,14 +153,6 @@
       "types": "./dist/resolver.d.ts",
       "default": "./src/resolver.js"
     },
-    "./state-schema": {
-      "alp-source": {
-        "types": "./src/state-schema.js",
-        "default": "./src/state-schema.js"
-      },
-      "types": "./dist/state-schema.d.ts",
-      "default": "./src/state-schema.js"
-    },
     "./task-rows": {
       "alp-source": {
         "types": "./src/task-rows.js",
@@ -281,10 +240,10 @@
     }
   },
   "engines": {
-    "node": ">=22.12"
+    "node": ">=20"
   },
   "dependencies": {
-    "@anhlp/alp-protocol": "0.0.0-beta.1"
+    "@anhlp/alp-protocol": "0.10.0"
   },
   "scripts": {
     "build": "node ../../scripts/build-workspace.mjs core",
@@ -293,17 +252,11 @@
   },
   "publishConfig": {
     "access": "public",
-    "registry": "https://registry.npmjs.org/",
-    "tag": "beta"
+    "registry": "https://registry.npmjs.org/"
   },
-  "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/phucanh08/alp.git",
+    "url": "git+https://github.com/phucanh08/alp-paseo.git",
     "directory": "packages/core"
-  },
-  "homepage": "https://github.com/phucanh08/alp/tree/main/packages/core#readme",
-  "bugs": {
-    "url": "https://github.com/phucanh08/alp/issues"
   }
 }

package/src/hook-run.js

@@ -1,10 +1,10 @@
-import { signalShell, spawnShell } from './shell.js';
+import { spawn } from 'node:child_process';
 
 const OUTPUT_LIMIT = 64 * 1024;
 const GRACE_MS = 2000;
 
 /**
- * Runs a hook's command once (ALPD §43): through /bin/sh (cmd.exe on Windows) in `cwd`, with the event as JSON
+ * Runs a hook's command once (ALPD §43): through /bin/sh in `cwd`, with the event as JSON
  * on stdin and `env` added to ALP's environment. It runs in its own process group, so
  * past its timeout the whole group gets SIGTERM, then SIGKILL two seconds later; a
  * shell's children do not outlive it. Output beyond 64 KiB per stream is cut.
@@ -17,8 +17,8 @@ export function runHook(hook, payload, { cwd, env = {}, timeoutMs } = {}) {
   const limit = timeoutMs ?? (hook.timeoutSec ?? 60) * 1000;
   const started = Date.now();
   return new Promise((resolve, reject) => {
-    const child = spawnShell(hook.command, { cwd, env: { ...process.env, ...env }, stdio: ['pipe', 'pipe', 'pipe'] });
-    const signal = name => signalShell(child, name);
+    const child = spawn('/bin/sh', ['-c', hook.command], { cwd, env: { ...process.env, ...env }, stdio: ['pipe', 'pipe', 'pipe'], detached: true });
+    const signal = name => { try { process.kill(-child.pid, name); } catch { child.kill(name); } };
     const output = { stdout: '', stderr: '' };
     for (const stream of ['stdout', 'stderr']) {
       child[stream].setEncoding('utf8');