@anhlp/alp-runtime 0.0.0-stage → 0.0.1-beta.4

package/dist/permission-path.d.ts

@@ -0,0 +1,2 @@
+/** ALP's permission gate, not an OS sandbox or protection against concurrent link swaps. */
+export declare function writablePath(file: unknown, workdir: string): boolean;

package/dist/permission-path.js

@@ -0,0 +1,44 @@
+// packages/runtime/src/permission-path.ts
+import { lstatSync, realpathSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+function canonical(file) {
+  const absolute = path.isAbsolute(file) ? file : `${process.cwd()}${path.sep}${file}`;
+  let current = path.parse(absolute).root;
+  for (const part of absolute.slice(current.length).split(process.platform === "win32" ? /[\\/]/ : /\//)) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      current = path.dirname(current);
+      continue;
+    }
+    const candidate = path.join(current, part);
+    try {
+      current = realpathSync.native(candidate);
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+      try {
+        if (lstatSync(candidate).isSymbolicLink()) throw new Error("Dangling symlink");
+      } catch (infoError) {
+        if (infoError?.code !== "ENOENT") throw infoError;
+      }
+      current = candidate;
+    }
+  }
+  return current;
+}
+var contains = (root, file) => {
+  const relative = path.relative(root, file);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+};
+function writablePath(file, workdir) {
+  if (typeof file !== "string" || !file.trim() || file.includes("\0")) return false;
+  try {
+    const target = canonical(path.isAbsolute(file) ? file : `${workdir}${path.sep}${file}`);
+    return contains(canonical(workdir), target) || contains(canonical(os.tmpdir()), target);
+  } catch {
+    return false;
+  }
+}
+export {
+  writablePath
+};

package/dist/process-info.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Telling a process from a later one that reuses its pid (ALPD §32): a pid alone
+ * can name an unrelated process once the first one is gone, so ALP also records
+ * when the process started, and compares that.
+ */
+/** When this process started, in milliseconds since the epoch. */
+export declare const OWN_START: number;
+/** When process `pid` started, from ps (PowerShell on Windows); undefined where they cannot tell. */
+export declare function processStartedAt(pid: number): number | undefined;
+/**
+ * Whether the process that started at `startedAt` as `pid` still runs. Without a
+ * start time, or where ps cannot tell, a live pid counts as that process.
+ */
+export declare function sameProcessAlive(pid: number, startedAt?: number): boolean;

package/dist/process-info.js

@@ -0,0 +1,32 @@
+// packages/runtime/src/process-info.ts
+import { execFileSync } from "node:child_process";
+var OWN_START = Math.round(Date.now() - process.uptime() * 1e3);
+var START_TOLERANCE_MS = 2e3;
+function processStartedAt(pid) {
+  try {
+    if (process.platform === "win32") {
+      const out = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `[DateTimeOffset]::new((Get-Process -Id ${Math.trunc(pid)}).StartTime).ToUnixTimeMilliseconds()`], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3, windowsHide: true }).trim();
+      return /^\d+$/.test(out) ? Number(out) : void 0;
+    }
+    const started = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 2e3, env: { ...process.env, LC_ALL: "C" } }).trim();
+    const at = Date.parse(started);
+    return Number.isNaN(at) ? void 0 : at;
+  } catch {
+    return void 0;
+  }
+}
+function sameProcessAlive(pid, startedAt) {
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    if (error?.code !== "EPERM") return false;
+  }
+  if (startedAt === void 0) return true;
+  const actual = processStartedAt(pid);
+  return actual === void 0 || Math.abs(actual - startedAt) < START_TOLERANCE_MS;
+}
+export {
+  OWN_START,
+  processStartedAt,
+  sameProcessAlive
+};

package/dist/providers.d.ts

@@ -0,0 +1,28 @@
+import { type AcpProvider } from './acp-transport.js';
+import { type AntigravityProvider } from './antigravity-transport.js';
+import type { RuntimeKind } from './resolve.js';
+import type { RuntimeOptions, RuntimeTransport } from './contracts.js';
+/** The environment a native harness starts with: the host's, without variables that would tie it to the host's own agent session. */
+export declare function nativeEnvironment(options: RuntimeOptions, extra?: Record<string, string>): NodeJS.ProcessEnv;
+/** Provider factories adapt native harnesses to ALP's normalized transport contract. */
+export type ProviderContext = {
+    options: RuntimeOptions;
+    runtime: RuntimeKind;
+    cwd: string;
+    environment: NodeJS.ProcessEnv;
+    acp?: AcpProvider;
+    antigravity?: AntigravityProvider;
+};
+export type ProviderFactory = (context: ProviderContext) => RuntimeTransport;
+export type ProviderFactories = Partial<Record<RuntimeKind, ProviderFactory>>;
+/** Explicit registry: each runtime instance can override adapters without global state. */
+export declare class ProviderRegistry {
+    private readonly factories;
+    constructor(factories?: Record<string, ProviderFactory | undefined>);
+    register(id: string, factory: ProviderFactory): this;
+    create(id: string, context: ProviderContext): RuntimeTransport;
+    has(id: string): boolean;
+    list(): string[];
+}
+export declare function createProviderRegistry(overrides?: ProviderFactories): ProviderRegistry;
+export declare function createTransport(options: RuntimeOptions, runtimeKind: RuntimeKind, cwd: string, environment: NodeJS.ProcessEnv, acp?: AcpProvider, antigravity?: AntigravityProvider): RuntimeTransport;

package/dist/providers.js

@@ -0,0 +1,71 @@
+// packages/runtime/src/providers.ts
+import { CodexTransport } from "./transport.js";
+import { ClaudeTransport } from "./claude-transport.js";
+import { AcpTransport } from "./acp-transport.js";
+import { AntigravityTransport } from "./antigravity-transport.js";
+function nativeEnvironment(options, extra = {}) {
+  const environment = { ...options.environment ?? process.env, ...extra };
+  for (const key of Object.keys(environment)) {
+    if (/^(PASEO_|CODEX_THREAD_ID$|CODEX_INTERNAL_|CODEX_PARENT_|CLAUDECODE$|CLAUDE_CODE_|ANTHROPIC_AGENT_)/.test(key)) delete environment[key];
+  }
+  return environment;
+}
+var ProviderRegistry = class {
+  factories = /* @__PURE__ */ new Map();
+  constructor(factories = {}) {
+    for (const [id, factory] of Object.entries(factories)) if (factory) this.register(id, factory);
+  }
+  register(id, factory) {
+    if (!id.trim()) throw new Error("A provider needs an id");
+    this.factories.set(id, factory);
+    return this;
+  }
+  create(id, context) {
+    const factory = this.factories.get(id);
+    if (!factory) throw new Error(`Unknown runtime provider: ${id}`);
+    return factory(context);
+  }
+  has(id) {
+    return this.factories.has(id);
+  }
+  list() {
+    return [...this.factories.keys()];
+  }
+};
+function createProviderRegistry(overrides = {}) {
+  return new ProviderRegistry({
+    codex: ({ options, cwd, environment }) => new CodexTransport(
+      options.codexCommand ?? process.env.ALP_CODEX_BIN ?? "codex",
+      cwd,
+      environment
+    ),
+    claude: ({ options, cwd, environment }) => new ClaudeTransport(
+      options.claudeCommand ?? process.env.ALP_CLAUDE_BIN ?? "claude",
+      cwd,
+      environment
+    ),
+    acp: ({ acp, cwd, environment }) => {
+      if (!acp) throw new Error("An ACP session needs its provider");
+      return new AcpTransport(acp, cwd, environment);
+    },
+    antigravity: ({ options, antigravity, cwd, environment }) => new AntigravityTransport(
+      options.antigravityCommand ?? process.env.ALP_ANTIGRAVITY_BIN ?? antigravity?.command ?? "agy",
+      cwd,
+      environment,
+      antigravity
+    ),
+    ...Object.fromEntries(Object.entries(overrides).filter(([, factory]) => factory !== void 0))
+  });
+}
+function createTransport(options, runtimeKind, cwd, environment, acp, antigravity) {
+  if (options.transport) return options.transport(cwd, environment, runtimeKind, acp, antigravity);
+  const registry = options.providerRegistry ?? createProviderRegistry(options.providers);
+  const providerId = runtimeKind === "acp" && acp && registry.has(`acp:${acp.id}`) ? `acp:${acp.id}` : runtimeKind;
+  return registry.create(providerId, { options, runtime: runtimeKind, cwd, environment, acp, antigravity });
+}
+export {
+  ProviderRegistry,
+  createProviderRegistry,
+  createTransport,
+  nativeEnvironment
+};

package/dist/recall.d.ts

@@ -0,0 +1,42 @@
+import type { RuntimeKind } from './resolve.js';
+/**
+ * Finished assignments whose native threads alp_recall can question (ALPD §27).
+ * The threads stay on disk for RECALL_KEEP_MS; then ALP deletes them.
+ */
+export type RecallEntry = {
+    assignmentId: string;
+    rootId: string;
+    /** The requester and its requesters, nearest first: who may recall it besides a root of the project. */
+    requesters: string[];
+    agent: string;
+    project: string;
+    runtime: RuntimeKind;
+    threadId: string;
+    /** Where it worked: the project, or a worktree or copy that may be gone by now. */
+    cwd: string;
+    model: string;
+    thinking?: string;
+    taskId?: string;
+    status: string;
+    finishedAt: string;
+    /** Shared work remains in cwd; a new assignment can build on this brief and handoff. */
+    shared?: {
+        brief: string;
+        summary: string;
+        writeRoot?: string;
+    };
+};
+export declare const RECALL_KEEP_MS: number;
+export declare const RECALL_MAX = 1000;
+export declare const RECALL_QUESTION_CHARS = 4000;
+export declare const RECALL_TIMEOUT_MS = 300000;
+/** The record of recallable threads, kept in `file` when given, else in memory. */
+export declare function createRecallBook(file?: string): {
+    all(): Promise<RecallEntry[]>;
+    add(entry: RecallEntry): Promise<void>;
+    /** Removes and returns the entries past their time, and the oldest beyond RECALL_MAX. */
+    expire(now?: number): Promise<RecallEntry[]>;
+    flush: () => Promise<void>;
+};
+/** What a recalled assignment is told before the question. */
+export declare function recallPrompt(asker: string, question: string): string;

package/dist/recall.js

@@ -0,0 +1,60 @@
+// packages/runtime/src/recall.ts
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+var RECALL_KEEP_MS = 14 * 24 * 60 * 60 * 1e3;
+var RECALL_MAX = 1e3;
+var RECALL_QUESTION_CHARS = 4e3;
+var RECALL_TIMEOUT_MS = 3e5;
+var valid = (entry) => !!entry && typeof entry === "object" && ["assignmentId", "rootId", "agent", "project", "runtime", "threadId", "cwd", "model", "status", "finishedAt"].every((key) => typeof entry[key] === "string") && Array.isArray(entry.requesters);
+function createRecallBook(file) {
+  let entries;
+  let writes = Promise.resolve();
+  const load = () => entries ??= file ? readFile(file, "utf8").then((text) => JSON.parse(text).filter(valid), () => []) : Promise.resolve([]);
+  const save = (list) => {
+    if (!file) return writes;
+    const body = JSON.stringify(list, null, 2) + "\n";
+    writes = writes.then(async () => {
+      await mkdir(path.dirname(file), { recursive: true, mode: 448 });
+      const temporary = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+      await writeFile(temporary, body, { mode: 384 });
+      await rename(temporary, file);
+    }).catch(() => {
+    });
+    return writes;
+  };
+  return {
+    async all() {
+      return [...await load()];
+    },
+    async add(entry) {
+      const list = await load();
+      list.push(entry);
+      await save(list);
+    },
+    /** Removes and returns the entries past their time, and the oldest beyond RECALL_MAX. */
+    async expire(now = Date.now()) {
+      const list = await load();
+      const kept = list.filter((entry) => now - Date.parse(entry.finishedAt) < RECALL_KEEP_MS).slice(-RECALL_MAX);
+      if (kept.length === list.length) return [];
+      const gone = list.filter((entry) => !kept.includes(entry));
+      list.splice(0, list.length, ...kept);
+      await save(list);
+      return gone;
+    },
+    flush: () => writes
+  };
+}
+function recallPrompt(asker, question) {
+  return `ALP recall: ${asker} asks about the assignment you finished in this conversation. Answer from what you did, saw and decided then; read files only to check a detail. This is a read-only copy of your session: change nothing, and do not call ALP tools; they are unavailable. Answer briefly and concretely.
+
+Question: ${question}`;
+}
+export {
+  RECALL_KEEP_MS,
+  RECALL_MAX,
+  RECALL_QUESTION_CHARS,
+  RECALL_TIMEOUT_MS,
+  createRecallBook,
+  recallPrompt
+};

package/dist/resolve.d.ts

@@ -0,0 +1,121 @@
+import type { AcpProvider } from './acp-transport.js';
+import type { AntigravityProvider } from './antigravity-transport.js';
+import type { ResolvedAgent } from '@anhlp/alp-core/types';
+import type { AlpRuntimeAdapter } from '@anhlp/alp-core/adapter';
+/** Codex and Claude Code, or an ACP agent the user's library defines (ALPD §46). */
+import type { RuntimeKind } from '@anhlp/alp-protocol/dto';
+export type { RuntimeKind } from '@anhlp/alp-protocol/dto';
+import type { SessionSpec } from '@anhlp/alp-protocol/session';
+export type { HostMcpServer, SessionSpec } from '@anhlp/alp-protocol/session';
+export type ResolvedSession = Awaited<ReturnType<typeof resolveSession>>;
+/** The description in a SKILL.md's frontmatter, on one line; empty when it has none. */
+export declare function skillDescription(file: string): Promise<string>;
+/**
+ * Composes project and agent instructions with the agent's skills (ALPD §59): each by
+ * name, file and description, so an agent knows which work a skill is for without
+ * opening it, and opens it before that work.
+ */
+export declare class InstructionsAdapter implements AlpRuntimeAdapter<{
+    instructions: string;
+    mcp: ResolvedAgent['mcp'];
+    runtime: ResolvedAgent['runtime'];
+}> {
+    id: string;
+    capabilities(): {
+        readonly instructions: "emulated";
+        readonly skills: "emulated";
+        readonly hooks: "emulated";
+        readonly mcp: "native";
+    };
+    compile(agent: ResolvedAgent): Promise<{
+        adapterId: string;
+        agentName: string;
+        projectRoot: string;
+        material: {
+            instructions: string;
+            mcp: import("@anhlp/alp-core/types").ResolvedMcpConfig;
+            runtime: {
+                provider?: string;
+                model?: string;
+                reasoning?: string;
+            };
+        };
+    }>;
+}
+/** Lessons main recorded after supervisor reviews; the newest are kept when the file grows. */
+export declare const LESSONS_FILE = "lessons.md";
+/** Agents that advise, review, or watch: they never write, and take no tasks. */
+export declare const READ_ONLY_AGENTS: string[];
+export declare function resolveSession(spec: SessionSpec, options?: {
+    templates?: Record<string, string>;
+    library?: string;
+    language?: string; /** False for a preview: it writes nothing (D31). */
+    initialize?: boolean;
+}): Promise<{
+    autocompact: number | undefined;
+    language: string;
+    context?: number | undefined;
+    instructions: string;
+    mcp: Record<string, unknown>;
+    env: {
+        [x: string]: string;
+    };
+    persist: boolean;
+    keepThread: boolean;
+    copyOf?: string | undefined;
+    mode: string;
+    permissions: import("@anhlp/alp-core/permissions").PermissionProfile | null;
+    thinking: string;
+    threadId: string | undefined;
+    workdir: string;
+    copy: boolean;
+    antigravity?: AntigravityProvider | undefined;
+    acp?: AcpProvider | undefined;
+    agent: import("@anhlp/alp-core/types").ResolvedAgent;
+    workflow: {
+        mode: string;
+        maxPeers: number;
+        supervisor: boolean;
+    };
+    team: {
+        id: string;
+        source: "builtin" | "library" | "project";
+        label: string;
+        description?: string;
+        main: string;
+        members: Record<string, {
+            role?: string;
+            model?: string;
+            thinking?: string;
+        }>;
+        delegation: Record<string, string[]>;
+        oracleThinking?: Record<string, string>;
+        oracleModels?: string[];
+        maxPeers?: number;
+        supervisor: false | {
+            agent: string;
+            model?: string;
+            thinking?: string;
+        };
+        houseRules: string;
+    } | undefined;
+    oracleModels: string[];
+    modelProfiles: Record<string, import("@anhlp/alp-core/types").AgentModelConfig[]>;
+    houseRules: string;
+    hooks: {
+        name: string;
+        path: string;
+        project: boolean;
+        event: string;
+        command: string;
+        blocking?: boolean;
+        timeoutSec?: number;
+        match?: {
+            agent?: string;
+            label?: string;
+        };
+        description?: string;
+    }[];
+    runtimeKind: RuntimeKind;
+    model: any;
+}>;

package/dist/resolve.js

@@ -0,0 +1,238 @@
+// packages/runtime/src/resolve.ts
+import path from "node:path";
+import { access, readFile, stat } from "node:fs/promises";
+import { defaultTeam, resolveWorkflow } from "@anhlp/alp-core/workflow";
+import { initProject } from "@anhlp/alp-core/init";
+import { profileModel, agentProfiles, selectedProfile } from "@anhlp/alp-core/profiles";
+import { jsonObject, resolveAgent } from "@anhlp/alp-core/resolver";
+import { resolveTeam, teamOf } from "@anhlp/alp-core/teams";
+import { loadHooks } from "@anhlp/alp-core/hooks";
+import { acpModel, loadProvider } from "@anhlp/alp-core/providers";
+import { ensureLibrary } from "@anhlp/alp-core/library";
+import { compileAgent } from "@anhlp/alp-core/adapter";
+import { capMode, profileFor } from "@anhlp/alp-core/permissions";
+import { userLanguage } from "@anhlp/alp-core/user-settings";
+import { claudeSandboxAvailable } from "./claude-transport.js";
+import { DEFAULT_ANTIGRAVITY_MODEL, DEFAULT_CLAUDE_MODEL, DEFAULT_MODEL, ORACLE_MODELS, ORACLE_THINKING, models, modes, thinkingOptions, thinkingOptionsFor } from "./catalog.js";
+async function exists(target) {
+  try {
+    await access(target);
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+var SKILL_DESCRIPTION_CHARS = 400;
+async function skillDescription(file) {
+  const text = await readFile(file, "utf8").catch(() => "");
+  const front = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text)?.[1] ?? "";
+  const match = /^description:[ \t]*(.*(?:\r?\n[ \t]+.*)*)/m.exec(front)?.[1] ?? "";
+  const flat = match.replace(/^[>|][-+]?/, "").replace(/\s+/g, " ").trim().replace(/^(['"])(.*)\1$/, "$2");
+  return flat.length > SKILL_DESCRIPTION_CHARS ? `${flat.slice(0, SKILL_DESCRIPTION_CHARS - 1)}\u2026` : flat;
+}
+var InstructionsAdapter = class {
+  id = "native";
+  // ALP runs an agent's hooks itself, at its own events (ALPD §45).
+  capabilities() {
+    return { instructions: "emulated", skills: "emulated", hooks: "emulated", mcp: "native" };
+  }
+  async compile(agent) {
+    const listed = await Promise.all(agent.skills.map(async (skill) => {
+      const description = await skillDescription(skill.path);
+      return `- ${skill.name} (${skill.path})${description ? `: ${description}` : ""}`;
+    }));
+    const skills = listed.length ? "Your skills: methods written for kinds of work. Before you start work that a skill's description matches, read its SKILL.md and follow it; say which skill you use.\n" + listed.join("\n") : "";
+    return { adapterId: this.id, agentName: agent.name, projectRoot: agent.projectRoot, material: {
+      instructions: [agent.instructions.project, agent.instructions.agent, skills].filter(Boolean).join("\n\n"),
+      mcp: agent.mcp,
+      runtime: agent.runtime
+    } };
+  }
+};
+var LESSONS_FILE = "lessons.md";
+var LESSON_CHARS = 6e3;
+async function lessons(file) {
+  const text = (await readFile(file, "utf8").catch(() => "")).trim();
+  return text.length > LESSON_CHARS ? `\u2026
+${text.slice(-LESSON_CHARS)}` : text;
+}
+var READ_ONLY_AGENTS = ["oracle", "reviewer", "supervisor"];
+async function resolveSession(spec, options = {}) {
+  if (!path.isAbsolute(spec.cwd) || !(await stat(spec.cwd)).isDirectory()) throw new Error("Session cwd must be an existing absolute directory");
+  if (spec.workdir !== void 0 && (!path.isAbsolute(spec.workdir) || !(await stat(spec.workdir)).isDirectory())) throw new Error("Session workdir must be an existing absolute directory");
+  const starter = options.templates ? { templates: options.templates } : {};
+  if (options.initialize !== false) {
+    const settingsFile = path.join(spec.cwd, ".alp", "settings.json");
+    const scaffoldMissing = !await exists(path.join(spec.cwd, "ALP.md")) || !await exists(settingsFile);
+    if (scaffoldMissing) await initProject(spec.cwd, { ...starter, library: options.library });
+    else if (!spec.restore) {
+      const settings = await jsonObject(settingsFile, "INVALID_SETTINGS");
+      await initProject(spec.cwd, { ...starter, library: options.library, onlyManagedProfiles: true, teamIds: [spec.workflow === void 0 ? defaultTeam(settings) : teamOf(spec.workflow)] });
+    }
+  }
+  if (options.library) await ensureLibrary(options.library, options.templates ? { templates: options.templates } : {});
+  const restored = spec.restore;
+  if (restored && spec.agent !== void 0 && spec.agent !== restored.agent) throw new Error("Cannot resume a thread as a different ALP agent");
+  const { team, ...workflow } = await resolveWorkflow(spec.cwd, spec.workflow, restored?.workflow, { library: options.library, templates: options.templates, scaffold: options.initialize === false });
+  const agent = await resolveAgent(spec.cwd, { agent: spec.agent ?? restored?.agent, library: options.library, templates: options.templates });
+  const oracleModels = team?.oracleModels ?? ORACLE_MODELS;
+  if (agent.name === "oracle" && !restored && !oracleModels.includes(spec.model ?? "")) throw new Error(`Oracle runs on ${oracleModels.join(" or ")}; choose one`);
+  const projectSettings = await jsonObject(path.join(spec.cwd, ".alp/settings.json"), "INVALID_SETTINGS");
+  const profile = (projectSettings.team ?? projectSettings.profile)?.[workflow.mode]?.[agent.name];
+  const modelProfiles = Object.fromEntries(Object.entries((projectSettings.team ?? projectSettings.profile)?.[workflow.mode] ?? {}).map(([name, config]) => [name, agentProfiles(config, name)]));
+  const requestedModel = restored?.model ? `${restored.runtime ?? agent.runtime.provider ?? "codex"}:${restored.model}` : spec.model;
+  const profileChoice = selectedProfile(modelProfiles[agent.name] ?? [], requestedModel);
+  const projectModel = profileModel(profileChoice);
+  const compiled = await compileAgent(new InstructionsAdapter(), agent);
+  const base = team ?? await resolveTeam(void 0, "pho", { templates: options.templates });
+  const main = base.main;
+  const member = Object.hasOwn(base.members, agent.name) && (team || agent.name === main) ? base.members[agent.name] : void 0;
+  const sameModel = (id) => id === void 0 || restored?.model === void 0 || `${restored.runtime}:${restored.model}` === id || restored.model === id;
+  const teamChoice = member && !agent.projectRuntime?.model && !agent.projectRuntime?.provider && spec.model === void 0 && sameModel(member.model) ? member : void 0;
+  let runtimeKind = restored?.runtime ?? profileChoice?.provider ?? (teamChoice?.model ? void 0 : agent.runtime.provider) ?? "codex";
+  let model = restored?.model ?? spec.model ?? projectModel ?? teamChoice?.model ?? agent.runtime.model ?? (runtimeKind === "claude" ? DEFAULT_CLAUDE_MODEL : DEFAULT_MODEL);
+  if (model.startsWith("codex:")) {
+    runtimeKind = "codex";
+    model = model.slice("codex:".length);
+  }
+  if (model.startsWith("claude:")) {
+    runtimeKind = "claude";
+    model = model.slice("claude:".length);
+  }
+  if (model.startsWith("codex/")) {
+    runtimeKind = "codex";
+    model = model.slice("codex/".length);
+  }
+  if (model.startsWith("claude/")) {
+    runtimeKind = "claude";
+    model = model.slice("claude/".length);
+  }
+  if (model.startsWith("antigravity:")) {
+    runtimeKind = "antigravity";
+    model = model.slice("antigravity:".length);
+  }
+  if (model.startsWith("antigravity/")) {
+    runtimeKind = "antigravity";
+    model = model.slice("antigravity/".length);
+  }
+  if (model.startsWith("acp:")) {
+    const raw = model.slice("acp:".length);
+    if (raw.startsWith("antigravity/") || raw === "antigravity") {
+      runtimeKind = "antigravity";
+      model = raw.startsWith("antigravity/") ? raw.slice("antigravity/".length) : "";
+    } else {
+      runtimeKind = "acp";
+      model = raw;
+    }
+  }
+  if (runtimeKind === "antigravity") {
+    if (!model.trim() || model === DEFAULT_MODEL) model = DEFAULT_ANTIGRAVITY_MODEL;
+  }
+  if (!["codex", "claude", "acp", "antigravity"].includes(runtimeKind)) {
+    model = model === DEFAULT_MODEL && agent.runtime.model !== DEFAULT_MODEL ? runtimeKind : `${runtimeKind}/${model}`;
+    runtimeKind = "acp";
+  }
+  if (restored?.runtime && runtimeKind !== restored.runtime) throw new Error("Cannot resume a thread with a different runtime provider");
+  let acp;
+  if (runtimeKind === "acp") {
+    const { provider: id, model: native } = acpModel(model);
+    acp = await loadProvider(options.library, id);
+    if (!acp) throw new Error(`No ACP provider '${id}': add one to your library with alp provider add ${id}, or name codex or claude`);
+    if (acp.enabled === false) throw new Error(`ACP provider '${id}' is turned off; turn it on in the web app's Providers settings or in providers/${id}.json`);
+    const listed = [...acp.models ?? [], ...acp.additionalModels ?? []];
+    if (native && acp.models && !listed.some((candidate) => candidate.id === native)) throw new Error(`ACP provider '${id}' lists no model '${native}'`);
+    if (spec.copy) throw new Error("A review copy cannot run on an ACP agent: ALP cannot keep its commands inside the copy");
+  }
+  let antigravity;
+  if (runtimeKind === "antigravity") {
+    const provider = await loadProvider(options.library, "antigravity");
+    if (provider && provider.kind === "antigravity") {
+      antigravity = provider;
+      if (antigravity.enabled === false) throw new Error("Antigravity provider 'antigravity' is turned off; turn it on in the web app's Providers settings or in providers/antigravity.json");
+    }
+  }
+  const permissions = await profileFor(agent.projectRoot, options.library, agent.name);
+  const requested = spec.mode ?? agent.mode ?? (agent.name === main ? "full-access" : "read-only");
+  const mode = permissions ? capMode(requested, permissions.base) : requested;
+  if (runtimeKind === "antigravity") {
+    if (mode !== "full-access" && !(mode === "read-only" && antigravity?.readOnlyMode === "instructions")) throw new Error('Antigravity currently supports only full-access; read-only requires explicit readOnlyMode: "instructions" and is not sandboxed');
+    if (spec.copy || permissions?.workdir === "copy") throw new Error("Antigravity cannot enforce isolation for a review copy");
+    if (permissions && (permissions.deny.length || permissions.ask.length || permissions.allow.length || permissions.beyondMode === "ask")) {
+      throw new Error("Antigravity cannot enforce custom permission rules");
+    }
+  }
+  const availableThinking = ["acp", "antigravity"].includes(runtimeKind) ? [] : thinkingOptionsFor(runtimeKind, model);
+  const preferred = ["acp", "antigravity"].includes(runtimeKind) ? "none" : spec.thinking ?? profileChoice?.effort ?? agent.projectRuntime?.reasoning ?? (agent.name === "oracle" ? team?.oracleThinking?.[`${runtimeKind}:${model}`] ?? team?.oracleThinking?.[runtimeKind] : void 0) ?? teamChoice?.thinking ?? agent.runtime.reasoning ?? (agent.name === "oracle" ? ORACLE_THINKING : availableThinking.length ? "medium" : "none");
+  const thinking = spec.thinking === void 0 && availableThinking.length && !availableThinking.some((candidate) => candidate.id === preferred) ? models.find((candidate) => candidate.id === `${runtimeKind}:${model}`)?.defaultThinkingOptionId ?? availableThinking[0].id : preferred;
+  if (!model.trim()) throw new Error("Model must be nonempty");
+  if (!modes.some((m) => m.id === mode)) throw new Error(`Unsupported mode '${mode}'`);
+  if (spec.copy && runtimeKind === "claude" && !claudeSandboxAvailable()) throw new Error("A review copy on Claude needs its Bash sandbox (Seatbelt on macOS; bubblewrap and socat on Linux)");
+  if (!thinkingOptions.some((m) => m.id === thinking)) throw new Error(`Unsupported thinking option '${thinking}'`);
+  if (availableThinking.length && !availableThinking.some((candidate) => candidate.id === thinking)) throw new Error(`Thinking option '${thinking}' is unsupported by ${runtimeKind}:${model}`);
+  const mcp = {};
+  for (const [name, value] of Object.entries(compiled.material.mcp.mcpServers)) {
+    const { headers, ...rest } = value;
+    Object.defineProperty(mcp, name, { value: { ...rest, ...headers ? { http_headers: headers } : {} }, enumerable: true, writable: true });
+  }
+  for (const [name, value] of Object.entries(spec.mcpServers ?? {})) {
+    if (Object.hasOwn(mcp, name)) throw new Error(`MCP server name collision: '${name}'`);
+    if (value.type === "sse") throw new Error(`SSE MCP server '${name}' is unsupported by this runtime`);
+    const server = value.type === "stdio" ? { command: value.command, args: value.args ?? [], env: value.env ?? {} } : { url: value.url, http_headers: value.headers ?? {} };
+    Object.defineProperty(mcp, name, { value: server, enumerable: true, writable: true });
+  }
+  let learned = "";
+  const supervisorAgent = team?.supervisor ? team.supervisor.agent : void 0;
+  if ([main, supervisorAgent].includes(agent.name) && workflow.supervisor) {
+    const user = options.library ? await lessons(path.join(options.library, LESSONS_FILE)) : "";
+    const project = await lessons(path.join(agent.projectRoot, ".alp", LESSONS_FILE));
+    if (user || project) {
+      learned = "Lessons main recorded after earlier supervisor reviews. Follow them; they are the user's process, not a task." + (user ? `
+
+For every project:
+${user}` : "") + (project ? `
+
+For this project:
+${project}` : "");
+    }
+  }
+  const houseRules = base.houseRules;
+  const hooks = await loadHooks(agent);
+  return {
+    agent,
+    workflow,
+    team,
+    oracleModels,
+    modelProfiles,
+    houseRules,
+    hooks,
+    runtimeKind,
+    model,
+    ...acp ? { acp } : {},
+    ...antigravity ? { antigravity } : {},
+    mode,
+    permissions,
+    thinking,
+    threadId: restored?.threadId,
+    workdir: spec.workdir ?? agent.projectRoot,
+    copy: Boolean(spec.copy && spec.workdir),
+    ...spec.copy && spec.copyOf ? { copyOf: spec.copyOf } : {},
+    instructions: [compiled.material.instructions, learned, spec.systemPrompt].filter(Boolean).join("\n\n"),
+    mcp,
+    env: { ...spec.env },
+    persist: spec.persist ?? false,
+    keepThread: spec.keepThread ?? false,
+    // ALPD §57: the window the agent works in before its runtime compacts; absent, the model's.
+    ...agent.context ? { context: agent.context } : {},
+    autocompact: typeof profile?.autocompact === "number" ? profile.autocompact : typeof agent.autocompact === "number" ? agent.autocompact : void 0,
+    // ALPD §54: the language everything the user reads is written in.
+    language: options.language ?? await userLanguage(options.library)
+  };
+}
+export {
+  InstructionsAdapter,
+  LESSONS_FILE,
+  READ_ONLY_AGENTS,
+  resolveSession,
+  skillDescription
+};