akm-cli 0.9.5 → 0.9.6

package/dist/registry/network.js

@@ -2,6 +2,7 @@
 // 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 { isIP } from "node:net";
+import { backoffDelay, computeRetryDelay, abortableDelay as sharedAbortableDelay, shouldRetry } from "../core/common.js";
 import { bareHostname, classifyNetworkAddress, classifyNetworkHostname, resolveHostnameAddresses, } from "../core/network-policy.js";
 import { assertRegistryPinnedTransportAvailable, requestRegistryAddressPinned, } from "./pinned-transport.js";
 export { requestRegistryAddressPinned } from "./pinned-transport.js";
@@ -77,7 +78,7 @@ async function requestRegistryHop(url, init, options) {
             }
             const response = await transport(url, address, init, remainingMs);
             if (attempt < maxRetries && shouldRetry(response.status)) {
-                const delay = retryDelay(response, attempt);
+                const delay = computeRetryDelay(response, attempt, { maxDelayMs: MAX_REGISTRY_RETRY_DELAY_MS });
                 await cancelRegistryResponse(response);
                 await abortableDelay(delay, init?.signal);
                 continue;
@@ -87,7 +88,7 @@ async function requestRegistryHop(url, init, options) {
         catch (error) {
             if (attempt >= maxRetries || init?.signal?.aborted)
                 throw error;
-            await abortableDelay(backoffDelay(attempt), init?.signal);
+            await abortableDelay(backoffDelay(attempt, undefined, MAX_REGISTRY_RETRY_DELAY_MS), init?.signal);
         }
     }
     throw new Error("Registry retry loop is unreachable");
@@ -217,45 +218,12 @@ function isRedirect(status) {
 export async function cancelRegistryResponse(response) {
     await response.body?.cancel().catch(() => undefined);
 }
-function shouldRetry(status) {
-    return status === 429 || status >= 500;
-}
-function retryDelay(response, attempt) {
-    const retryAfter = response.headers.get("retry-after");
-    if (retryAfter) {
-        const seconds = Number(retryAfter);
-        if (Number.isFinite(seconds)) {
-            return seconds >= 0 ? Math.min(MAX_REGISTRY_RETRY_DELAY_MS, seconds * 1_000) : backoffDelay(attempt);
-        }
-        const date = Date.parse(retryAfter);
-        if (Number.isFinite(date))
-            return Math.min(MAX_REGISTRY_RETRY_DELAY_MS, Math.max(0, date - Date.now()));
-    }
-    return backoffDelay(attempt);
-}
-function backoffDelay(attempt) {
-    return Math.min(MAX_REGISTRY_RETRY_DELAY_MS, 500 * 2 ** attempt * (0.5 + Math.random() * 0.5));
-}
 /** Test-only visibility for the server-controlled Retry-After clamp. */
 export function _registryRetryDelayForTests(response, attempt) {
-    return retryDelay(response, attempt);
+    return computeRetryDelay(response, attempt, { maxDelayMs: MAX_REGISTRY_RETRY_DELAY_MS });
 }
 function abortableDelay(ms, signal) {
-    if (!signal)
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    if (signal.aborted)
-        return Promise.reject(signal.reason ?? new Error("Registry request aborted"));
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(signal.reason ?? new Error("Registry request aborted"));
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
+    return sharedAbortableDelay(ms, signal, "Registry request aborted");
 }
 /** Existing local HTTP fixtures remain available only inside the test process. */
 export function allowPrivateRegistryFixtureForTests(rawUrl) {

package/dist/runtime.js

@@ -135,18 +135,10 @@ function stdioFor(mode) {
     return mode ?? "pipe";
 }
 // ── Stdin ───────────────────────────────────────────────────────────────────
-/**
- * Read all of stdin as a single `Buffer`, enforcing a byte limit. When more
- * than `limitBytes` is read, `onLimitExceeded()` is invoked and its return (an
- * Error) is thrown — callers supply their own message so behaviour is exact.
- */
-export async function readStdin(limitBytes, onLimitExceeded) {
+/** Read all of stdin as a single `Buffer`. */
+export async function readStdin() {
     const chunks = [];
-    let total = 0;
     for await (const chunk of stdinIterator()) {
-        total += chunk.byteLength;
-        if (total > limitBytes)
-            throw onLimitExceeded();
         chunks.push(chunk);
     }
     return Buffer.concat(chunks);

package/dist/scripts/akm-migrate-node.js

@@ -9380,8 +9380,6 @@ function getRegistryIndexCacheDir() {
 }
 
 // src/core/common.ts
-var MAX_CONFIG_FILE_BYTES = 1024 * 1024;
-var MAX_LOCAL_METADATA_BYTES = 1024 * 1024;
 var MAX_LOCK_METADATA_BYTES = 64 * 1024;
 function readTextFileDescriptorWithLimit(fd, maxBytes, label = "File", displayPath = "(open file)") {
   const stat = fs.fstatSync(fd);
@@ -9403,10 +9401,13 @@ function readTextFileDescriptorWithLimit(fd, maxBytes, label = "File", displayPa
   }
   return buffer.subarray(0, total).toString("utf8");
 }
-function readTextFileWithLimit(filePath, maxBytes, label = "File") {
+function readTextFile(filePath, label = "File") {
   const fd = fs.openSync(filePath, "r");
   try {
-    return readTextFileDescriptorWithLimit(fd, maxBytes, label, filePath);
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile())
+      throw new ConfigError(`${label} is not a regular file: ${filePath}.`, "INVALID_CONFIG_FILE");
+    return fs.readFileSync(fd, "utf8");
   } finally {
     fs.closeSync(fd);
   }
@@ -9506,6 +9507,8 @@ function asNonEmptyString(value) {
   return trimmed.length > 0 ? trimmed : undefined;
 }
 function isProcessAlive(pid) {
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
+    return false;
   try {
     process.kill(pid, 0);
     return true;
@@ -14957,25 +14960,13 @@ var EXECUTION_MAX_TIMEOUT_MS = 2 ** 31 - 1;
 // src/workflows/resource-limits.ts
 var WORKFLOW_MAX_PLAN_BYTES = 2 * 1024 * 1024;
 var WORKFLOW_MAX_SOURCE_BYTES = 1024 * 1024;
-var WORKFLOW_MAX_STEPS = 256;
-var WORKFLOW_MAX_PARAMS = 128;
-var WORKFLOW_MAX_ROUTE_BRANCHES = 256;
 var WORKFLOW_MAX_INSTRUCTION_BYTES = 256 * 1024;
 var WORKFLOW_MAX_SCHEMA_BYTES = 256 * 1024;
 var WORKFLOW_MAX_EXTRA_PARAMS_BYTES = 64 * 1024;
-var WORKFLOW_MAX_MAP_EXPANSION = 1e4;
-var WORKFLOW_MAX_INPUTS = 64;
-var WORKFLOW_MAX_OUTPUTS = 64;
 var WORKFLOW_MAX_CONCURRENCY = 64;
-var WORKFLOW_MAX_GATE_LOOPS = 100;
-var WORKFLOW_MAX_RETRIES = 100;
 var WORKFLOW_MAX_TIMEOUT_MS = EXECUTION_MAX_TIMEOUT_MS;
 var WORKFLOW_ENGINE_NAME_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 var WORKFLOW_MAX_ENGINE_NAME_LENGTH = 63;
-var WORKFLOW_MAX_EXEC_ARGV = 64;
-var WORKFLOW_MAX_EXEC_ARG_BYTES = 4096;
-var WORKFLOW_MAX_EXEC_CWD_LENGTH = 1024;
-var WORKFLOW_MAX_EXEC_PASS_ENV = 32;
 var WORKFLOW_ENV_VAR_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var WORKFLOW_MAX_EXEC_OUTPUT_BYTES = 8 * 1024 * 1024;
 var EXEC_CONTEXT_LIMITS_POSIX = {
@@ -14993,13 +14984,13 @@ function jsonBytes(value) {
 var WORKFLOW_MAX_EMBEDDED_CHILD_PLAN_BYTES = 1024 * 1024;
 
 // src/tasks/source/bounded-document.ts
-var TASK_V3_MAX_SOURCE_BYTES = 1024 * 1024;
 var TASK_V3_MAX_JSON_DEPTH = 64;
 var TASK_V3_MAX_JSON_NODES = 1e4;
 var TASK_V3_MAX_COLLECTION_ITEMS = 1024;
 var TASK_V3_MAX_OBJECT_KEYS = 256;
 var TASK_V3_MAX_STRING_BYTES = 256 * 1024;
 var TASK_V3_MAX_SCHEDULES = 64;
+var TASK_V3_MAX_REDACT_NAMES = 32;
 function own2(value, key) {
   return Object.hasOwn(value, key);
 }
@@ -15288,9 +15279,6 @@ function readBoundedTaskSourceYaml(input, options) {
   if (typeof input.yaml !== "string") {
     throw new UsageError(`Invalid ${sourceLabel} at ${input.filePath}: source must be a string.`, "TASK_SOURCE_INVALID");
   }
-  if (utf8Bytes2(input.yaml) > TASK_V3_MAX_SOURCE_BYTES) {
-    throw new UsageError(`Invalid ${sourceLabel} at ${input.filePath}: source exceeds the 1 MiB (${TASK_V3_MAX_SOURCE_BYTES}-byte) resource limit.`, "TASK_SOURCE_INVALID");
-  }
   const lineCounter2 = new $LineCounter;
   let document;
   try {
@@ -16050,7 +16038,7 @@ function parseExecutionControls(input, ctx) {
     out.timeout = parseTimeoutTopLevel(input.timeout, ctx);
   if (own2(input, "redact")) {
     const names = parseStringArray(input.redact, ctx, ["redact"], {
-      max: WORKFLOW_MAX_EXEC_PASS_ENV,
+      max: TASK_V3_MAX_REDACT_NAMES,
       pattern: WORKFLOW_ENV_VAR_NAME_PATTERN
     });
     if (new Set(names).size !== names.length)
@@ -16064,8 +16052,8 @@ function parseExecutionControls(input, ctx) {
     out.maxSteps = input.maxSteps;
   }
   if (own2(input, "maxRetries")) {
-    if (!Number.isSafeInteger(input.maxRetries) || input.maxRetries < 0 || input.maxRetries > WORKFLOW_MAX_RETRIES) {
-      sourceError(ctx, ["maxRetries"], `must be an integer from 0 through ${WORKFLOW_MAX_RETRIES}.`);
+    if (!Number.isSafeInteger(input.maxRetries) || input.maxRetries < 0) {
+      sourceError(ctx, ["maxRetries"], "must be a non-negative safe integer.");
     }
     out.maxRetries = input.maxRetries;
   }
@@ -16125,9 +16113,6 @@ function parseInputDeclaration(name, raw, ctx) {
 function parseInputDeclarations(value, ctx) {
   const input = asRecord(value, ctx, ["inputs"]);
   const names = Object.keys(input);
-  if (names.length > WORKFLOW_MAX_PARAMS) {
-    sourceError(ctx, ["inputs"], `accepts at most ${WORKFLOW_MAX_PARAMS} declared inputs.`);
-  }
   const result = {};
   for (const name of names) {
     if (!INPUT_NAME_PATTERN.test(name)) {
@@ -16560,7 +16545,7 @@ function parseAkm(value, ctx) {
     out.timeout = parseTimeout(input.timeout, ctx);
   if (own2(input, "redact")) {
     const names = parseStringArray(input.redact, ctx, ["akm", "redact"], {
-      max: WORKFLOW_MAX_EXEC_PASS_ENV,
+      max: TASK_V3_MAX_REDACT_NAMES,
       pattern: WORKFLOW_ENV_VAR_NAME_PATTERN
     });
     if (new Set(names).size !== names.length)
@@ -16574,8 +16559,8 @@ function parseAkm(value, ctx) {
     out.maxSteps = input.maxSteps;
   }
   if (own2(input, "maxRetries")) {
-    if (!Number.isSafeInteger(input.maxRetries) || input.maxRetries < 0 || input.maxRetries > WORKFLOW_MAX_RETRIES) {
-      sourceError(ctx, ["akm", "maxRetries"], `must be an integer from 0 through ${WORKFLOW_MAX_RETRIES}.`);
+    if (!Number.isSafeInteger(input.maxRetries) || input.maxRetries < 0) {
+      sourceError(ctx, ["akm", "maxRetries"], "must be a non-negative safe integer.");
     }
     out.maxRetries = input.maxRetries;
   }
@@ -16892,9 +16877,6 @@ function optionalString(value, label) {
   return exactString(value, label);
 }
 function parseLegacyTaskYaml(input) {
-  if (input.bytes.byteLength > TASK_V3_MAX_SOURCE_BYTES) {
-    throw new Error(`task YAML exceeds the 1 MiB (${TASK_V3_MAX_SOURCE_BYTES}-byte) source resource limit`);
-  }
   let source;
   try {
     source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(input.bytes);
@@ -16942,7 +16924,7 @@ function validateCommonV2(data) {
     }
   }
   if (data.redact !== undefined && data.redact !== null) {
-    if (!Array.isArray(data.redact) || data.redact.length > WORKFLOW_MAX_EXEC_PASS_ENV || data.redact.some((entry) => typeof entry !== "string" || !WORKFLOW_ENV_VAR_NAME_PATTERN.test(entry))) {
+    if (!Array.isArray(data.redact) || data.redact.length > TASK_V3_MAX_REDACT_NAMES || data.redact.some((entry) => typeof entry !== "string" || !WORKFLOW_ENV_VAR_NAME_PATTERN.test(entry))) {
       throw new Error("redact must contain only bounded environment variable names");
     }
   }
@@ -17068,8 +17050,8 @@ function migratedObject(data) {
       akm.maxSteps = data.maxSteps;
     }
     if (data.maxRetries !== undefined && data.maxRetries !== null) {
-      if (!Number.isSafeInteger(data.maxRetries) || data.maxRetries < 0 || data.maxRetries > WORKFLOW_MAX_RETRIES) {
-        throw new Error(`maxRetries must be from 0 through ${WORKFLOW_MAX_RETRIES}`);
+      if (!Number.isSafeInteger(data.maxRetries) || data.maxRetries < 0) {
+        throw new Error("maxRetries must be a non-negative integer");
       }
       akm.maxRetries = data.maxRetries;
     }
@@ -17328,9 +17310,6 @@ function exactString2(value, label, nonempty = false) {
   return value;
 }
 function parseV3RawYaml(input) {
-  if (input.bytes.byteLength > TASK_V3_MAX_SOURCE_BYTES) {
-    throw new Error(`task YAML exceeds the 1 MiB (${TASK_V3_MAX_SOURCE_BYTES}-byte) source resource limit`);
-  }
   let source;
   try {
     source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(input.bytes);
@@ -18531,7 +18510,7 @@ function validateStep(value, jobId, index, stepIds, options) {
   }
   validateMap(step.map, `step ${id} map`);
   validateRoute(step.route, `step ${id} route`);
-  optionalStringList(step.inputs, `step ${id} inputs`, WORKFLOW_MAX_INPUTS);
+  optionalStringList(step.inputs, `step ${id} inputs`, Infinity);
   if (Array.isArray(step.inputs)) {
     for (const [inputIndex, input] of step.inputs.entries())
       validateReference(input, `step ${id} inputs[${inputIndex}]`);
@@ -18553,12 +18532,7 @@ function validateExec(value, location, options) {
     return;
   const exec = record(value, location);
   keys(exec, ["command", "cwd", "passEnv"], location);
-  stringList(exec.command, `${location}.command`, WORKFLOW_MAX_EXEC_ARGV, false);
-  for (const [index, argument] of exec.command.entries()) {
-    if (utf8Bytes(argument) > WORKFLOW_MAX_EXEC_ARG_BYTES) {
-      fail2(`${location}.command[${index}] exceeds ${WORKFLOW_MAX_EXEC_ARG_BYTES} bytes`);
-    }
-  }
+  stringList(exec.command, `${location}.command`, Infinity, false);
   try {
     rejectNulInArgv(exec.command);
   } catch (cause) {
@@ -18566,9 +18540,6 @@ function validateExec(value, location, options) {
   }
   optionalString2(exec.cwd, `${location}.cwd`);
   if (exec.cwd !== undefined) {
-    if (exec.cwd.length > WORKFLOW_MAX_EXEC_CWD_LENGTH) {
-      fail2(`${location}.cwd exceeds ${WORKFLOW_MAX_EXEC_CWD_LENGTH} characters`);
-    }
     try {
       exec.cwd = canonicalizeWorkflowWorkingDirectory(exec.cwd, options.workspaceRoot);
     } catch (cause) {
@@ -18576,7 +18547,7 @@ function validateExec(value, location, options) {
     }
   }
   if (exec.passEnv !== undefined) {
-    stringList(exec.passEnv, `${location}.passEnv`, WORKFLOW_MAX_EXEC_PASS_ENV, false);
+    stringList(exec.passEnv, `${location}.passEnv`, Infinity, false);
   }
   if (Array.isArray(exec.passEnv)) {
     for (const name of exec.passEnv) {
@@ -18627,8 +18598,8 @@ function validateRetry(value, location) {
     return;
   const retry = record(value, location);
   keys(retry, ["max", "on"], location);
-  if (!Number.isSafeInteger(retry.max) || retry.max < 0 || retry.max > WORKFLOW_MAX_RETRIES) {
-    fail2(`${location}.max must be an integer from 0 through ${WORKFLOW_MAX_RETRIES}`);
+  if (!Number.isSafeInteger(retry.max) || retry.max < 0) {
+    fail2(`${location}.max must be a non-negative integer`);
   }
   stringList(retry.on, `${location}.on`, PROGRAM_RETRY_REASONS.length, false);
   for (const reason of retry.on) {
@@ -18658,8 +18629,8 @@ function validateRoute(value, location) {
   keys(route, ["input", "branches", "defaultStepId"], location);
   nonEmptyString2(route.input, `${location}.input`);
   validateReference(route.input, `${location}.input`);
-  if (!Array.isArray(route.branches) || route.branches.length === 0 || route.branches.length > WORKFLOW_MAX_ROUTE_BRANCHES) {
-    fail2(`${location}.branches must contain 1 through ${WORKFLOW_MAX_ROUTE_BRANCHES} entries`);
+  if (!Array.isArray(route.branches) || route.branches.length === 0) {
+    fail2(`${location}.branches must be a non-empty array`);
   }
   const matches = new Set;
   for (const [index, value2] of route.branches.entries()) {
@@ -18679,8 +18650,8 @@ function validateGate(value, location) {
     return;
   const gate = record(value, location);
   keys(gate, ["maxLoops", "rubric"], location);
-  if (gate.maxLoops !== undefined && (!Number.isSafeInteger(gate.maxLoops) || gate.maxLoops < 1 || gate.maxLoops > WORKFLOW_MAX_GATE_LOOPS)) {
-    fail2(`${location}.maxLoops must be an integer from 1 through ${WORKFLOW_MAX_GATE_LOOPS}`);
+  if (gate.maxLoops !== undefined && (!Number.isSafeInteger(gate.maxLoops) || gate.maxLoops < 1)) {
+    fail2(`${location}.maxLoops must be an integer of at least 1`);
   }
   optionalString2(gate.rubric, `${location}.rubric`);
 }
@@ -18713,8 +18684,8 @@ function validateParams(value) {
   if (value === undefined)
     return;
   const params = record(value, "params");
-  if (Object.keys(params).length === 0 || Object.keys(params).length > WORKFLOW_MAX_PARAMS) {
-    fail2(`params must contain 1 through ${WORKFLOW_MAX_PARAMS} entries`);
+  if (Object.keys(params).length === 0) {
+    fail2(`params must contain at least one entry`);
   }
   for (const [name, schema] of Object.entries(params)) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
@@ -18726,8 +18697,8 @@ function validateOutputs(value) {
   if (value === undefined)
     return;
   const outputs = record(value, "outputs");
-  if (Object.keys(outputs).length === 0 || Object.keys(outputs).length > WORKFLOW_MAX_OUTPUTS) {
-    fail2(`outputs must contain 1 through ${WORKFLOW_MAX_OUTPUTS} entries`);
+  if (Object.keys(outputs).length === 0) {
+    fail2(`outputs must contain at least one entry`);
   }
   for (const [name, declaration] of Object.entries(outputs)) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
@@ -18750,9 +18721,6 @@ function validateBudget(value) {
       fail2(`budget.${key} must be a positive integer`);
     }
   }
-  if (typeof budget.maxUnits === "number" && budget.maxUnits > WORKFLOW_MAX_MAP_EXPANSION) {
-    fail2(`budget.maxUnits must be at most ${WORKFLOW_MAX_MAP_EXPANSION}`);
-  }
 }
 function validateLlm(value, location) {
   if (value === undefined)
@@ -19336,12 +19304,6 @@ function checkXrefs(value, line, errors2) {
   }
 }
 function checkResourceLimits(draft, errors2) {
-  if (draft.steps.length > WORKFLOW_MAX_STEPS) {
-    errors2.push({ line: 1, message: `Workflow must contain at most ${WORKFLOW_MAX_STEPS} steps.` });
-  }
-  if (Object.keys(draft.params ?? {}).length > WORKFLOW_MAX_PARAMS) {
-    errors2.push({ line: 1, message: `Workflow must contain at most ${WORKFLOW_MAX_PARAMS} parameters.` });
-  }
   for (const step of draft.steps) {
     if (step.instructions && utf8Bytes(step.instructions.text) > WORKFLOW_MAX_INSTRUCTION_BYTES) {
       errors2.push({
@@ -19703,9 +19665,6 @@ function parseParams(ctx, raw) {
     ctx.err(["params"], `"params" must be a mapping of param name to a JSON Schema object (e.g. changed_files: { type: array }).`);
     return;
   }
-  if (Object.keys(raw).length > WORKFLOW_MAX_PARAMS) {
-    ctx.err(["params"], `"params" must contain at most ${WORKFLOW_MAX_PARAMS} entries.`);
-  }
   const params = {};
   for (const [paramName, value] of Object.entries(raw)) {
     if (!INPUT_NAME_PATTERN.test(paramName)) {
@@ -19731,9 +19690,6 @@ function parseOutputs(ctx, raw) {
     ctx.err(["outputs"], `"outputs" must be a mapping of output name to { from, schema? } (e.g. report: { from: steps.summarize.output }).`);
     return;
   }
-  if (Object.keys(raw).length > WORKFLOW_MAX_OUTPUTS) {
-    ctx.err(["outputs"], `"outputs" must contain at most ${WORKFLOW_MAX_OUTPUTS} entries.`);
-  }
   const outputs = {};
   for (const [outputName, value] of Object.entries(raw)) {
     const path13 = ["outputs", outputName];
@@ -19825,10 +19781,10 @@ function parseBudget(ctx, raw) {
     }
   }
   if (raw.max_units !== undefined) {
-    if (typeof raw.max_units === "number" && Number.isInteger(raw.max_units) && raw.max_units >= 1 && raw.max_units <= WORKFLOW_MAX_MAP_EXPANSION) {
+    if (typeof raw.max_units === "number" && Number.isInteger(raw.max_units) && raw.max_units >= 1) {
       budget.maxUnits = raw.max_units;
     } else {
-      ctx.err([...path13, "max_units"], `"budget.max_units" must be an integer from 1 through ${WORKFLOW_MAX_MAP_EXPANSION}.`);
+      ctx.err([...path13, "max_units"], `"budget.max_units" must be an integer >= 1.`);
     }
   }
   return Object.keys(budget).length > 0 ? budget : undefined;
@@ -19838,9 +19794,6 @@ function parseSteps(ctx, raw) {
     ctx.err(["steps"], `"steps" is required and must be a list with at least one step.`);
     return [];
   }
-  if (raw.length > WORKFLOW_MAX_STEPS) {
-    ctx.err(["steps"], `"steps" must contain at most ${WORKFLOW_MAX_STEPS} entries.`);
-  }
   const idIndex = new Map;
   raw.forEach((rawStep, index) => {
     if (isPlainRecord(rawStep) && typeof rawStep.id === "string" && !idIndex.has(rawStep.id)) {
@@ -20011,10 +19964,6 @@ function parseExecPassEnv(ctx, raw, path13, stepLabel) {
     ctx.err(path13, `${stepLabel} "exec.pass_env" must be a non-empty list of environment variable NAMES to copy through from ` + `akm's own environment, e.g. pass_env: [CARGO_HOME]. Values never appear here — use "env:" bindings for those.`);
     return;
   }
-  if (raw.length > WORKFLOW_MAX_EXEC_PASS_ENV) {
-    ctx.err(path13, `${stepLabel} "exec.pass_env" must have at most ${WORKFLOW_MAX_EXEC_PASS_ENV} entries. A command needing ` + `more than that should use explicit named "env:" bindings instead.`);
-    return;
-  }
   const names = [];
   for (const [index, entry] of raw.entries()) {
     if (typeof entry !== "string" || !WORKFLOW_ENV_VAR_NAME_PATTERN.test(entry)) {
@@ -20034,10 +19983,6 @@ function parseExecCommand(ctx, raw, path13, stepLabel) {
     ctx.err(path13, `${stepLabel} "exec" requires "command": a non-empty argv list, e.g. command: ["bun", "run", "test:unit"]. ` + `A single shell string is not accepted — the command is spawned directly, never through a shell.`);
     return;
   }
-  if (raw.length > WORKFLOW_MAX_EXEC_ARGV) {
-    ctx.err(path13, `${stepLabel} "exec.command" must have at most ${WORKFLOW_MAX_EXEC_ARGV} entries.`);
-    return;
-  }
   const argv = [];
   for (const [index, entry] of raw.entries()) {
     if (typeof entry !== "string" || entry === "") {
@@ -20048,10 +19993,6 @@ function parseExecCommand(ctx, raw, path13, stepLabel) {
       ctx.err([...path13, index], `${stepLabel} "exec.command[${index}]" may not contain NUL bytes.`);
       return;
     }
-    if (utf8Bytes(entry) > WORKFLOW_MAX_EXEC_ARG_BYTES) {
-      ctx.err(path13, `${stepLabel} "exec.command[${index}]" exceeds ${WORKFLOW_MAX_EXEC_ARG_BYTES} bytes.`);
-      return;
-    }
     argv.push(entry);
   }
   return argv;
@@ -20064,10 +20005,6 @@ function parseExecCwd(ctx, raw, path13, stepLabel) {
     return;
   }
   const value = raw.trim();
-  if (value.length > WORKFLOW_MAX_EXEC_CWD_LENGTH) {
-    ctx.err(path13, `${stepLabel} "exec.cwd" exceeds ${WORKFLOW_MAX_EXEC_CWD_LENGTH} characters.`);
-    return;
-  }
   if (!isContainedRelativePath(value)) {
     ctx.err(path13, `${stepLabel} "exec.cwd" (${JSON.stringify(value)}) must be a RELATIVE path inside the unit's working ` + `directory — absolute paths, Windows drive letters, "~", and ".." segments are rejected.`);
     return;
@@ -20101,10 +20038,10 @@ function parseMap(ctx, raw, path13, stepLabel) {
   }
   let concurrency;
   if (raw.concurrency !== undefined) {
-    if (typeof raw.concurrency === "number" && Number.isInteger(raw.concurrency) && raw.concurrency > 0 && raw.concurrency <= WORKFLOW_MAX_CONCURRENCY) {
-      concurrency = raw.concurrency;
+    if (typeof raw.concurrency === "number" && Number.isInteger(raw.concurrency) && raw.concurrency > 0) {
+      concurrency = Math.min(raw.concurrency, WORKFLOW_MAX_CONCURRENCY);
     } else {
-      ctx.err([...path13, "concurrency"], `${stepLabel} "concurrency" must be an integer from 1 through ${WORKFLOW_MAX_CONCURRENCY}.`);
+      ctx.err([...path13, "concurrency"], `${stepLabel} "concurrency" must be a positive integer.`);
     }
   }
   const reducer = parseEnumField(ctx, raw.reducer, [...path13, "reducer"], `${stepLabel} "reducer"`, PROGRAM_REDUCERS);
@@ -20136,9 +20073,6 @@ function parseRoute(ctx, raw, path13, stepLabel, stepIndex, routeChecks) {
   if (!Array.isArray(raw.when) || raw.when.length === 0) {
     ctx.err(whenPath, `${stepLabel} "route" requires "when": a non-empty list of { match, step } branches (e.g. when: [{ match: pass, step: ship }]).`);
   } else {
-    if (raw.when.length > WORKFLOW_MAX_ROUTE_BRANCHES) {
-      ctx.err(whenPath, `${stepLabel} "when" must contain at most ${WORKFLOW_MAX_ROUTE_BRANCHES} branches.`);
-    }
     const seenMatches = new Map;
     raw.when.forEach((branch, i) => {
       const branchPath = [...whenPath, i];
@@ -20194,9 +20128,6 @@ function parseInputs(ctx, raw, path13, stepLabel) {
     ctx.err(path13, `${stepLabel} "inputs" must be a non-empty list of reference strings.`);
     return;
   }
-  if (raw.length > WORKFLOW_MAX_INPUTS) {
-    ctx.err(path13, `${stepLabel} "inputs" must contain at most ${WORKFLOW_MAX_INPUTS} entries.`);
-  }
   const out = [];
   const seen = new Set;
   raw.forEach((entry, i) => {
@@ -20223,10 +20154,10 @@ function parseGate(ctx, raw, path13, stepLabel) {
   checkUnknownKeys(ctx, raw, path13, GATE_KEYS, `${stepLabel} "gate"`);
   const gate = {};
   if (raw.max_loops !== undefined) {
-    if (typeof raw.max_loops === "number" && Number.isInteger(raw.max_loops) && raw.max_loops >= 1 && raw.max_loops <= WORKFLOW_MAX_GATE_LOOPS) {
+    if (typeof raw.max_loops === "number" && Number.isInteger(raw.max_loops) && raw.max_loops >= 1) {
       gate.maxLoops = raw.max_loops;
     } else {
-      ctx.err([...path13, "max_loops"], `${stepLabel} "gate.max_loops" must be an integer from 1 through ${WORKFLOW_MAX_GATE_LOOPS}.`);
+      ctx.err([...path13, "max_loops"], `${stepLabel} "gate.max_loops" must be an integer of at least 1.`);
     }
   }
   return gate;
@@ -20252,8 +20183,8 @@ function parseRetry(ctx, raw, path13, stepLabel) {
   }
   checkUnknownKeys(ctx, raw, path13, RETRY_KEYS, `${stepLabel} "retry"`);
   let ok = true;
-  if (!(typeof raw.max === "number" && Number.isInteger(raw.max) && raw.max >= 0 && raw.max <= WORKFLOW_MAX_RETRIES)) {
-    ctx.err([...path13, "max"], `${stepLabel} "retry.max" is required and must be an integer from 0 through ${WORKFLOW_MAX_RETRIES}.`);
+  if (!(typeof raw.max === "number" && Number.isInteger(raw.max) && raw.max >= 0)) {
+    ctx.err([...path13, "max"], `${stepLabel} "retry.max" is required and must be a non-negative integer.`);
     ok = false;
   }
   const on = [];
@@ -23841,7 +23772,7 @@ function withLockOperationMutex(lockPath, run) {
       db.exec("BEGIN IMMEDIATE");
       began = db.inTransaction;
       if (!began)
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2 ** attempt);
+        sleepSync(2 ** attempt);
     }
     if (!began)
       throw new Error(`Could not acquire lock operation mutex for ${lockPath}.`);
@@ -24004,7 +23935,7 @@ function extractHolderPid(content) {
 // src/core/config/config-io.ts
 function readConfigText(configPath) {
   try {
-    return readTextFileWithLimit(configPath, MAX_CONFIG_FILE_BYTES, "Config file");
+    return readTextFile(configPath, "Config file");
   } catch (err) {
     if (err.code === "ENOENT")
       return;
@@ -28111,9 +28042,6 @@ var ExtraParamsSchema = exports_external.record(exports_external.unknown()).supe
     ctx.addIssue({ code: exports_external.ZodIssueCode.custom, path: issue.path, message: issue.message });
   }
 });
-var LlmCapabilitiesSchema = exports_external.object({
-  structuredOutput: exports_external.boolean().optional()
-}).passthrough();
 var LlmInvocationOverridesSchema = exports_external.object({
   temperature: exports_external.number().finite().optional(),
   maxTokens: positiveInt.optional(),
@@ -28169,15 +28097,13 @@ var LlmConnectionConfigSchema = exports_external.object({
   maxTokens: positiveInt.optional(),
   timeoutMs: timeoutMsField,
   concurrency: positiveInt.optional(),
-  capabilities: LlmCapabilitiesSchema.optional(),
+  supportsJsonSchema: exports_external.boolean().optional(),
   extraParams: ExtraParamsSchema.optional(),
   contextLength: positiveInt.optional(),
   enableThinking: exports_external.boolean().optional(),
   reasoningEffort: nonEmptyString3.optional()
 }).passthrough();
-var LlmProfileConfigSchema = LlmConnectionConfigSchema.extend({
-  supportsJsonSchema: exports_external.boolean().optional()
-}).passthrough();
+var LlmProfileConfigSchema = LlmConnectionConfigSchema.passthrough();
 var AgentPlatformSchema = exports_external.enum(VALID_HARNESS_IDS);
 var LlmEngineSchema = exports_external.object({
   kind: exports_external.literal("llm"),
@@ -28189,7 +28115,6 @@ var LlmEngineSchema = exports_external.object({
   maxTokens: positiveInt.optional(),
   timeoutMs: timeoutMsField,
   concurrency: positiveInt.optional(),
-  supportsJsonSchema: exports_external.boolean().optional(),
   extraParams: ExtraParamsSchema.optional(),
   contextLength: positiveInt.optional(),
   enableThinking: exports_external.boolean().optional(),
@@ -28219,7 +28144,6 @@ var AgentEngineSchema = exports_external.object({
     "temperature",
     "maxTokens",
     "concurrency",
-    "supportsJsonSchema",
     "extraParams",
     "contextLength",
     "enableThinking",
@@ -28585,7 +28509,7 @@ var SearchGraphBoostSchema = exports_external.object({
   hopBoostPerEntity: nonNegativeNumber.optional(),
   hopBoostCap: nonNegativeNumber.optional(),
   maxHops: positiveInt.max(3).optional(),
-  confidenceMode: exports_external.enum(["off", "blend", "multiply"]).default("blend").optional(),
+  confidenceMode: exports_external.enum(["blend"]).default("blend").optional(),
   confidenceWeight: exports_external.number().finite().min(0).max(1).default(0.2).optional()
 }).passthrough();
 var SearchConfigSchema = exports_external.object({
@@ -29127,8 +29051,7 @@ function withMaintenanceStartBarrier(run) {
 
 // src/indexer/index-writer-lock.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-var INDEX_WRITER_LOCK_STALE_AFTER_MS = 12 * 60 * 60 * 1000;
-var DEFAULT_INDEX_WRITER_MAX_WAIT_MS = 10 * 60 * 1000;
+var DEFAULT_ASSET_MUTATION_MAX_WAIT_MS = 10 * 60 * 1000;
 var leaseContext = new AsyncLocalStorage2;
 
 // src/integrations/lockfile.ts
@@ -29926,9 +29849,14 @@ function existingDirectory(target) {
     throw cause;
   }
 }
+function reconcileDuplicateRoot(existing, candidate, sharedPath) {
+  if (existing.writable === candidate.writable && existing.layout === candidate.layout)
+    return;
+  throw new ConfigError(`Bundles "${existing.bundleId}" and "${candidate.bundleId}" both resolve to the same directory ` + `(${sharedPath}) but disagree on writable/adapter settings. Two bundle ids configured for one ` + "directory must have matching settings, or one of them removed — run `akm bundle list` to see both.", "INVALID_CONFIG_FILE");
+}
 function taskRoots(config, resolutionBase = process.cwd()) {
   const sources = new Map((bundlesToSourceEntries(config) ?? []).map((source) => [source.name, source]));
-  const roots = [];
+  const rootsByPath = new Map;
   for (const [bundleId, bundle] of Object.entries(config.bundles ?? {})) {
     if (bundle.enabled === false)
       continue;
@@ -29956,15 +29884,21 @@ function taskRoots(config, resolutionBase = process.cwd()) {
     }
     if (adapter !== "akm" && adapter !== "akm-task")
       continue;
-    roots.push({
+    const candidate = {
       bundleId,
       root: componentRoot,
       bundleRoot,
       writable: component?.writable ?? resolveWritable(source),
       layout: adapter === "akm-task" ? "akm-task" : "akm-stash"
-    });
+    };
+    const existing = rootsByPath.get(componentRoot);
+    if (existing) {
+      reconcileDuplicateRoot(existing, candidate, componentRoot);
+      continue;
+    }
+    rootsByPath.set(componentRoot, candidate);
   }
-  return roots;
+  return [...rootsByPath.values()];
 }
 function summarize(plan) {
   const files = plan.files.map((file) => ({