akm-cli 0.9.5 → 0.9.7

package/dist/scripts/akm-migrate.js

@@ -9379,8 +9379,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);
@@ -9402,10 +9400,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);
   }
@@ -9505,6 +9506,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;
@@ -11521,6 +11524,7 @@ var SCRIPT_EXTENSIONS = new Set([
   ".kts"
 ]);
 var WORKFLOW_EXTENSIONS = [".md", ".yml"];
+var DERIVED_SUFFIX = ".derived";
 var KNOWN_TYPES = [
   "skill",
   "command",
@@ -11681,6 +11685,9 @@ function assetPathForName(assetType, typeRoot, name) {
 }
 function assetPathCandidatesForName(assetType, typeRoot, name) {
   const primary = assetPathForName(assetType, typeRoot, name);
+  if (assetType === "memory" && !name.endsWith(DERIVED_SUFFIX)) {
+    return [primary, assetPathForName(assetType, typeRoot, `${name}${DERIVED_SUFFIX}`)];
+  }
   if (assetType !== "env")
     return [primary];
   const base = name === "default" ? "" : name.endsWith("/default") ? name.slice(0, -"default".length) : undefined;
@@ -14879,25 +14886,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 = {
@@ -14915,13 +14910,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);
 }
@@ -15210,9 +15205,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 {
@@ -15972,7 +15964,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)
@@ -15986,8 +15978,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;
   }
@@ -16047,9 +16039,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)) {
@@ -16482,7 +16471,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)
@@ -16496,8 +16485,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;
   }
@@ -16814,9 +16803,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);
@@ -16864,7 +16850,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");
     }
   }
@@ -16990,8 +16976,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;
     }
@@ -17250,9 +17236,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);
@@ -17549,6 +17532,9 @@ function peekTaskSourceVersion(root) {
   return typeof value === "number" ? value : undefined;
 }
 var TASK_MIGRATE_HINT = "Run `akm migrate apply --dry-run` to preview the task-v3 to task-source-v4 conversion, then run `akm migrate apply`.";
+function unmigratableVersionError(filePath, version, reason, detail) {
+  return new UsageError(`TASK_SCHEMA_VERSION_UNSUPPORTED: Task at ${filePath} uses task schema version ${version} and needs a human decision before it can run \u2014 the deterministic migrator cannot convert it automatically (${reason}${detail ? `: ${detail}` : ""}).`, "TASK_SCHEMA_VERSION_UNSUPPORTED", "Review the file and resolve the ambiguity by hand, then it will convert normally; `akm migrate status` reports the same reason.");
+}
 function unsupportedVersionError(filePath, version) {
   return new UsageError(`TASK_SCHEMA_VERSION_UNSUPPORTED: Task at ${filePath} uses task schema version ${version}, which this release does not accept.`, "TASK_SCHEMA_VERSION_UNSUPPORTED", TASK_MIGRATE_HINT);
 }
@@ -17568,12 +17554,12 @@ function planInMemoryV4Bytes(version, yaml, filePath, workspaceRoot) {
   } else {
     const v3Outcome = planTaskToV3File(baseInput);
     if (v3Outcome.status !== "changed")
-      return;
+      return { reason: v3Outcome.reason, detail: v3Outcome.detail };
     v3Bytes = v3Outcome.after;
   }
   const v4Outcome = planTaskToV4File({ ...baseInput, bytes: v3Bytes });
   if (v4Outcome.status !== "changed")
-    return;
+    return { reason: v4Outcome.reason, detail: v4Outcome.detail };
   return v4Outcome.after.toString("utf8");
 }
 function parseTaskSource(input) {
@@ -17581,16 +17567,17 @@ function parseTaskSource(input) {
   const version = peekTaskSourceVersion(root);
   if (version !== undefined && version !== TASK_SOURCE_V4_VERSION) {
     if (version === 2 || version === 3) {
-      const v4Yaml = planInMemoryV4Bytes(version, input.yaml, input.filePath, input.workspaceRoot);
-      if (v4Yaml !== undefined) {
+      const shimmed = planInMemoryV4Bytes(version, input.yaml, input.filePath, input.workspaceRoot);
+      if (typeof shimmed === "string") {
         const v4 = parseTaskSourceV4({
-          yaml: v4Yaml,
+          yaml: shimmed,
           filePath: input.filePath,
           ...input.workspaceRoot ? { workspaceRoot: input.workspaceRoot } : {}
         });
         warn(`akm: task ${input.filePath} uses schema v${version} \u2014 auto-read as v4; run \`akm migrate apply\` to rewrite it and silence this`);
         return Object.freeze({ version: 4, v4 });
       }
+      throw unmigratableVersionError(input.filePath, version, shimmed.reason, shimmed.detail);
     }
     throw unsupportedVersionError(input.filePath, version);
   }
@@ -18453,7 +18440,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}]`);
@@ -18475,12 +18462,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) {
@@ -18488,9 +18470,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) {
@@ -18498,7 +18477,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) {
@@ -18549,8 +18528,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) {
@@ -18580,8 +18559,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()) {
@@ -18601,8 +18580,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`);
 }
@@ -18635,8 +18614,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))
@@ -18648,8 +18627,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))
@@ -18672,9 +18651,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)
@@ -19258,12 +19234,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({
@@ -19625,9 +19595,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)) {
@@ -19653,9 +19620,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];
@@ -19747,10 +19711,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;
@@ -19760,9 +19724,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)) {
@@ -19933,10 +19894,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 \u2014 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)) {
@@ -19956,10 +19913,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 \u2014 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 === "") {
@@ -19970,10 +19923,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;
@@ -19986,10 +19935,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 \u2014 absolute paths, Windows drive letters, "~", and ".." segments are rejected.`);
     return;
@@ -20023,10 +19968,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);
@@ -20058,9 +20003,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];
@@ -20116,9 +20058,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) => {
@@ -20145,10 +20084,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;
@@ -20174,8 +20113,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 = [];
@@ -23763,7 +23702,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}.`);
@@ -23926,7 +23865,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;
@@ -27981,9 +27920,7 @@ var BUILTIN_IMPROVE_STRATEGY_NAMES = [
   "default",
   "quick",
   "thorough",
-  "memory-focus",
   "graph-refresh",
-  "frequent",
   "consolidate",
   "catchup",
   "reflect-distill",
@@ -28033,9 +27970,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(),
@@ -28091,15 +28025,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"),
@@ -28111,7 +28043,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(),
@@ -28141,7 +28072,6 @@ var AgentEngineSchema = exports_external.object({
     "temperature",
     "maxTokens",
     "concurrency",
-    "supportsJsonSchema",
     "extraParams",
     "contextLength",
     "enableThinking",
@@ -28507,7 +28437,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({
@@ -29049,8 +28979,7 @@ function withMaintenanceStartBarrier(run) {
 
 // src/indexer/index-writer-lock.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "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
@@ -29848,9 +29777,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 \u2014 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;
@@ -29878,15 +29812,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) => ({

package/dist/setup/engine-config.js

@@ -7,11 +7,10 @@ export function readCurrentLlmEngine(config) {
     const engine = name ? config.engines?.[name] : undefined;
     if (!engine || engine.kind !== "llm")
         return undefined;
-    const { kind: _kind, supportsJsonSchema, timeoutMs, ...connection } = engine;
+    const { kind: _kind, timeoutMs, ...connection } = engine;
     return {
         ...connection,
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-        ...(supportsJsonSchema !== undefined ? { capabilities: { structuredOutput: supportsJsonSchema } } : {}),
     };
 }
 export function readAgentEngineSelection(config) {
@@ -45,15 +44,13 @@ export function writeLlmEngine(config, llm) {
     const endpoint = llm.endpoint.endsWith("/chat/completions")
         ? llm.endpoint
         : `${llm.endpoint.replace(/\/$/, "")}/chat/completions`;
-    const { capabilities, ...connection } = llm;
     return {
         engines: {
             ...(config.engines ?? {}),
             [name]: {
-                ...connection,
+                ...llm,
                 kind: "llm",
                 endpoint,
-                ...(capabilities?.structuredOutput !== undefined ? { supportsJsonSchema: capabilities.structuredOutput } : {}),
             },
         },
         defaults: { ...(config.defaults ?? {}), engine: config.defaults?.engine ?? name, llmEngine: name },

package/dist/setup/registry-stash-loader.js

@@ -17,14 +17,6 @@ import { hasRegistryUrlCredentials } from "../core/registry-url.js";
 import { allowPrivateRegistryFixtureForTests, cancelRegistryResponse, fetchRegistryResponse, } from "../registry/network.js";
 import { parseRegistryRef } from "../registry/resolve.js";
 // ── Default selections ──────────────────────────────────────────────────────
-/**
- * Registry stash IDs that are pre-selected by default during setup.
- * IDs must match the `id` field in the official registry index and have a
- * matching target in AUTHENTICATED_DEFAULT_TARGETS.
- *
- * The target binding is intentionally separate from display metadata.
- */
-export const DEFAULT_SELECTED_STASH_IDS = ["itlackey/akm-stash"];
 const AUTHENTICATED_DEFAULT_TARGETS = {
     "itlackey/akm-stash": {
         installType: "git",