akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/core/config/schema/engines.js

@@ -1,160 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * OpenAI-compatible LLM connection configs + named agent/LLM engine schemas
- * (`engines`). Extracted verbatim from the former `config-schema.ts` monolith —
- * no behavior change.
- */
-import { z } from "zod";
-// Harness ids come straight from the harness registry (the same source
-// `config-types.ts` re-exports them from). Importing them here rather than via
-// `../config-types` keeps `schema/*` free of any edge to `config-types`, which
-// type-derives from this barrel via `typeof import("./config-schema")` —
-// routing through config-types would mint a config-schema ↔ config-types type
-// cycle that collapses inference.
-import { HARNESS_AGENT_DISPATCH_IDS, HARNESS_NATIVE_AGENT_IDS, VALID_HARNESS_IDS, } from "../../../integrations/harnesses/index.js";
-import { WORKFLOW_MAX_TIMEOUT_MS } from "../../../workflows/resource-limits.js";
-import { chatCompletionsEndpoint, ExtraParamsSchema, engineName, nonEmptyString, positiveInt, symbolicOrWarnApiKey, } from "./primitives.js";
-/**
- * Engine-config timeouts share the workflow ceiling.
- *
- * 0.9.1 bounded workflow-authored timeouts (parser) and frozen invocations
- * (decoder) at 2^31-1, but the third source — `engines.<name>.timeoutMs` — was
- * validated only as a positive integer. A larger value passed config validation
- * and then failed EVERY run of that engine with an unlocated "Invalid frozen
- * workflow plan: invocation is invalid". Reject it where the value is written.
- */
-const timeoutMsField = z.union([positiveInt.max(WORKFLOW_MAX_TIMEOUT_MS), z.null()]).optional();
-// ── Connection configs (LLM) ────────────────────────────────────────────────
-/**
- * OpenAI-compatible connection fields shared by named LLM engines and bounded
- * internal call helpers. `model` is required at schema level: current loads and
- * CLI writes reject a partial named engine rather than normalizing it through a
- * pre-schema compatibility transform.
- */
-export const LlmConnectionConfigSchema = z
-    .object({
-    provider: z.string().optional(),
-    endpoint: z.string(),
-    model: z.string(),
-    apiKey: z.string().optional(),
-    temperature: z.number().finite().optional(),
-    maxTokens: positiveInt.optional(),
-    timeoutMs: timeoutMsField,
-    concurrency: positiveInt.optional(),
-    // User-settable override, not a cached probe verdict: attempt-then-
-    // fallback in llm/client.ts tries `response_format: json_schema` whenever
-    // a schema is supplied, degrading to plain text on an unsupported-4xx and
-    // remembering that in-memory for the rest of the process. `false` here
-    // opts a known-incompatible endpoint out of even the first attempt;
-    // `true` is advisory only.
-    supportsJsonSchema: z.boolean().optional(),
-    extraParams: ExtraParamsSchema.optional(),
-    contextLength: positiveInt.optional(),
-    enableThinking: z.boolean().optional(),
-    reasoningEffort: nonEmptyString.optional(),
-})
-    .passthrough();
-export const LlmProfileConfigSchema = LlmConnectionConfigSchema.passthrough();
-// ── Agent engines ───────────────────────────────────────────────────────────
-// Derives from the canonical VALID_HARNESS_IDS (#565) so the Zod gate cannot
-// drift from the TS union / parse check / setup detection.
-const AgentPlatformSchema = z.enum(VALID_HARNESS_IDS);
-const LlmEngineSchema = z
-    .object({
-    kind: z.literal("llm"),
-    provider: z.string().optional(),
-    endpoint: chatCompletionsEndpoint,
-    model: nonEmptyString,
-    apiKey: symbolicOrWarnApiKey("engines.<name>.apiKey").optional(),
-    // #905: file-backed alternative to `apiKey` for hosts that refuse
-    // secrets in the process environment. A plain filesystem path (`~`
-    // expanded, read at dispatch) — see resolveLlmEngineUse/
-    // materializeLlmConnectionWithCredential in integrations/agent/engine-resolution.ts.
-    apiKeyFile: nonEmptyString.optional(),
-    temperature: z.number().finite().optional(),
-    maxTokens: positiveInt.optional(),
-    timeoutMs: timeoutMsField,
-    concurrency: positiveInt.optional(),
-    // Same user-settable override LlmConnectionConfigSchema declares above; a
-    // named `kind: "llm"` engine is validated by THIS object, so without the
-    // field here the unknown-key walk reported a live setting as unknown and
-    // `akm migrate apply` dropped it from config.json.
-    supportsJsonSchema: z.boolean().optional(),
-    extraParams: ExtraParamsSchema.optional(),
-    contextLength: positiveInt.optional(),
-    enableThinking: z.boolean().optional(),
-    reasoningEffort: nonEmptyString.optional(),
-})
-    .passthrough()
-    .superRefine((value, ctx) => {
-    for (const key of ["platform", "bin", "args", "workspace", "modelAliases", "llmEngine", "agent"]) {
-        if (key in value)
-            ctx.addIssue({ code: z.ZodIssueCode.custom, path: [key], message: `${key} is not valid on an LLM engine` });
-    }
-    // #905: apiKey and apiKeyFile are two alternative ways to supply the same
-    // credential; a third (the implicit AKM_ENGINE_<NAME>_API_KEY env var) is
-    // still available when neither is set, so only the both-set case is
-    // rejected here.
-    if (value.apiKey !== undefined && value.apiKeyFile !== undefined) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["apiKeyFile"],
-            message: "apiKey and apiKeyFile cannot both be set",
-        });
-    }
-});
-const AgentEngineSchema = z
-    .object({
-    kind: z.literal("agent"),
-    platform: AgentPlatformSchema.refine((platform) => HARNESS_AGENT_DISPATCH_IDS.has(platform), {
-        message: "platform does not support agent dispatch",
-    }),
-    bin: nonEmptyString.optional(),
-    args: z.array(z.string()).optional(),
-    workspace: nonEmptyString.optional(),
-    model: nonEmptyString.optional(),
-    agent: nonEmptyString.optional(),
-    timeoutMs: timeoutMsField,
-    llmEngine: engineName.optional(),
-})
-    .passthrough()
-    .superRefine((value, ctx) => {
-    for (const key of [
-        "provider",
-        "endpoint",
-        "apiKey",
-        "apiKeyFile",
-        "temperature",
-        "maxTokens",
-        "concurrency",
-        "extraParams",
-        "contextLength",
-        "enableThinking",
-        "reasoningEffort",
-        "modelAliases",
-    ]) {
-        if (key in value)
-            ctx.addIssue({ code: z.ZodIssueCode.custom, path: [key], message: `${key} is not valid on an agent engine` });
-    }
-    if (value.platform !== "opencode-sdk" && value.llmEngine !== undefined) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["llmEngine"],
-            message: "llmEngine is only valid on opencode-sdk",
-        });
-    }
-    if (value.agent !== undefined && !HARNESS_NATIVE_AGENT_IDS.has(value.platform)) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["agent"],
-            message: `agent is not valid on ${value.platform}: it has no native agent selector`,
-        });
-    }
-    if (value.platform === "opencode-sdk" && value.args !== undefined) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["args"], message: "args is not valid on opencode-sdk" });
-    }
-});
-export const EngineConfigSchema = z.union([LlmEngineSchema, AgentEngineSchema]);
-export const EnginesSchema = z.record(engineName, EngineConfigSchema);

package/dist/core/config/schema/execution.js

@@ -1,23 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { z } from "zod";
-const toolName = z.string().trim().min(1, "expected a non-empty tool name");
-/** Host-owned ceiling for capabilities requested by executable assets. */
-export const ExecutionPolicyConfigSchema = z
-    .object({
-    /** Exact tool names an asset may request. `*` is an explicit allow-all ceiling. */
-    allowedTools: z
-        .array(toolName)
-        .default([])
-        .superRefine((tools, ctx) => {
-        const seen = new Set();
-        for (const [index, tool] of tools.entries()) {
-            if (seen.has(tool)) {
-                ctx.addIssue({ code: z.ZodIssueCode.custom, path: [index], message: "duplicates an earlier tool name" });
-            }
-            seen.add(tool);
-        }
-    }),
-})
-    .passthrough();

package/dist/core/spawn-env.js

@@ -1,268 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * The ONE allowlist-based child-environment primitive.
- *
- * Three akm code paths spawn a child from an explicit list of environment
- * variable NAMES — the agent-CLI spawn wrapper
- * (`integrations/agent/spawn.ts`, `profile.envPassthrough`), the workflow
- * `exec` unit runner (`workflows/exec/exec-unit.ts`), and the opencode-sdk
- * server spawn (`integrations/harnesses/opencode-sdk/sdk-runner.ts`) — and
- * all build their allowlist from {@link COMMON_SPAWN_ENV_PASSTHROUGH} /
- * {@link spawnEnvNamesFor}. Keeping that in one leaf module is what makes
- * "allowlist" a single reviewable mechanism instead of independent
- * implementations that drift apart.
- *
- * A LEAF: node built-ins only, so both the integrations layer and the workflow
- * engine can import it without opening a cycle.
- *
- * @module core/spawn-env
- */
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-/**
- * The baseline env names every allowlisted akm child receives regardless of
- * what it runs: process identity (`HOME`, `USER`), tool resolution (`PATH`),
- * locale (`LANG`, `LC_ALL`), terminal (`TERM`), scratch space (`TMPDIR`), and
- * akm's own event provenance (`AKM_EVENT_SOURCE` — machine traffic, never a
- * secret). BOTH allowlists extend it — the agent-CLI profiles'
- * `COMMON_PASSTHROUGH` (`integrations/agent/profiles.ts`) and the workflow
- * exec unit's `EXEC_DEFAULT_ENV_PASSTHROUGH` (`workflows/exec/exec-unit.ts`)
- * — so a baseline name cannot drift into one child-spawn path but not the
- * other. NOTE: profile `envPassthrough` is frozen into workflow engine
- * snapshots, so growing this list changes frozen-plan content — extend
- * deliberately.
- */
-export const COMMON_SPAWN_ENV_PASSTHROUGH = [
-    "HOME",
-    "PATH",
-    "USER",
-    "LANG",
-    "LC_ALL",
-    "TERM",
-    "TMPDIR",
-    "AKM_EVENT_SOURCE",
-];
-/**
- * The XDG base-directory variables. opencode resolves its config, data, cache
- * and state directories from them, so it must receive them: an akm that runs
- * under a custom `XDG_CONFIG_HOME` otherwise spawns an opencode that reads
- * `$HOME/.config/opencode` and misses the provider config its caller named.
- *
- * Deliberately NOT part of {@link COMMON_SPAWN_ENV_PASSTHROUGH}, which is every
- * harness's baseline, the workflow exec unit's default allowlist (a documented
- * list) and, through profile `envPassthrough`, frozen into workflow plans.
- * codex, gemini and pi keep their own dotdirs under `$HOME`, and handing the
- * names to a shell command would redirect the `git` and `gh` config it reads. A
- * harness that reads them asks for them by name: the opencode profile's list,
- * and the opencode-sdk server's allowlist (`opencodeSdkServerEnvironmentNames`).
- *
- * A name added to a profile's list changes the plans frozen after it (their
- * bytes, so their `plan_hash`); a stored plan keeps the list it was frozen with
- * and still resumes, because nothing gates on that hash. The SDK server's
- * allowlist is not part of a plan, so it takes the names by code.
- */
-export const XDG_BASE_DIR_ENV_PASSTHROUGH = [
-    "XDG_CONFIG_HOME",
-    "XDG_DATA_HOME",
-    "XDG_CACHE_HOME",
-    "XDG_STATE_HOME",
-];
-/**
- * The names an `opencode` process reads beyond the common baseline: its API key
- * (OpenCode Go and Zen read `OPENCODE_API_KEY`), the config file it is pointed
- * at, and the {@link XDG_BASE_DIR_ENV_PASSTHROUGH} directories. ONE list for
- * both ways akm starts opencode: the `opencode` CLI profile's `envPassthrough`
- * and the `opencode-sdk` server's allowlist
- * (`opencodeSdkServerEnvironmentNames`), so the two cannot drift.
- */
-export const OPENCODE_ENV_PASSTHROUGH = [
-    "OPENCODE_API_KEY",
-    "OPENCODE_CONFIG",
-    ...XDG_BASE_DIR_ENV_PASSTHROUGH,
-];
-/**
- * The names Windows itself requires of ANY child, whatever the caller's
- * allowlist says. Applied at build time rather than added to
- * {@link COMMON_SPAWN_ENV_PASSTHROUGH} because profile `envPassthrough` is
- * frozen into workflow engine snapshots: growing the shared list would change
- * the bytes — and so the hashes — of every plan already on disk, to express
- * something that is not a policy choice at all.
- *
- * `SystemRoot`, `SystemDrive` and `WINDIR` are what PROCESS CREATION reads;
- * without them the loader cannot find system DLLs and the spawn fails before
- * the command runs. Without `PATHEXT` Windows never tries `bun.exe`/`bun.cmd`,
- * so a `bin: "bun"` profile is unresolvable, and `COMSPEC` is how `.bat`/`.cmd`
- * targets resolve at all. The rest are the win32 analogues of baseline names
- * the POSIX side already grants — `HOME` (`USERPROFILE`, `HOMEDRIVE`,
- * `HOMEPATH`) and `TMPDIR` (`TEMP`, `TMP`). None is a secret.
- *
- * Config and install roots (`APPDATA`, `LOCALAPPDATA`, `ProgramFiles`, …) are
- * deliberately NOT here: a child can be created and can resolve its command
- * without them, so which allowlist wants them stays a per-caller decision.
- *
- * THE definition of the floor. The workflow exec allowlist
- * (`EXEC_DEFAULT_ENV_PASSTHROUGH`) spreads this constant rather than
- * re-spelling it, because that list is also consumed on POSIX — where
- * {@link spawnEnvNamesFor} appends nothing — and the names still have to be
- * requestable there for a win32 run of the same workflow.
- */
-export const WIN32_SPAWN_ENV_FLOOR = [
-    "SystemRoot",
-    "SystemDrive",
-    "WINDIR",
-    "COMSPEC",
-    "PATHEXT",
-    "USERPROFILE",
-    "HOMEDRIVE",
-    "HOMEPATH",
-    "TEMP",
-    "TMP",
-];
-/**
- * The effective allowlist for `platform`: the caller's names, plus any floor
- * the operating system requires of every child regardless of allowlist.
- * Exported for tests, which must be able to ask for a platform they are not
- * running on.
- */
-export function spawnEnvNamesFor(names, platform = process.platform) {
-    const effective = [...names];
-    if (platform !== "win32")
-        return effective;
-    // Deduped by EXACT spelling, never case-folded: {@link collectAllowlistedEnv}
-    // looks each surviving name up with exactly this case, and a `source` that is
-    // a plain object — the agent spawn's `envSource` seam — does not case-fold.
-    // Suppressing `SystemRoot` because the caller happened to write `SYSTEMROOT`
-    // would therefore drop the loader-critical variable the floor exists to
-    // guarantee. Keeping both spellings is harmless: the win32 environment is
-    // itself case-insensitive, so they resolve to the same value.
-    const present = new Set(effective);
-    for (const name of WIN32_SPAWN_ENV_FLOOR) {
-        if (!present.has(name))
-            effective.push(name);
-    }
-    return effective;
-}
-/**
- * Build a child environment from an allowlist: start EMPTY and copy through
- * exactly the named variables that exist in `source`. Names absent from the
- * source are simply absent from the child (never an empty string, which many
- * tools treat as "set but blank").
- *
- * `PATH`, when it comes through, is supplemented for scheduler contexts — see
- * {@link supplementPathForSchedulerContext}. That happens here rather than in
- * each caller so a child spawned from cron/launchd/Task Scheduler can find the
- * user's toolchain no matter which spawn path reached it. On win32 the names
- * in {@link WIN32_SPAWN_ENV_FLOOR} come through too, for the same reason: the
- * spawn cannot succeed without them, whichever caller built the list.
- */
-export function collectAllowlistedEnv(names, source = process.env) {
-    const env = {};
-    for (const name of spawnEnvNamesFor(names)) {
-        const value = source[name];
-        if (value !== undefined)
-            env[name] = value;
-    }
-    if (env.PATH !== undefined) {
-        env.PATH = supplementPathForSchedulerContext(env.PATH);
-    }
-    return env;
-}
-/**
- * Answers already computed by {@link supplementPathForSchedulerContext}, keyed
- * by the input PATH and the home directory it was computed against.
- *
- * Correctness envelope: the answer is a pure function of those two, the
- * platform, and which candidate directories exist on disk. The platform cannot
- * change under a running process, and the other two are in the key — so the one
- * thing the memo assumes is that a candidate directory does not APPEAR while
- * akm runs. Answering the rest of a run the way its start was answered is what
- * a shell's own command-path caching already does, and the cost of not
- * memoizing is paid on every child-env build: two PATH splits and up to seven
- * SYNCHRONOUS `existsSync` probes, on the event loop a 10 000-unit fan-out
- * shares with every other in-flight unit.
- *
- * Bounded so a caller that somehow varies its PATH cannot grow it without
- * limit; a spawn path only ever sees a handful of distinct PATH strings, so
- * the reset is effectively unreachable in practice.
- */
-const supplementedPaths = new Map();
-const SUPPLEMENTED_PATH_MEMO_MAX = 64;
-/**
- * Supplement `existingPath` with well-known user binary directories when
- * running in a scheduler context (cron/launchd) where PATH is stripped.
- *
- * Detection heuristic: if the current PATH does not contain the user's home
- * directory, we are likely in a stripped scheduler env. In an interactive
- * shell the user's home almost always appears (e.g. ~/.bun/bin, ~/.cargo/bin).
- *
- * Only directories that actually exist on disk are prepended, and only if
- * they are not already present, so interactive-shell PATH ordering is never
- * disturbed.
- *
- * Memoized per input PATH — see {@link supplementedPaths} for what that
- * assumes.
- */
-export function supplementPathForSchedulerContext(existingPath) {
-    const home = os.homedir();
-    // NUL-joined so no pair of (home, PATH) can collide onto one key: no path
-    // component can contain a NUL.
-    const key = `${home}\u0000${existingPath}`;
-    const memoized = supplementedPaths.get(key);
-    if (memoized !== undefined)
-        return memoized;
-    const supplemented = computeSupplementedPath(existingPath, home);
-    if (supplementedPaths.size >= SUPPLEMENTED_PATH_MEMO_MAX)
-        supplementedPaths.clear();
-    supplementedPaths.set(key, supplemented);
-    return supplemented;
-}
-function computeSupplementedPath(existingPath, home) {
-    // A home of `/` (system crontab, launchd, service accounts) or of `""`
-    // prefixes EVERY entry, so a prefix test would read the most stripped
-    // environments there are as interactive and skip the repair they exist for.
-    const comparableHome = home === "" || home === path.sep ? undefined : home;
-    // If PATH already contains the home directory, we are in an interactive
-    // shell — skip supplementation entirely. Compared on a path boundary: a
-    // sibling home (`/home/alice` next to `/home/al`) is not this user's.
-    const isUnderHome = (dir) => comparableHome !== undefined && (dir === comparableHome || dir.startsWith(comparableHome + path.sep));
-    if (existingPath.split(path.delimiter).some(isUnderHome)) {
-        return existingPath;
-    }
-    const candidates = pathCandidatesForCurrentPlatform(home);
-    const existing = new Set(existingPath.split(path.delimiter).filter(Boolean));
-    const toAdd = candidates.filter((d) => !existing.has(d) && fs.existsSync(d));
-    if (toAdd.length === 0)
-        return existingPath;
-    return [...toAdd, existingPath].filter(Boolean).join(path.delimiter);
-}
-function pathCandidatesForCurrentPlatform(home) {
-    if (process.platform === "win32") {
-        // Windows: Bun + Cargo + Scoop + Chocolatey + system tools. Order favors
-        // user-local installs over machine-global so the user's chosen toolchain
-        // wins. These paths are commonly stripped from Task Scheduler / service
-        // environments, mirroring the cron/launchd problem on POSIX.
-        const localAppData = process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local");
-        const userProfile = process.env.USERPROFILE ?? home;
-        const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
-        return [
-            path.join(userProfile, ".bun", "bin"),
-            path.join(localAppData, "Programs", "bun"),
-            path.join(userProfile, ".cargo", "bin"),
-            path.join(localAppData, "Programs", "Git", "cmd"),
-            path.join(userProfile, "scoop", "shims"),
-            path.join(programFiles, "Git", "cmd"),
-            "C:\\ProgramData\\chocolatey\\bin",
-        ];
-    }
-    return [
-        path.join(home, ".bun", "bin"),
-        path.join(home, ".cargo", "bin"),
-        path.join(home, ".local", "bin"),
-        "/opt/homebrew/bin",
-        "/opt/homebrew/sbin",
-        "/usr/local/bin",
-    ];
-}

package/dist/execution/directory-identity.js

@@ -1,78 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import fs from "node:fs";
-import path from "node:path";
-import { UsageError } from "../core/errors.js";
-export function captureFrozenDirectoryIdentity(rootInput, relativeCwd) {
-    const requestedRoot = path.resolve(rootInput);
-    const requestedCwd = path.resolve(requestedRoot, relativeCwd ?? ".");
-    requireContained(requestedRoot, requestedCwd);
-    const realRoot = fs.realpathSync(requestedRoot);
-    const realCwd = fs.realpathSync(requestedCwd);
-    requireContained(realRoot, realCwd);
-    const rootStat = fs.statSync(realRoot, { bigint: true });
-    const cwdStat = fs.statSync(realCwd, { bigint: true });
-    if (!rootStat.isDirectory() || !cwdStat.isDirectory()) {
-        throw new UsageError("Execution root and cwd must both be directories.", "INVALID_FLAG_VALUE");
-    }
-    return Object.freeze({
-        requestedRoot,
-        realRoot,
-        rootDevice: rootStat.dev.toString(),
-        rootInode: rootStat.ino.toString(),
-        requestedCwd,
-        realCwd,
-        cwdDevice: cwdStat.dev.toString(),
-        cwdInode: cwdStat.ino.toString(),
-    });
-}
-/**
- * Re-verify, immediately before spawn, that a frozen cwd still resolves
- * inside its execution root — path containment and resolved-path identity,
- * NOT device/inode identity. Unlike the removed assertFrozenDirectoryIdentity,
- * this does not compare device/inode numbers against the frozen snapshot: a
- * remount, an rsync, or a container rebuild that leaves the same real
- * content at the same real PATH must not abort a dispatch. What still
- * throws is anything that changes the resolved real PATH itself — a
- * symlink swap, an ancestor swap, a file replacing the directory, or the
- * root itself being replaced by a symlink elsewhere (root-vs-cwd
- * containment alone can't catch that last one, since both resolve together
- * under the new root; comparing the root's own resolved path to its frozen
- * value catches it).
- */
-export function assertFrozenDirectoryContained(identity) {
-    let realRoot;
-    let realCwd;
-    try {
-        realRoot = fs.realpathSync(identity.requestedRoot);
-        realCwd = fs.realpathSync(identity.requestedCwd);
-    }
-    catch {
-        throw changed(identity.requestedCwd);
-    }
-    if (realRoot !== identity.realRoot)
-        throw changed(identity.requestedCwd);
-    const relative = path.relative(realRoot, realCwd);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        throw changed(identity.requestedCwd);
-    }
-    let cwdStat;
-    try {
-        cwdStat = fs.statSync(realCwd, { bigint: true });
-    }
-    catch {
-        throw changed(identity.requestedCwd);
-    }
-    if (!cwdStat.isDirectory())
-        throw changed(identity.requestedCwd);
-}
-function changed(cwd) {
-    return new UsageError(`Frozen execution cwd ${cwd} changed and no longer resolves inside its root.`, "PATH_ESCAPE_VIOLATION");
-}
-function requireContained(root, candidate) {
-    const relative = path.relative(root, candidate);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        throw new UsageError(`${candidate} escapes its execution root.`, "PATH_ESCAPE_VIOLATION");
-    }
-}

package/dist/integrations/agent/builder-shared.js

@@ -1,33 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/** Models reaching a harness have already crossed the single model-map boundary. */
-export function resolveDispatchModel(request, _profile, _platform) {
-    return request.model;
-}
-/**
- * The model an engine's own `args` select, as `--model X` or `--model=X` (the
- * last one wins), for a builder that writes its own argv in place of those args.
- */
-export function modelFromArgs(args) {
-    let model;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--model")
-            model = args[index + 1];
-        else if (arg?.startsWith("--model="))
-            model = arg.slice("--model=".length);
-    }
-    return model;
-}
-/**
- * Normalize a toolPolicy value to a comma-separated string suitable for a
- * CLI flag. Structured policy objects are JSON-serialized.
- */
-export function normalizeTools(tools) {
-    if (typeof tools === "string")
-        return tools;
-    if (Array.isArray(tools))
-        return tools.join(",");
-    return JSON.stringify(tools);
-}

package/dist/integrations/agent/builders.js

@@ -1,43 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Agent command builder strategy (v1 spec §12.2).
- *
- * Each supported agent CLI platform has its own `AgentCommandBuilder` that
- * translates a platform-agnostic `AgentDispatchRequest` into the exact argv
- * the CLI expects. This keeps all per-platform arg differences out of the
- * spawn wrapper and profiles.
- *
- * Adding a new platform: implement `AgentCommandBuilder`, add to
- * `BUILTIN_BUILDERS`. Nothing else changes.
- */
-import { ConfigError } from "../../core/errors.js";
-import { HARNESS_REGISTRY } from "../harnesses/index.js";
-// ── Registry ──────────────────────────────────────────────────────────────────
-/**
- * DERIVED from `HARNESS_REGISTRY` (P0.5 registry-drift fix): each harness that
- * owns an `agentBuilder` is registered under its canonical id. Named engines
- * are schema-validated to canonical harness ids before reaching this boundary.
- */
-const BUILTIN_BUILDERS = (() => {
-    const registry = {};
-    for (const harness of HARNESS_REGISTRY) {
-        if (!harness.agentBuilder)
-            continue;
-        registry[harness.id] = harness.agentBuilder;
-    }
-    return Object.freeze(registry);
-})();
-/**
- * Return the builder for the given platform name.
- *
- * Unknown platforms are rejected: there is no safe generic CLI flag shape.
- * Custom builders injected by tests can be passed as `registry`.
- */
-export function getCommandBuilder(platform, registry = BUILTIN_BUILDERS) {
-    const found = registry[platform];
-    if (found)
-        return found;
-    throw new ConfigError(`Agent platform "${platform}" has no registered command builder.`, "INVALID_CONFIG_FILE", "Select a canonical agent platform in engines.<name>.platform.");
-}

package/dist/integrations/agent/engine-fallback.js

@@ -1,59 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { defaultWhich } from "./detect.js";
-import { OPENCODE_SDK_SERVER_BIN } from "./profiles.js";
-/** Engine name used for the synthesized entry; matches the platform id. */
-export const FALLBACK_ENGINE_NAME = "opencode-sdk";
-/** Announcement text, surfaced once per run/dispatch. */
-export const FALLBACK_ANNOUNCEMENT = `No engine is configured; falling back to \`${FALLBACK_ENGINE_NAME}\` via the ` +
-    `\`${OPENCODE_SDK_SERVER_BIN}\` binary on PATH — provider, model, and auth come ` +
-    "from opencode's own configuration. " +
-    "Run `akm setup`, or set `defaults.engine`, to choose explicitly.";
-/** Failure suffix for every surface that needs an engine and found none. */
-export const NO_ENGINE_MESSAGE_SUFFIX = `has no selected engine, and no usable \`${OPENCODE_SDK_SERVER_BIN}\` binary was found to fall back to.`;
-/** Guidance used when the fallback itself is unavailable. */
-export const NO_ENGINE_REMEDY = "Run `akm setup` to detect an installed agent, or set one explicitly: " +
-    '`akm config set engines.claude \'{"kind":"agent","platform":"claude"}\'` ' +
-    "then `akm config set defaults.engine claude`. " +
-    `Installing the \`${OPENCODE_SDK_SERVER_BIN}\` binary also works ` +
-    "(`npm i -g opencode-ai`) — akm falls back to it automatically.";
-/**
- * The fallback engine when its `opencode` binary is present: an
- * operator-configured `opencode-sdk` entry (whose pinned `bin`, possibly
- * outside PATH, is what gets probed), else a bare opencode-sdk agent engine.
- */
-export function fallbackEngineConfig(config, whichFn = defaultWhich) {
-    const existing = config.engines?.[FALLBACK_ENGINE_NAME];
-    const bin = existing?.kind === "agent" ? existing.bin : undefined;
-    if (!whichFn(bin ?? OPENCODE_SDK_SERVER_BIN))
-        return undefined;
-    return existing ?? { kind: "agent", platform: "opencode-sdk" };
-}
-/**
- * For diagnostics that report the effective engine: a config whose
- * `defaults.engine` resolves, with the implicit `opencode-sdk` fallback when it
- * does not and an opencode binary is present. Never mutates `config`; returns
- * the same object when no fallback is needed.
- */
-export function withEngineFallback(config, whichFn = defaultWhich) {
-    if (config.defaults?.engine)
-        return { config };
-    const engine = fallbackEngineConfig(config, whichFn);
-    if (!engine)
-        return { config };
-    return {
-        config: {
-            ...config,
-            engines: { ...(config.engines ?? {}), [FALLBACK_ENGINE_NAME]: engine },
-            defaults: { ...(config.defaults ?? {}), engine: FALLBACK_ENGINE_NAME },
-        },
-        fallbackEngineName: FALLBACK_ENGINE_NAME,
-    };
-}
-/** The announcement, but only when the fallback candidate is the engine that actually won selection. */
-export function fallbackAnnouncement(fallbackEngineName, selectedEngineName) {
-    if (!fallbackEngineName || selectedEngineName !== fallbackEngineName)
-        return undefined;
-    return FALLBACK_ANNOUNCEMENT;
-}