@anhlp/alp 0.0.1-beta.4 → 0.0.1-beta.6

package/packages/core/dist/user-worktree.d.ts

@@ -1,29 +0,0 @@
-export function repositoryIdentity(directory: any): Promise<{
-    gitDir: string;
-    commonDir: string;
-    branch: string | null;
-}>;
-/** User workspace primitives. Assignment cleanup's force/rm semantics must never be used here. */
-export function userWorktreeGit({ executable, timeoutMs, maxBytes }?: {
-    executable?: string | undefined;
-    timeoutMs?: number | undefined;
-    maxBytes?: number | undefined;
-}): {
-    facts: (source: any) => Promise<{
-        commonDir: string;
-        gitDir: string;
-        head: any;
-        branch: any;
-    }>;
-    inspect: (source: any, target: any, branch: any) => Promise<any>;
-    assertClean: (target: any) => Promise<void>;
-    checkoutFacts(directory: any): Promise<{
-        isGit: true;
-        repoRoot: any;
-        currentBranch: any;
-        remoteUrl: any;
-        isDirty: boolean;
-    }>;
-    create(source: any, parent: any, name: any, branch: any, head: any): Promise<string>;
-    remove(source: any, target: any, branch: any): Promise<void>;
-};

package/packages/core/dist/user-worktree.js

@@ -1,242 +0,0 @@
-// packages/core/src/user-worktree.js
-import { spawn } from "node:child_process";
-import { lstat, realpath, open } from "node:fs/promises";
-import path from "node:path";
-import { constants } from "node:fs";
-async function control(file) {
-  const handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
-  try {
-    const info = await handle.stat();
-    if (!info.isFile() || info.nlink !== 1 || info.size > 4096) throw new Error("Invalid Git administrative file");
-    const bytes = Buffer.alloc(4097);
-    const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
-    if (bytesRead > 4096) throw new Error("Git administrative file exceeds limit");
-    return bytes.subarray(0, bytesRead).toString("utf8").replace(/\r?\n$/, "");
-  } finally {
-    await handle.close();
-  }
-}
-async function repositoryIdentity(directory) {
-  if (await realpath(directory) !== directory) throw new Error("Repository root is not canonical");
-  const entry = path.join(directory, ".git");
-  const info = await lstat(entry);
-  let gitDir;
-  if (info.isDirectory()) gitDir = await realpath(entry);
-  else {
-    const value = await control(entry);
-    if (!value.startsWith("gitdir: ") || /[\r\n\0]/.test(value)) throw new Error("Invalid Git control link");
-    gitDir = await realpath(path.resolve(directory, value.slice(8)));
-  }
-  const commonEntry = path.join(gitDir, "commondir");
-  const hasCommon = await lstat(commonEntry).catch((error) => {
-    if (error.code === "ENOENT") return void 0;
-    throw error;
-  });
-  const commonDir = hasCommon ? await realpath(path.resolve(gitDir, await control(commonEntry))) : gitDir;
-  if (gitDir !== commonDir) {
-    if (path.dirname(gitDir) !== path.join(commonDir, "worktrees") || path.resolve(gitDir, await control(path.join(gitDir, "gitdir"))) !== entry)
-      throw new Error("Git worktree backlink changed");
-  }
-  const head = await control(path.join(gitDir, "HEAD"));
-  const branch = head.startsWith("ref: refs/heads/") ? head.slice(16) : null;
-  if (branch !== null && (!branch || /[\r\n\0]/.test(branch))) throw new Error("Invalid branch reference");
-  return { gitDir, commonDir, branch };
-}
-function userWorktreeGit({ executable = "/usr/bin/git", timeoutMs = 15e3, maxBytes = 2 * 1024 * 1024 } = {}) {
-  if (process.platform === "win32") throw new Error("User worktree operations are unavailable on this host");
-  if (!path.isAbsolute(executable)) throw new Error("Git executable must be host configured and absolute");
-  const disabled = [
-    "-c",
-    "core.hooksPath=/dev/null",
-    "-c",
-    "core.fsmonitor=false",
-    "-c",
-    "core.untrackedCache=false",
-    "-c",
-    "core.pager=cat",
-    "-c",
-    "maintenance.auto=false",
-    "-c",
-    "gc.auto=0",
-    "-c",
-    "protocol.allow=never",
-    "-c",
-    "submodule.recurse=false"
-  ];
-  const env = {
-    PATH: "/usr/bin:/bin",
-    GIT_CONFIG_NOSYSTEM: "1",
-    GIT_CONFIG_GLOBAL: "/dev/null",
-    GIT_TERMINAL_PROMPT: "0",
-    GIT_OPTIONAL_LOCKS: "0",
-    LANG: "C",
-    LC_ALL: "C"
-  };
-  async function raw(cwd, args, extra = []) {
-    return new Promise((resolve, reject) => {
-      const child = spawn(executable, [...disabled, ...extra, ...args], {
-        cwd,
-        env,
-        stdio: ["ignore", "pipe", "pipe"],
-        windowsHide: true,
-        detached: true
-      });
-      let size = 0;
-      let overflow = false;
-      const stdout = [];
-      const stderr = [];
-      const kill = () => {
-        try {
-          process.kill(-child.pid, "SIGKILL");
-        } catch {
-          child.kill("SIGKILL");
-        }
-      };
-      const timer = setTimeout(() => {
-        overflow = true;
-        kill();
-      }, timeoutMs);
-      const collect = (sink) => (chunk) => {
-        size += chunk.length;
-        if (size > maxBytes) {
-          overflow = true;
-          kill();
-        } else sink.push(chunk);
-      };
-      child.stdout.on("data", collect(stdout));
-      child.stderr.on("data", collect(stderr));
-      child.once("error", (error) => {
-        clearTimeout(timer);
-        reject(error);
-      });
-      child.once("close", (code) => {
-        clearTimeout(timer);
-        if (overflow) reject(new Error("Git operation exceeded its host limit"));
-        else
-          resolve({
-            code,
-            stdout: Buffer.concat(stdout).toString("utf8"),
-            stderr: Buffer.concat(stderr).toString("utf8")
-          });
-      });
-    });
-  }
-  async function filterOverrides(cwd) {
-    const filters = await raw(cwd, [
-      "config",
-      "--null",
-      "--name-only",
-      "--get-regexp",
-      "^filter\\..*\\.(smudge|clean|process|required)$"
-    ]);
-    if (filters.code !== 0 && filters.code !== 1) throw new Error("Cannot inspect repository filters");
-    const neutral = filters.stdout.split("\0").filter(Boolean).flatMap((key) => ["-c", `${key}=${key.endsWith(".required") ? "false" : ""}`]);
-    return neutral;
-  }
-  async function run(cwd, args, extra = []) {
-    return raw(cwd, args, [...await filterOverrides(cwd), ...extra]);
-  }
-  async function checked(cwd, args, extra = []) {
-    const result = await run(cwd, args, extra);
-    if (result.code !== 0) throw new Error("Git workspace operation refused");
-    return result.stdout.trim();
-  }
-  async function directory(value) {
-    const canonical = await realpath(value);
-    if (canonical !== value || !(await lstat(value)).isDirectory())
-      throw new Error("Workspace paths must be canonical directories");
-    return canonical;
-  }
-  async function facts(source) {
-    await directory(source);
-    const top = await checked(source, ["rev-parse", "--show-toplevel"]);
-    if (await realpath(top) !== source) throw new Error("Workspace must be a repository top level");
-    const commonDir = await realpath(
-      await checked(source, ["rev-parse", "--path-format=absolute", "--git-common-dir"])
-    );
-    const identity = await repositoryIdentity(source);
-    if (identity.commonDir !== commonDir) throw new Error("Repository identity changed");
-    const head = await checked(source, ["rev-parse", "--verify", "HEAD"]);
-    const branch = await run(source, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
-    return { commonDir, gitDir: identity.gitDir, head, branch: branch.code === 0 ? branch.stdout.trim() : null };
-  }
-  async function list(source) {
-    const result = await checked(source, ["worktree", "list", "--porcelain", "-z"]);
-    return result.split("\0\0").filter(Boolean).map(
-      (block) => Object.fromEntries(
-        block.split("\0").filter(Boolean).map((line) => {
-          const i = line.indexOf(" ");
-          return i < 0 ? [line, true] : [line.slice(0, i), line.slice(i + 1)];
-        })
-      )
-    );
-  }
-  async function inspect(source, target, branch) {
-    const row = (await list(source)).find((row2) => row2.worktree === target);
-    if (!row) return void 0;
-    await directory(target);
-    if (row.branch !== `refs/heads/${branch}` || row.locked || row.prunable)
-      throw new Error("Managed worktree identity changed");
-    const origin = await facts(source);
-    const destination = await facts(target);
-    if (origin.commonDir !== destination.commonDir) throw new Error("Managed worktree repository changed");
-    return row;
-  }
-  async function assertClean(target) {
-    const flags = await checked(target, ["ls-files", "-v", "-z"]);
-    if (flags.split("\0").some((row) => row && (row[0] === "S" || /[a-z]/.test(row[0]))))
-      throw new Error("Worktree has hidden index state");
-    if ((await checked(target, ["ls-files", "--stage", "-z"])).split("\0").some((row) => row.startsWith("160000 ")))
-      throw new Error("Worktree has submodules");
-    if ((await checked(target, ["status", "--porcelain=v1", "--untracked-files=all", "--ignored"])).length)
-      throw new Error("Worktree contains uncommitted or ignored files");
-  }
-  return {
-    facts,
-    inspect,
-    assertClean,
-    async checkoutFacts(directory2) {
-      const canonical = await realpath(directory2);
-      const repoRoot = await checked(canonical, ["rev-parse", "--show-toplevel"]);
-      const branch = await run(canonical, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
-      const remote = await run(canonical, ["config", "--get", "remote.origin.url"]);
-      const status = await checked(canonical, ["status", "--porcelain=v1", "--untracked-files=all"]);
-      return {
-        isGit: (
-          /** @type {const} */
-          true
-        ),
-        repoRoot,
-        currentBranch: branch.code === 0 ? branch.stdout.trim() : null,
-        remoteUrl: remote.code === 0 ? remote.stdout.trim() || null : null,
-        isDirty: !!status
-      };
-    },
-    async create(source, parent, name, branch, head) {
-      await directory(parent);
-      if (!/^wks_[0-9a-f]{16}$/.test(name) || branch !== `alp/workspace/${name}` || !/^[0-9a-f]{40,64}$/.test(head))
-        throw new Error("Invalid generated worktree identity");
-      const target = path.join(parent, name);
-      if (await lstat(target).catch((error) => {
-        if (error.code === "ENOENT") return void 0;
-        throw error;
-      }))
-        throw new Error("Worktree destination already exists");
-      await checked(source, ["worktree", "add", "--quiet", "--no-checkout", "-b", branch, target, head]);
-      await checked(target, ["reset", "--hard", "--no-recurse-submodules", head]);
-      if (!await inspect(source, target, branch)) throw new Error("Worktree creation needs reconciliation");
-      return target;
-    },
-    async remove(source, target, branch) {
-      if (!await inspect(source, target, branch)) throw new Error("Managed worktree is missing");
-      await assertClean(target);
-      await checked(source, ["worktree", "remove", target], await filterOverrides(target));
-      if ((await list(source)).some((row) => row.worktree === target))
-        throw new Error("Worktree removal needs reconciliation");
-    }
-  };
-}
-export {
-  repositoryIdentity,
-  userWorktreeGit
-};

package/packages/core/dist/validation.d.ts

@@ -1,17 +0,0 @@
-export const PROJECT_SETTINGS: string[];
-export const USER_SETTINGS: string[];
-export const RETIRED_SETTINGS: { project: Record<string, string>; user: Record<string, string> };
-export function settingsKeys(settings: unknown, known: string[], retired?: Record<string, string>): { unknown: Array<{ key: string; suggestion?: string }>; retired: Array<{ key: string; instead: string }> };
-export function settingsWarnings(settings: unknown, scope: 'project' | 'user'): string[];
-export function validateSettings(settings: unknown, source: string): { provider?: string; model?: string; reasoning?: string };
-export function validateUserSettings(settings: unknown, source: string): { language?: string; permissions?: unknown; limits?: { autoResume?: boolean }; recovery?: { autoResume?: boolean } };
-export function normalizeMcp(raw: unknown, directory: string, source: string): { mcpServers: Record<string, Record<string, unknown>> };
-export function validateResolvedAgent(agent: unknown): unknown;
-export const AGENT_SETTINGS: string[];
-export const CONTEXT_TOKENS: { min: number; max: number };
-export function validateAgentConfig(config: unknown, source: string): { description?: string; provider?: string; model?: string; thinking?: string; mode?: 'read-only' | 'workspace-write' | 'full-access'; skills?: string[]; mcp?: string[]; hooks?: string[] };
-export const HOOK_SETTINGS: string[];
-export const HOOK_EVENTS: string[];
-export const BLOCKING_HOOK_EVENTS: string[];
-export function validateHook(config: unknown, source: string): { description?: string; event: string; command: string; blocking?: boolean; timeoutSec?: number; match?: { agent?: string; label?: string } };
-export function unknownMessage(unknown: { key: string; suggestion?: string }, known: string[]): string;

package/packages/core/dist/validation.js

@@ -1,296 +0,0 @@
-// packages/core/src/validation.js
-import path from "node:path";
-import { AlpError } from "./errors.js";
-import { MODELS } from "./models.js";
-import { validatePermissions } from "./permissions.js";
-import { validateVerify } from "./verify.js";
-var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-var nonempty = (value) => typeof value === "string" && value.trim().length > 0;
-var stringMap = (value) => object(value) && Object.values(value).every((v) => typeof v === "string");
-function requireValue(condition, code, source, message) {
-  if (!condition) throw new AlpError(code, `${source}: ${message}`);
-}
-var EFFORTS = ["none", "off", "low", "medium", "high", "xhigh", "max", "ultra", "ultracode"];
-var PROJECT_SETTINGS = ["$schema", "defaultAgent", "workflow", "runtime", "permissions", "verify", "delegation", "team", "profile", "templateDefaults"];
-var USER_SETTINGS = ["$schema", "language", "permissions", "limits", "recovery", "web"];
-var RETIRED_SETTINGS = { project: {}, user: {} };
-function distance(a, b) {
-  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
-  for (let i = 1; i <= a.length; i++) {
-    let previous = row[0];
-    row[0] = i;
-    for (let j = 1; j <= b.length; j++) {
-      const kept = row[j];
-      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1].toLowerCase() === b[j - 1].toLowerCase() ? 0 : 1));
-      previous = kept;
-    }
-  }
-  return row[b.length];
-}
-function settingsKeys(settings, known, retired = {}) {
-  const unknown = [];
-  const old = [];
-  for (const key of Object.keys(object(settings) ? settings : {})) {
-    if (known.includes(key)) continue;
-    if (Object.hasOwn(retired, key)) {
-      old.push({ key, instead: retired[key] });
-      continue;
-    }
-    const near = known.filter((candidate) => !candidate.startsWith("$")).map((candidate) => ({ candidate, d: distance(key, candidate) })).sort((a, b) => a.d - b.d)[0];
-    unknown.push({ key, ...near && near.d <= 2 ? { suggestion: near.candidate } : {} });
-  }
-  return { unknown, retired: old };
-}
-var unknownMessage = (unknown, known) => `unknown setting '${unknown.key}'${unknown.suggestion ? `; did you mean '${unknown.suggestion}'?` : `; known settings are ${known.filter((key) => !key.startsWith("$")).join(", ")}`}`;
-function settingsWarnings(settings, scope) {
-  return settingsKeys(settings, scope === "user" ? USER_SETTINGS : PROJECT_SETTINGS, RETIRED_SETTINGS[scope]).retired.map(({ key, instead }) => `setting '${key}' is no longer read; ${instead}`);
-}
-function validateSettings(settings, source) {
-  const check = (ok, message) => requireValue(ok, "INVALID_SETTINGS", source, message);
-  check(object(settings), "expected an object");
-  const { unknown } = settingsKeys(settings, PROJECT_SETTINGS, RETIRED_SETTINGS.project);
-  check(!unknown.length, unknown.length ? unknownMessage(unknown[0], PROJECT_SETTINGS) : "");
-  if (settings.defaultAgent !== void 0) check(nonempty(settings.defaultAgent), "defaultAgent must be a nonempty string");
-  if (settings.workflow !== void 0) {
-    check(object(settings.workflow), "workflow must be an object");
-    check(Object.keys(settings.workflow).every((key) => ["mode", "maxPeers", "supervisor"].includes(key)), "unsupported workflow field");
-    if (settings.workflow.mode !== void 0) check(typeof settings.workflow.mode === "string" && /^[\w.-]+$/.test(settings.workflow.mode) && settings.workflow.mode !== "custom", "workflow.mode must name a team, such as pho or cafe");
-    if (settings.workflow.maxPeers !== void 0) check(Number.isSafeInteger(settings.workflow.maxPeers) && settings.workflow.maxPeers > 0, "workflow.maxPeers must be a positive integer");
-    if (settings.workflow.supervisor !== void 0) check(typeof settings.workflow.supervisor === "boolean", "workflow.supervisor must be true or false");
-  }
-  if (settings.templateDefaults !== void 0) {
-    check(object(settings.templateDefaults), "templateDefaults must map teams to profile fingerprints");
-    for (const [team, agents] of Object.entries(settings.templateDefaults)) {
-      check(/^[\w.-]+$/.test(team) && object(agents), "templateDefaults must map teams to profile fingerprints");
-      for (const [agent, hash] of Object.entries(agents)) check(/^[\w.-]+$/.test(agent) && typeof hash === "string" && /^[a-f0-9]{64}$/.test(hash), "templateDefaults requires profile fingerprints");
-    }
-  }
-  for (const key of ["team", "profile"]) {
-    if (settings[key] === void 0) continue;
-    check(object(settings[key]), `${key} must map team names to agent configurations`);
-    const validateChoice = (config, where) => {
-      check(object(config), `${where} must be an object`);
-      check(Object.keys(config).every((key2) => ["provider", "model", "effort"].includes(key2)), `${where}: use provider, model and effort`);
-      if (config.provider !== void 0) check(["codex", "claude", "antigravity", "acp"].includes(config.provider), `${where}.provider must be codex, claude or antigravity`);
-      if (config.model !== void 0) {
-        check(nonempty(config.model) && !/\s/.test(config.model), `${where}.model must be a model ID`);
-        check(config.provider !== void 0 || /^(codex|claude|antigravity|acp):.+$/.test(config.model), `${where}: model needs a provider`);
-        if (config.model.includes(":")) check(/^(codex|claude|antigravity|acp):.+$/.test(config.model) && (!config.provider || config.model.startsWith(`${config.provider}:`)), `${where}: model and provider disagree`);
-      }
-      if (config.effort !== void 0) check(EFFORTS.includes(config.effort), `${where}.effort is unsupported`);
-    };
-    for (const [team, agents] of Object.entries(settings[key])) {
-      check(/^[\w.-]+$/.test(team) && object(agents), `${key}.${team} must map agent names to configurations`);
-      for (const [agent, config] of Object.entries(agents)) {
-        const where = `${key}.${team}.${agent}`;
-        check(object(config), `${where} must be an object`);
-        if (config.autocompact !== void 0) validateAutoCompact(config.autocompact, check, `${where}.autocompact`);
-        if (Object.hasOwn(config, "profiles")) {
-          check(Object.keys(config).every((key2) => ["profiles", "autocompact"].includes(key2)), `${where}: use profiles and autocompact`);
-          check(Array.isArray(config.profiles) && config.profiles.length > 0, `${where}.profiles must be a nonempty list`);
-          const models = [];
-          for (const [index, entry] of config.profiles.entries()) {
-            if (typeof entry === "string") {
-              const at = `${where}.profiles[${index}]`;
-              check(/^(codex|claude|antigravity):(\*|[^\s:*]+(:[a-z]+)?)$/.test(entry) || /^acp:[\w.-]+(?:\/[^\s:*]+)?$/.test(entry), `${at} must be "provider:model", "provider:model:effort" (such as "claude:claude-opus-5-5:high"), "acp:provider/model", or "codex:*" / "claude:*" for any model of that provider`);
-              const [provider, model, effort] = entry.split(":");
-              check(model !== "*" || agent !== "oracle" && agent !== "main", `${at}: ${agent} runs on a named model, not any model`);
-              if (effort !== void 0) {
-                const known = MODELS.find((candidate) => candidate.runtime === provider && candidate.id === model);
-                check(EFFORTS.includes(effort), `${at}: effort ${effort} is unsupported`);
-                check(!known?.efforts.length || known.efforts.includes(effort), `${at}: ${provider}:${model} takes effort ${known?.efforts.join(", ")}`);
-              }
-              models.push(`${provider}:${model}`);
-              continue;
-            }
-            validateChoice(entry, `${where}.profiles[${index}]`);
-            check(["claude", "codex", "antigravity"].includes(entry.provider) && nonempty(entry.model), `${where}.profiles[${index}]: specify provider and model`);
-            models.push(entry.model.includes(":") ? entry.model : `${entry.provider}:${entry.model}`);
-          }
-          check(new Set(models).size === models.length, `${where}.profiles must not repeat the same model`);
-          check(agent !== "main" || config.profiles.length === 1, `${where}.profiles: main runs on exactly one model`);
-        } else if (agent === "oracle") {
-          const entries = Object.entries(config).filter(([key2]) => key2 !== "autocompact");
-          check(entries.length > 0 && entries.every(([provider]) => ["claude", "codex"].includes(provider)), `${where} must define profiles or claude/codex lenses`);
-          for (const [provider, lens] of entries) {
-            validateChoice(lens, `${where}.${provider}`);
-            check(lens.provider === provider && nonempty(lens.model), `${where}.${provider}: specify matching provider and model`);
-          }
-        } else {
-          const { autocompact, ...legacy } = config;
-          validateChoice(legacy, where);
-        }
-      }
-    }
-  }
-  validatePermissions(settings.permissions, source);
-  validateVerify(settings.verify, source);
-  const runtime = settings.runtime ?? {};
-  if (settings.runtime !== void 0) check(object(settings.runtime), "runtime must be an object");
-  for (const key of Object.keys(runtime)) {
-    check(["provider", "model", "reasoning"].includes(key), `unsupported runtime field '${key}'`);
-    check(nonempty(runtime[key]), `runtime.${key} must be a nonempty string`);
-  }
-  return { ...runtime };
-}
-function validateUserSettings(settings, source) {
-  const check = (ok, message) => requireValue(ok, "INVALID_SETTINGS", source, message);
-  check(object(settings), "expected an object");
-  const { unknown } = settingsKeys(settings, USER_SETTINGS, RETIRED_SETTINGS.user);
-  check(!unknown.length, unknown.length ? unknownMessage(unknown[0], USER_SETTINGS) : "");
-  for (const key of ["limits", "recovery"]) {
-    if (settings[key] === void 0) continue;
-    check(object(settings[key]), `${key} must be an object`);
-    const extra = Object.keys(settings[key]).find((field) => field !== "autoResume");
-    check(!extra, `unsupported ${key} field '${extra}'; use autoResume`);
-    if (settings[key].autoResume !== void 0) check(typeof settings[key].autoResume === "boolean", `${key}.autoResume must be true or false`);
-  }
-  if (settings.web !== void 0) {
-    check(object(settings.web), "web must be an object");
-    const extra = Object.keys(settings.web).find((field) => !["enabled", "port", "relay", "permissions"].includes(field));
-    check(!extra, `unsupported web field '${extra}'; use enabled, port, relay or permissions`);
-    if (settings.web.permissions !== void 0) check(Array.isArray(settings.web.permissions) && settings.web.permissions.every((entry) => typeof entry === "string" && /^[a-z][a-z.]*$/.test(entry)), "web.permissions must be a list of permission names, such as files.read");
-    const relay = settings.web.relay;
-    if (relay !== void 0) {
-      check(object(relay), "web.relay must be an object");
-      const unsupported = Object.keys(relay).find((field) => !["enabled", "endpoint", "useTls"].includes(field));
-      check(!unsupported, `unsupported web.relay field '${unsupported}'; use enabled, endpoint or useTls`);
-      if (relay.enabled !== void 0) check(typeof relay.enabled === "boolean", "web.relay.enabled must be true or false");
-      if (relay.endpoint !== void 0) check(typeof relay.endpoint === "string" && /^[a-z0-9.-]+:\d{1,5}$/i.test(relay.endpoint), "web.relay.endpoint must be host:port, such as relay.paseo.sh:443");
-      if (relay.useTls !== void 0) check(typeof relay.useTls === "boolean", "web.relay.useTls must be true or false");
-    }
-    if (settings.web.enabled !== void 0) check(typeof settings.web.enabled === "boolean", "web.enabled must be true or false");
-    if (settings.web.port !== void 0) check(Number.isInteger(settings.web.port) && settings.web.port >= 1024 && settings.web.port <= 65535, "web.port must be a port from 1024 to 65535");
-  }
-  if (settings.language !== void 0) check(nonempty(settings.language) && settings.language.trim().length <= 40, "language must be a language name of at most 40 characters, such as Vietnamese or English");
-  validatePermissions(settings.permissions, source);
-  return settings;
-}
-var AGENT_SETTINGS = ["$schema", "description", "provider", "model", "thinking", "mode", "context", "autocompact", "skills", "mcp", "hooks"];
-var CONTEXT_TOKENS = { min: 1e5, max: 1e6 };
-function validateAutoCompact(value, check, where) {
-  check(
-    value === "auto" || Number.isSafeInteger(value) && value >= CONTEXT_TOKENS.min && value <= CONTEXT_TOKENS.max,
-    `${where} must be "auto" or a number of tokens from ${CONTEXT_TOKENS.min} to ${CONTEXT_TOKENS.max}`
-  );
-}
-var AGENT_MODES = ["read-only", "workspace-write", "full-access"];
-var entryName = (value) => typeof value === "string" && /^[\w.-]+$/.test(value) && value !== "." && value !== "..";
-var HOOK_SETTINGS = ["$schema", "description", "event", "command", "blocking", "timeoutSec", "match"];
-var HOOK_EVENTS = ["session.start", "turn.end", "assignment.start", "assignment.end", "handoff", "task.close", "merge"];
-var BLOCKING_HOOK_EVENTS = ["handoff", "task.close", "merge"];
-function validateHook(config, source) {
-  const check = (ok, message) => requireValue(ok, "INVALID_HOOK", source, message);
-  check(object(config), "expected an object");
-  const { unknown } = settingsKeys(config, HOOK_SETTINGS);
-  check(!unknown.length, unknown.length ? unknownMessage(unknown[0], HOOK_SETTINGS) : "");
-  if (config.description !== void 0) check(typeof config.description === "string", "description must be a string");
-  check(HOOK_EVENTS.includes(config.event), `event must be one of ${HOOK_EVENTS.join(", ")}`);
-  check(nonempty(config.command), "command must be a nonempty string");
-  if (config.blocking !== void 0) {
-    check(typeof config.blocking === "boolean", "blocking must be true or false");
-    check(!config.blocking || BLOCKING_HOOK_EVENTS.includes(config.event), `only ${BLOCKING_HOOK_EVENTS.join(", ")} hooks can block`);
-  }
-  if (config.timeoutSec !== void 0) check(Number.isInteger(config.timeoutSec) && config.timeoutSec >= 1 && config.timeoutSec <= 3600, "timeoutSec must be a whole number of seconds from 1 to 3600");
-  if (config.match !== void 0) {
-    check(object(config.match) && Object.keys(config.match).every((key) => ["agent", "label"].includes(key)), "match may hold only agent and label");
-    for (const key of ["agent", "label"]) if (config.match[key] !== void 0) check(nonempty(config.match[key]), `match.${key} must be a nonempty string`);
-  }
-  return config;
-}
-function validateAgentConfig(config, source) {
-  const check = (ok, message) => requireValue(ok, "INVALID_AGENT_CONFIG", source, message);
-  check(object(config), "expected an object");
-  const { unknown } = settingsKeys(config, AGENT_SETTINGS);
-  check(!unknown.length, unknown.length ? unknownMessage(unknown[0], AGENT_SETTINGS) : "");
-  if (config.description !== void 0) check(typeof config.description === "string", "description must be a string");
-  for (const key of ["provider", "model", "thinking"]) if (config[key] !== void 0) check(nonempty(config[key]), `${key} must be a nonempty string`);
-  if (config.mode !== void 0) check(AGENT_MODES.includes(config.mode), `mode must be one of ${AGENT_MODES.join(", ")}`);
-  if (config.context !== void 0) {
-    check(
-      config.context === "auto" || Number.isSafeInteger(config.context) && config.context >= CONTEXT_TOKENS.min && config.context <= CONTEXT_TOKENS.max,
-      `context must be "auto" or a number of tokens from ${CONTEXT_TOKENS.min} to ${CONTEXT_TOKENS.max}`
-    );
-  }
-  if (config.autocompact !== void 0) validateAutoCompact(config.autocompact, check, "autocompact");
-  for (const key of ["skills", "mcp", "hooks"]) {
-    if (config[key] === void 0) continue;
-    check(Array.isArray(config[key]) && config[key].every(entryName), `${key} must list names of letters, digits, '.', '_' or '-'`);
-    check(new Set(config[key]).size === config[key].length, `${key} lists a name twice`);
-  }
-  return config;
-}
-function normalizeMcp(raw, directory, source) {
-  const check = (ok, message) => requireValue(ok, "INVALID_MCP", source, message);
-  check(object(raw), "expected an object");
-  check(Object.keys(raw).every((k) => k === "mcpServers"), "only mcpServers is supported");
-  const servers = raw.mcpServers === void 0 ? {} : raw.mcpServers;
-  check(object(servers), "mcpServers must be an object");
-  const normalized = [];
-  for (const [name, server] of Object.entries(servers)) {
-    check(nonempty(name) && object(server), `invalid server '${name}'`);
-    check(Object.keys(server).every((k) => ["command", "args", "cwd", "env", "url", "headers"].includes(k)), `${name}: unsupported server field`);
-    check(nonempty(server.command) !== nonempty(server.url), `${name}: specify exactly one of command or url`);
-    const result = { ...server };
-    if (server.command !== void 0) check(nonempty(server.command), `${name}.command must be nonempty`);
-    if (server.url !== void 0) {
-      check(nonempty(server.url), `${name}.url must be nonempty`);
-      let url;
-      try {
-        url = new URL(server.url);
-      } catch {
-      }
-      check(url && ["https:", "http:"].includes(url.protocol), `${name}.url must be an HTTP(S) URL`);
-      check(server.args === void 0 && server.cwd === void 0 && server.env === void 0, `${name}: args/cwd/env require command`);
-    }
-    if (server.args !== void 0) check(Array.isArray(server.args) && server.args.every((v) => typeof v === "string"), `${name}.args must be strings`);
-    for (const key of ["env", "headers"]) if (server[key] !== void 0) check(stringMap(server[key]), `${name}.${key} must map strings to strings`);
-    if (server.command !== void 0) check(server.headers === void 0, `${name}: headers require url`);
-    if (server.cwd !== void 0) {
-      check(nonempty(server.cwd), `${name}.cwd must be nonempty`);
-      result.cwd = path.resolve(directory, server.cwd);
-    }
-    if (server.command && /[\\/]/.test(server.command)) result.command = path.resolve(directory, server.command);
-    normalized.push([name, result]);
-  }
-  return { mcpServers: Object.fromEntries(normalized) };
-}
-function validateResolvedAgent(agent) {
-  const check = (ok, message) => requireValue(ok, "INVALID_RESOLVED_AGENT", "ResolvedAgent", message);
-  check(object(agent), "expected an object");
-  check(nonempty(agent.name), "name is required");
-  check(typeof agent.projectRoot === "string" && path.isAbsolute(agent.projectRoot), "projectRoot must be absolute");
-  check(object(agent.instructions) && typeof agent.instructions.project === "string" && typeof agent.instructions.agent === "string", "instructions must contain project and agent strings");
-  for (const key of ["skills", "hooks"]) {
-    check(Array.isArray(agent[key]), `${key} must be an array`);
-    for (const resource of agent[key]) check(object(resource) && nonempty(resource.name) && typeof resource.path === "string" && path.isAbsolute(resource.path), `${key} must contain named absolute paths`);
-  }
-  check(object(agent.runtime), "runtime must be an object");
-  validateSettings({ runtime: agent.runtime }, "ResolvedAgent.runtime");
-  normalizeMcp(agent.mcp, agent.projectRoot, "ResolvedAgent.mcp");
-  check(object(agent.mcp.mcpServers), "MCP must contain a normalized mcpServers map");
-  for (const server of Object.values(agent.mcp.mcpServers)) {
-    if (server.cwd !== void 0) check(path.isAbsolute(server.cwd), "MCP cwd must already be absolute");
-    if (server.command && /[\\/]/.test(server.command)) check(path.isAbsolute(server.command), "MCP command paths must already be absolute");
-  }
-  return agent;
-}
-export {
-  AGENT_SETTINGS,
-  BLOCKING_HOOK_EVENTS,
-  CONTEXT_TOKENS,
-  HOOK_EVENTS,
-  HOOK_SETTINGS,
-  PROJECT_SETTINGS,
-  RETIRED_SETTINGS,
-  USER_SETTINGS,
-  normalizeMcp,
-  settingsKeys,
-  settingsWarnings,
-  unknownMessage,
-  validateAgentConfig,
-  validateHook,
-  validateResolvedAgent,
-  validateSettings,
-  validateUserSettings
-};

package/packages/core/dist/verify.d.ts

@@ -1,15 +0,0 @@
-export const VERIFY_STEPS: readonly ['setup', 'typecheck', 'test'];
-export const VERIFY_TIMEOUT_SEC: number;
-export const VERIFY_GRACE_MS: number;
-export const VERIFY_INFRA_EXIT: number;
-
-export type VerifyConfig = { setup?: string; typecheck?: string; test?: string; timeoutSec: number; idleSec?: number };
-
-export type VerifyCommand = { step: 'setup' | 'typecheck' | 'test'; command: string; exitCode: number; ms: number; output: string; timedOut?: boolean; idle?: boolean };
-
-export type Verification = { passed: boolean; cwd: string; commands: VerifyCommand[]; skipped?: string };
-
-export function validateVerify(verify: unknown, source: string): VerifyConfig | undefined;
-export function verifyConfig(projectRoot: string): Promise<VerifyConfig | undefined>;
-export function runVerify(cwd: string, config: VerifyConfig, options?: { env?: NodeJS.ProcessEnv }): Promise<Verification>;
-export function describeVerification(verified: { passed: boolean; commands: Array<{ step: string; exitCode: number; timedOut?: boolean; idle?: boolean }>; skipped?: string }): string;