@anhlp/alp-core 0.0.0-beta.1

package/dist/library.js

@@ -0,0 +1,108 @@
+// 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 { createHash, randomUUID } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { AlpError } from "./errors.js";
+function alpHome(env = process.env) {
+  return path.resolve(env.ALP_HOME || path.join(os.homedir(), ".alp"));
+}
+var MANIFEST = "library.json";
+var sha = (text) => createHash("sha256").update(text.replaceAll("\r\n", "\n")).digest("hex");
+async function optional(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function shippedFiles({ templateRoot, templates }) {
+  if (templates) return Object.fromEntries(Object.entries(templates).filter(([name]) => name === "role-skills.json" || name.startsWith("skills/") || name.startsWith("providers/")));
+  const root = templateRoot ?? shippedTemplateRoot();
+  const files = { "role-skills.json": await readFile(new URL("role-skills.json", root), "utf8") };
+  async function walk(relative) {
+    for (const entry of await readdir(new URL(`${relative}/`, root), { withFileTypes: true })) {
+      if (entry.isDirectory()) await walk(`${relative}/${entry.name}`);
+      else if (entry.isFile()) files[`${relative}/${entry.name}`] = await readFile(new URL(`${relative}/${entry.name}`, root), "utf8");
+    }
+  }
+  await walk("skills");
+  await walk("providers");
+  return files;
+}
+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: {} };
+  const created = [];
+  const updated = [];
+  for (const [name, content] of Object.entries(shipped).sort(([a], [b]) => a.localeCompare(b))) {
+    const target = path.join(home, ...name.split("/"));
+    const current = await optional(target);
+    const seeded = manifest.files[name];
+    if (seeded === void 0) {
+      if (current !== void 0) continue;
+      await mkdir(path.dirname(target), { recursive: true });
+      await writeFile(target, content, { flag: "wx" }).catch((error) => {
+        if (error.code !== "EEXIST") throw error;
+      });
+      manifest.files[name] = sha(content);
+      created.push(name);
+    } else if (current !== void 0 && sha(current) === seeded && seeded !== sha(content)) {
+      await writeFile(target, content);
+      manifest.files[name] = sha(content);
+      updated.push(name);
+    }
+  }
+  if (created.length || updated.length || manifestText === void 0) {
+    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);
+  }
+  return { created, updated };
+}
+var seeding = /* @__PURE__ */ new Map();
+function ensureLibrary(home, options = {}) {
+  let done = seeding.get(home);
+  if (!done) {
+    done = seedLibrary(home, options).catch((error) => {
+      seeding.delete(home);
+      throw error;
+    });
+    seeding.set(home, done);
+  }
+  return done;
+}
+var skillName = (name) => typeof name === "string" && /^[\w.-]+$/.test(name) && name !== "." && name !== "..";
+async function librarySkills(home, agent) {
+  const file = path.join(home, "role-skills.json");
+  const text = await optional(file);
+  if (text === void 0) return [];
+  let roles;
+  try {
+    roles = JSON.parse(text);
+  } catch (cause) {
+    throw new AlpError("INVALID_LIBRARY", `${file}: ${cause.message}`, { cause });
+  }
+  if (!roles || typeof roles !== "object" || Array.isArray(roles)) throw new AlpError("INVALID_LIBRARY", `${file}: expected an object of role names to skill lists`);
+  const names = roles[agent] ?? [];
+  if (!Array.isArray(names) || !names.every(skillName)) throw new AlpError("INVALID_LIBRARY", `${file}: ${agent} must list skill directory names`);
+  const skills = [];
+  for (const name of new Set(names)) {
+    const skillPath = path.join(home, "skills", name, "SKILL.md");
+    if (await optional(skillPath) !== void 0) skills.push({ name, path: skillPath });
+  }
+  return skills;
+}
+export {
+  alpHome,
+  ensureLibrary,
+  librarySkills,
+  seedLibrary
+};

package/dist/log.d.ts

@@ -0,0 +1,37 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export const LEVELS: Readonly<Record<LogLevel, number>>;
+export const REDACTED: string;
+export const OMITTED: string;
+export type LogFields = {
+  code?: string;
+  error?: unknown;
+  sessionId?: string;
+  rootId?: string;
+  assignmentId?: string;
+  clientMessageId?: string;
+  requestId?: string;
+  agent?: string;
+  [key: string]: unknown;
+};
+export type LogRecord = {
+  time: string;
+  level: LogLevel;
+  component: string;
+  code?: string;
+  msg: string;
+  error?: { name?: string; code?: string | number; message: string; stack?: string; cause?: unknown };
+  [key: string]: unknown;
+};
+export type Logger = {
+  component: string;
+  debug(message: string, fields?: LogFields): void;
+  info(message: string, fields?: LogFields): void;
+  warn(message: string, fields?: LogFields): void;
+  error(message: string, fields?: LogFields): void;
+  child(extra?: LogFields, component?: string): Logger;
+};
+export function scrubText(text: unknown, options?: { env?: Record<string, string | undefined>; max?: number }): string;
+export function describeError(error: unknown, options?: { env?: Record<string, string | undefined> }): { name?: string; code?: string | number; message: string; stack?: string; cause?: unknown };
+export function redact(value: unknown, options?: { env?: Record<string, string | undefined> }): any;
+export function createLogger(options: { component: string; level?: LogLevel; context?: LogFields; write?: (line: string) => void; now?: () => Date; env?: Record<string, string | undefined> }): Logger;
+export function readLogTail(file: string, options?: { bytes?: number; env?: Record<string, string | undefined> }): Promise<Array<LogRecord | { legacy: string }>>;

package/dist/log.js

@@ -0,0 +1,156 @@
+// packages/core/src/log.js
+import { open, stat } from "node:fs/promises";
+var LEVELS = Object.freeze({ debug: 10, info: 20, warn: 30, error: 40 });
+var REDACTED = "[redacted]";
+var OMITTED = "[omitted]";
+var MAX_STRING = 2e3;
+var MAX_DEPTH = 5;
+var MAX_KEYS = 50;
+var MAX_ITEMS = 20;
+var STACK_LINES = 8;
+var SECRET_KEY = /pass(word|wd)?|secret|token|api[-_]?key|authorization|credential|cookie|private[-_]?key|bearer|signature/i;
+var OMITTED_KEY = /^(env|environment|prompt|prompts|instructions|content|text|input|headers|body|args|argv)$/i;
+var SECRET_NAME = /KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTH|COOKIE|PRIVATE/i;
+var PATTERNS = [
+  [/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, `$1 ${REDACTED}`],
+  [/\b(sk|rk|pk)-[A-Za-z0-9_-]{16,}/g, REDACTED],
+  [/\bgh[pousr]_[A-Za-z0-9]{20,}/g, REDACTED],
+  [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, REDACTED],
+  [/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, REDACTED],
+  [/\bAKIA[0-9A-Z]{16}\b/g, REDACTED],
+  [/\bAIza[0-9A-Za-z_-]{30,}/g, REDACTED],
+  [/\beyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}/g, REDACTED],
+  [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(-----END [A-Z ]*PRIVATE KEY-----|$)/g, REDACTED],
+  [/(\b[a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/gi, `$1${REDACTED}@`],
+  // NAME=value and NAME: value for names that look like secrets; also JSON "token": "value".
+  [/(\b[\w.-]*(?:key|token|secret|passw(?:or)?d|credential|authorization|cookie)[\w.-]*["']?\s*[=:]\s*)(?:"[^"]{4,}"|'[^']{4,}'|[^\s,;&"']{8,})/gi, `$1${REDACTED}`],
+  // --token value, --api-key value
+  [/(--[\w-]*(?:key|token|secret|passw(?:or)?d|credential)[\w-]*\s+)[^\s-][^\s]*/gi, `$1${REDACTED}`]
+];
+function secretValues(env) {
+  const values = /* @__PURE__ */ new Set();
+  for (const [name, value] of Object.entries(env ?? {})) if (typeof value === "string" && value.length >= 8 && SECRET_NAME.test(name)) values.add(value);
+  return [...values].sort((a, b) => b.length - a.length);
+}
+function scrubText(text, { env = process.env, max = MAX_STRING } = {}) {
+  let result = String(text);
+  for (const value of secretValues(env)) result = result.split(value).join(REDACTED);
+  for (const [pattern, replacement] of PATTERNS) result = result.replace(pattern, replacement);
+  return result.length > max ? `${result.slice(0, max)}... (${result.length - max} more characters)` : result;
+}
+function describeError(error, options = {}) {
+  if (!(error instanceof Error)) return { message: scrubText(error, options) };
+  const stack = typeof error.stack === "string" ? error.stack.split("\n").slice(0, STACK_LINES).join("\n") : void 0;
+  return {
+    name: error.name,
+    ...typeof error.code === "string" || typeof error.code === "number" ? { code: error.code } : {},
+    message: scrubText(error.message, options),
+    ...stack ? { stack: scrubText(stack, options) } : {},
+    ...error.cause !== void 0 ? { cause: describeError(error.cause, options) } : {}
+  };
+}
+function redact(value, options = {}, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || value === void 0 || typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "string") return scrubText(value, options);
+  if (typeof value === "bigint") return String(value);
+  if (typeof value !== "object") return void 0;
+  if (value instanceof Error) return describeError(value, options);
+  if (seen.has(value)) return "[circular]";
+  if (depth >= MAX_DEPTH) return "[too deep]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const items = value.slice(0, MAX_ITEMS).map((item) => redact(item, options, depth + 1, seen));
+    return value.length > MAX_ITEMS ? [...items, `... ${value.length - MAX_ITEMS} more`] : items;
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value).slice(0, MAX_KEYS)) {
+    result[key] = OMITTED_KEY.test(key) ? OMITTED : SECRET_KEY.test(key) ? REDACTED : redact(item, options, depth + 1, seen);
+  }
+  return result;
+}
+var CORRELATION = ["sessionId", "rootId", "assignmentId", "clientMessageId", "requestId", "agent"];
+var stderrSink = (line) => {
+  try {
+    process.stderr.write(`${line}
+`);
+  } catch {
+  }
+};
+function createLogger({ component, level, context = {}, write = stderrSink, now = () => /* @__PURE__ */ new Date(), env = process.env } = {}) {
+  const threshold = LEVELS[level ?? env.ALP_LOG_LEVEL] ?? LEVELS.info;
+  const options = { env };
+  const emit = (name, message, fields = {}) => {
+    if (LEVELS[name] < threshold) return;
+    try {
+      const { code, error, ...rest } = { ...context, ...fields };
+      const record = {
+        time: now().toISOString(),
+        level: name,
+        component,
+        ...code ? { code: String(code) } : {},
+        msg: scrubText(message, options)
+      };
+      for (const key of CORRELATION) if (rest[key] !== void 0) record[key] = redact(String(rest[key]), options);
+      if (error !== void 0) {
+        record.error = describeError(error, options);
+        if (!record.code && record.error.code !== void 0) record.code = String(record.error.code);
+      }
+      for (const [key, value] of Object.entries(rest)) {
+        if (CORRELATION.includes(key)) continue;
+        record[key] = OMITTED_KEY.test(key) ? OMITTED : SECRET_KEY.test(key) ? REDACTED : redact(value, options);
+      }
+      write(JSON.stringify(record));
+    } catch {
+    }
+  };
+  return {
+    component,
+    debug: (message, fields) => emit("debug", message, fields),
+    info: (message, fields) => emit("info", message, fields),
+    warn: (message, fields) => emit("warn", message, fields),
+    error: (message, fields) => emit("error", message, fields),
+    child: (extra = {}, name = component) => createLogger({ component: name, level, context: { ...context, ...extra }, write, now, env })
+  };
+}
+var TAIL_BYTES = 256 * 1024;
+async function readLogTail(file, { bytes = TAIL_BYTES, env = process.env } = {}) {
+  let handle;
+  try {
+    handle = await open(file, "r");
+    const { size } = await stat(file);
+    const start = Math.max(0, size - bytes);
+    const buffer = Buffer.alloc(size - start);
+    await handle.read(buffer, 0, buffer.length, start);
+    const lines = buffer.toString("utf8").split("\n");
+    if (start > 0) lines.shift();
+    const records = [];
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const record = JSON.parse(line);
+        if (record && typeof record === "object" && typeof record.time === "string" && typeof record.level === "string" && typeof record.msg === "string") {
+          records.push(redact(record, { env }));
+          continue;
+        }
+      } catch {
+      }
+      records.push({ legacy: scrubText(line, { env, max: 500 }) });
+    }
+    return records;
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  } finally {
+    await handle?.close();
+  }
+}
+export {
+  LEVELS,
+  OMITTED,
+  REDACTED,
+  createLogger,
+  describeError,
+  readLogTail,
+  redact,
+  scrubText
+};

package/dist/migrations.d.ts

@@ -0,0 +1,9 @@
+export type Migration = { from: number; to: number; name: string; run(home: string): Promise<void> };
+export const MIGRATIONS: Migration[];
+export type MigrationResult = { from: number; to: number; steps: Array<{ name: string; from: number; to: number; backup: string; resumed: boolean }> };
+export function migrateState(home: string, options?: {
+  by?: string;
+  migrations?: Migration[];
+  target?: number;
+  log?: { info(message: string, fields?: object): void; warn(message: string, fields?: object): void };
+}): Promise<MigrationResult>;

package/dist/migrations.js

@@ -0,0 +1,95 @@
+// packages/core/src/migrations.js
+import { readdir, readFile, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { AlpError } from "./errors.js";
+import { writeAtomic } from "./atomic.js";
+import { STATE_SCHEMA, assertStateSupported, migrationFile, readStateSchema, stateDir, writeStateSchema } from "./state-schema.js";
+import { STATE_UNITS, automaticBackup, restoreBackup } from "./backup.js";
+async function timelineCursors(home) {
+  const directory = path.join(stateDir(home), "timeline");
+  const names = await readdir(directory).catch((error) => {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  });
+  for (const name of names.filter((name2) => name2.endsWith(".jsonl"))) {
+    const file = path.join(directory, name);
+    const lines = [];
+    let cursor = 0;
+    let changed = false;
+    for (const line of (await readFile(file, "utf8")).split("\n")) {
+      if (!line) continue;
+      let envelope;
+      try {
+        envelope = JSON.parse(line);
+      } catch {
+        lines.push(line);
+        continue;
+      }
+      cursor = typeof envelope?.cursor === "number" && envelope.cursor > cursor ? envelope.cursor : cursor + 1;
+      if (envelope?.cursor === cursor) {
+        lines.push(line);
+        continue;
+      }
+      lines.push(JSON.stringify({ ...envelope, cursor }));
+      changed = true;
+    }
+    if (changed) await writeAtomic(file, lines.map((line) => `${line}
+`).join(""));
+  }
+}
+var MIGRATIONS = [
+  { from: 1, to: 2, name: "timeline-cursors", run: timelineCursors }
+];
+async function readJournal(home) {
+  try {
+    return JSON.parse(await readFile(migrationFile(home), "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return void 0;
+    return {};
+  }
+}
+var exists = (file) => stat(file).then(() => true, () => false);
+async function migrateState(home, { by = "alp", migrations = MIGRATIONS, target = STATE_SCHEMA, log } = {}) {
+  const info = assertStateSupported(await readStateSchema(home), home);
+  let journal = await readJournal(home);
+  if (journal && Number.isSafeInteger(journal.to) && journal.to <= info.schema) {
+    await rm(migrationFile(home), { force: true });
+    journal = void 0;
+  }
+  if (info.fresh && !journal) {
+    await writeStateSchema(home, target, by);
+    return { from: target, to: target, steps: [] };
+  }
+  let schema = info.schema;
+  const steps = [];
+  while (schema < target) {
+    const step = migrations.find((candidate) => candidate.from === schema);
+    if (!step) throw new AlpError("STATE_MIGRATION_MISSING", `ALP has no migration from state schema ${schema}; the state was not changed`);
+    const resumed = journal?.to === step.to && typeof journal.backup === "string" && await exists(journal.backup);
+    const backup = resumed ? journal.backup : await automaticBackup(home, `pre-migrate-v${step.from}-v${step.to}`, { units: STATE_UNITS, by });
+    if (!resumed) await writeAtomic(migrationFile(home), JSON.stringify({ from: step.from, to: step.to, name: step.name, backup, by, startedAt: (/* @__PURE__ */ new Date()).toISOString() }) + "\n");
+    log?.info(`${resumed ? "continuing" : "running"} state migration ${step.name} (schema ${step.from} \u2192 ${step.to}); backup ${backup}`, { code: "ALP_STATE_MIGRATING", from: step.from, to: step.to, migration: step.name, resumed });
+    try {
+      await step.run(home);
+    } catch (error) {
+      try {
+        await restoreBackup({ home, file: backup, projects: false, safety: false, clearLive: false, by });
+      } catch (rollback) {
+        throw new AlpError("STATE_MIGRATION_ROLLBACK_FAILED", `state migration ${step.name} failed (${error?.message ?? error}) and putting the state back from ${backup} failed too (${rollback?.message ?? rollback}); the next start tries the migration again. See docs/alp/data-recovery.md`, { cause: error });
+      }
+      await rm(migrationFile(home), { force: true });
+      throw new AlpError("STATE_MIGRATION_FAILED", `state migration ${step.name} (schema ${step.from} \u2192 ${step.to}) failed: ${error?.message ?? error}; the state was put back from ${backup} and is unchanged. See docs/alp/data-recovery.md`, { cause: error });
+    }
+    await writeStateSchema(home, step.to, by);
+    await rm(migrationFile(home), { force: true });
+    steps.push({ name: step.name, from: step.from, to: step.to, backup, resumed });
+    schema = step.to;
+    journal = void 0;
+  }
+  if (!info.marked && !steps.length) await writeStateSchema(home, schema, by);
+  return { from: info.schema, to: schema, steps };
+}
+export {
+  MIGRATIONS,
+  migrateState
+};

package/dist/models.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @type {Array<{ runtime: 'codex' | 'claude' | 'antigravity', id: string, label: string, description: string, efforts: string[], effort?: string }>}
+ */
+export const MODELS: Array<{
+    runtime: "codex" | "claude" | "antigravity";
+    id: string;
+    label: string;
+    description: string;
+    efforts: string[];
+    effort?: string;
+}>;

package/dist/models.js

@@ -0,0 +1,44 @@
+// packages/core/src/models.js
+var codexFull = ["low", "medium", "high", "xhigh", "max", "ultra"];
+var codexStandard = ["low", "medium", "high", "xhigh", "max"];
+var claudeFull = ["low", "medium", "high", "xhigh", "max", "ultracode"];
+var claudeLegacy = ["off", "low", "medium", "high", "xhigh", "max", "ultracode"];
+var claude46 = ["off", "low", "medium", "high", "max"];
+var MODELS = [
+  ["codex", "gpt-6.1-sol", "GPT-6.1-Sol", "Latest workhorse model for coding and everyday work.", codexFull, "low"],
+  // ALP runs GPT-6 Astra at low effort only.
+  ["codex", "gpt-6-astra", "GPT-6-Astra", "Frontier intelligence for the most demanding work.", ["low"], "low"],
+  ["codex", "gpt-6-sol", "GPT-6-Sol", "Previous generation workhorse model.", codexFull, "low"],
+  ["codex", "gpt-6-luna", "GPT-6-Luna", "Fast and affordable model for easier tasks.", codexStandard, "low"],
+  ["codex", "gpt-5.6-sol", "GPT-5.6-Sol", "Older generation workhorse model.", codexFull, "low"],
+  ["codex", "gpt-5.6-terra", "GPT-5.6-Terra", "Older balanced model for straightforward work.", codexFull, "low"],
+  ["codex", "gpt-5.6-luna", "GPT-5.6-Luna", "Older fast and efficient model.", codexStandard, "low"],
+  ["claude", "claude-opus-5-5", "Opus 5.5", "Latest release.", claudeFull, "medium"],
+  ["claude", "claude-opus-5", "Opus 5", "Previous release.", claudeLegacy, "high"],
+  ["claude", "claude-fable-5-1", "Fable 5.1", "Most powerful model.", claudeFull, "high"],
+  ["claude", "claude-fable-5", "Fable 5", "Previous release.", claudeFull, "high"],
+  ["claude", "claude-opus-4-8[1m]", "Opus 4.8 1M", "Opus 4.8 with 1M context window.", claudeLegacy, "high"],
+  ["claude", "claude-opus-4-8", "Opus 4.8", "Previous release.", claudeLegacy, "high"],
+  ["claude", "claude-sonnet-5-5", "Sonnet 5.5", "Best for everyday tasks.", claudeFull, "medium"],
+  ["claude", "claude-sonnet-5", "Sonnet 5", "Previous release.", claudeLegacy, "high"],
+  ["claude", "claude-sonnet-5[1m]", "Sonnet 5 1M", "Sonnet 5 with 1M context window.", claudeLegacy, "high"],
+  ["claude", "claude-opus-4-7[1m]", "Opus 4.7 1M", "Opus 4.7 with 1M context window.", claudeLegacy, "high"],
+  ["claude", "claude-opus-4-7", "Opus 4.7", "Previous release.", claudeLegacy, "high"],
+  ["claude", "claude-opus-4-6[1m]", "Opus 4.6 1M", "Opus 4.6 with 1M context window.", claude46, "high"],
+  ["claude", "claude-opus-4-6", "Opus 4.6", "Most capable for complex work.", claude46, "high"],
+  ["claude", "claude-sonnet-4-6[1m]", "Sonnet 4.6 1M", "Sonnet 4.6 with 1M context window.", claude46, "high"],
+  ["claude", "claude-sonnet-4-6", "Sonnet 4.6", "Best for everyday tasks.", claude46, "high"],
+  ["claude", "claude-haiku-4-5", "Haiku 4.5", "Fastest for quick answers.", [], void 0],
+  ["claude", "sonnet", "sonnet", "From Claude settings.json model.", [], void 0],
+  ["antigravity", "gemini-3.8-flash-high", "Gemini 3.8 Flash (High)", "High reasoning effort workhorse for complex tasks.", [], void 0],
+  ["antigravity", "gemini-3.8-flash-medium", "Gemini 3.8 Flash (Medium)", "Balanced speed and reasoning.", [], void 0],
+  ["antigravity", "gemini-3.8-flash-low", "Gemini 3.8 Flash (Low)", "Fast and efficient for straightforward work.", [], void 0],
+  ["antigravity", "gemini-2.5-pro", "Gemini 2.5 Pro", "Deep reasoning for coding and analysis.", [], void 0],
+  ["antigravity", "gemini-2.5-flash", "Gemini 2.5 Flash", "Fast and versatile everyday model.", [], void 0],
+  ["antigravity", "claude-sonnet-4-6", "Claude Sonnet 4.6", "Sonnet 4.6 via Antigravity.", [], void 0],
+  ["antigravity", "claude-opus-4-6-thinking", "Claude Opus 4.6 Thinking", "Opus 4.6 with thinking via Antigravity.", [], void 0],
+  ["antigravity", "gpt-oss-120b-medium", "GPT-OSS 120B (Medium)", "Open weights model via Antigravity.", [], void 0]
+].map(([runtime, id, label, description, efforts, effort]) => ({ runtime, id, label, description, efforts, ...effort ? { effort } : {} }));
+export {
+  MODELS
+};

package/dist/permissions.d.ts

@@ -0,0 +1,14 @@
+export type PermissionBase = 'read-only' | 'workspace-write' | 'full-access';
+export type PermissionProfile = { name: string; base: PermissionBase; allow: string[]; ask: string[]; deny: string[]; beyondMode: 'refuse' | 'ask'; workdir?: 'copy' };
+export const BASES: PermissionBase[];
+export const ADVISORS: string[];
+export const MAX_RULES: number;
+export const TOOLS: string[];
+export function parseRule(rule: unknown, source?: string): { tool: string; specifier?: string };
+export function validatePermissions(value: unknown, source: string): { profiles: Record<string, { base?: PermissionBase; beyondMode?: 'refuse' | 'ask'; workdir?: 'copy'; allow: string[]; ask: string[]; deny: string[] }>; agents: Record<string, string> };
+export function addAllowRule(projectRoot: string, home: string | undefined, profileName: string, rule: string): Promise<string>;
+export function profileFor(projectRoot: string, home: string | undefined, agent: string): Promise<PermissionProfile | null>;
+export function capMode(mode: string, base: string): string;
+export function unwrapShell(command: string): string;
+export function simpleCommands(line: string): string[] | null;
+export function commandDecision(profile: Pick<PermissionProfile, 'allow' | 'deny'> & { ask?: string[] }, command: string): 'allow' | 'ask' | 'deny' | undefined;