akm-cli 0.9.5 → 0.9.6

package/dist/setup/setup.js

@@ -29,11 +29,10 @@ import { ConfigError, UsageError } from "../core/errors.js";
 import { getConfigPath, getDefaultStashDir, isTransientStashPath } from "../core/paths.js";
 import { warn } from "../core/warn.js";
 import { akmIndex } from "../indexer/indexer.js";
-import { clearSemanticStatus, deriveSemanticProviderFingerprint, writeSemanticStatus, } from "../indexer/search/semantic-status.js";
 import { detectAgentCliProfiles, pickDefaultAgentProfile } from "../integrations/agent/index.js";
 import { defaultProfileName } from "../integrations/harnesses/index.js";
 import { readLockfile } from "../integrations/lockfile.js";
-import { probeLlmCapabilities } from "../llm/client.js";
+import { probeLlmReachable } from "../llm/client.js";
 import { detectEnvironment, detectLMStudio, renderDetectionSummary, } from "./detect.js";
 import { upsertDetectedAgentEngine, upsertDetectedLlmEngine, verifyOpenAiCompatibleEndpoint } from "./detected-engines.js";
 import { readCurrentLlmEngine, writeAgentEngines, writeLlmEngine } from "./engine-config.js";
@@ -592,38 +591,14 @@ export async function runSetupWizard(opts) {
     // Non-interactive setup paths never reach this interactive-only step.
     p.log.step("Scheduled Tasks");
     await stepScheduledTasks();
-    if (semanticSearchMode.mode === "off") {
-        clearSemanticStatus();
-    }
     if (semanticSearchMode.mode === "auto") {
         if (semanticSearchMode.prepareAssets) {
             const ready = await prepareSemanticSearchAssets(savedConfig);
             if (!ready.ok) {
-                writeSemanticStatus({
-                    status: "blocked",
-                    reason: ready.reason,
-                    message: ready.message,
-                    providerFingerprint: deriveSemanticProviderFingerprint(savedConfig.embedding),
-                    lastCheckedAt: new Date().toISOString(),
-                });
                 p.log.warn("Semantic search remains set to auto, but is currently blocked. Re-run `akm index --full --verbose` once the issue is resolved.");
             }
-            else {
-                writeSemanticStatus({
-                    status: "pending",
-                    message: "Semantic prerequisites verified. Building the index to finish activation.",
-                    providerFingerprint: deriveSemanticProviderFingerprint(savedConfig.embedding),
-                    lastCheckedAt: new Date().toISOString(),
-                });
-            }
         }
         else {
-            writeSemanticStatus({
-                status: "pending",
-                message: "Semantic search is enabled, but asset preparation was skipped.",
-                providerFingerprint: deriveSemanticProviderFingerprint(savedConfig.embedding),
-                lastCheckedAt: new Date().toISOString(),
-            });
             p.log.info("Semantic search is set to auto, but asset preparation was skipped. Run `akm index --full --verbose` later to verify it.");
         }
     }
@@ -649,15 +624,6 @@ export async function runSetupWizard(opts) {
     catch (err) {
         spin.stop("Indexing failed — you can run `akm index` manually later.");
         p.log.warn(String(err));
-        if (savedConfig.semanticSearchMode === "auto") {
-            writeSemanticStatus({
-                status: "blocked",
-                reason: "index-failed",
-                message: String(err),
-                providerFingerprint: deriveSemanticProviderFingerprint(savedConfig.embedding),
-                lastCheckedAt: new Date().toISOString(),
-            });
-        }
     }
     // API key reminder
     if (embedding?.apiKey === undefined && embedding?.provider !== "ollama") {
@@ -989,22 +955,19 @@ export async function runSetupFromConfig(opts) {
         merged = ctx.config;
     }
     // Convert the private setup draft to the persisted bundle shape.
-    let finalizedMerged = finalizeSetupDraft(merged);
+    const finalizedMerged = finalizeSetupDraft(merged);
     // Reject an invalid merged engine graph before probing or touching the stash.
     validateCompleteConfig(finalizedMerged);
-    // Optional probe
+    // Optional connectivity probe — informational only, never blocks or
+    // mutates config. `chatCompletion` attempts structured output fresh on
+    // every call that needs it (see `llm/client.ts`), so there is nothing to
+    // probe or persist here beyond "did the endpoint answer".
     const mergedLlm = readCurrentLlmEngine(finalizedMerged);
     if (opts.probe && mergedLlm) {
         try {
-            const caps = await probeLlmCapabilities(mergedLlm);
-            if (caps.reachable) {
-                finalizedMerged = {
-                    ...finalizedMerged,
-                    ...writeLlmEngine(finalizedMerged, {
-                        ...mergedLlm,
-                        capabilities: { structuredOutput: caps.structuredOutput ?? false },
-                    }),
-                };
+            const reach = await probeLlmReachable(mergedLlm);
+            if (!reach.reachable) {
+                warn(`[akm setup] LLM endpoint not reachable${reach.error ? `: ${reach.error}` : ""}.`);
             }
         }
         catch {

package/dist/setup/steps/connection-shared.js

@@ -9,7 +9,7 @@
  * each step keeps its own option assembly and branching.
  */
 import * as p from "../../cli/clack.js";
-import { probeLlmCapabilities } from "../../llm/client.js";
+import { probeLlmReachable } from "../../llm/client.js";
 import { prompt, promptOrBack } from "../prompt.js";
 // ── Derive-config ───────────────────────────────────────────────────────────
 /** Standard chat-connection config shared by every provider branch. */
@@ -97,21 +97,18 @@ export async function promptApiKeyEnvVarName() {
 }
 // ── Probe ───────────────────────────────────────────────────────────────────
 /**
- * Best-effort structured-output probe — never blocks setup. Annotates
- * `llm.capabilities.structuredOutput` in place when the endpoint answers,
- * and warns (configuration is still saved) when it does not.
+ * Best-effort reachability probe — never blocks setup. Does NOT probe or
+ * cache structured-output support: `chatCompletion` now attempts
+ * `response_format: json_schema` fresh on every call that supplies a schema
+ * and falls back once per call on a 4xx (see `llm/client.ts`), so there is
+ * no verdict for setup to determine or persist here.
  */
 export async function probeLlmConnection(llm) {
     const probeSpin = p.spinner();
-    probeSpin.start("Probing LLM (structured-output round-trip)...");
-    const probe = await probeLlmCapabilities(llm);
-    if (probe.reachable && probe.structuredOutput) {
-        probeSpin.stop("LLM reachable; structured output verified.");
-        llm.capabilities = { ...(llm.capabilities ?? {}), structuredOutput: true };
-    }
-    else if (probe.reachable) {
-        probeSpin.stop("LLM reachable but structured-output probe failed.");
-        llm.capabilities = { ...(llm.capabilities ?? {}), structuredOutput: false };
+    probeSpin.start("Probing LLM connectivity...");
+    const probe = await probeLlmReachable(llm);
+    if (probe.reachable) {
+        probeSpin.stop("LLM reachable.");
     }
     else {
         probeSpin.stop("LLM not reachable.");

package/dist/sources/providers/git-install.js

@@ -198,7 +198,7 @@ async function doSyncGit(parsed, options) {
                 };
             }
         }
-        catch (error) {
+        catch {
             // Cache invalid, re-clone
         }
     }

package/dist/storage/engines/sqlite-migrations.js

@@ -1,6 +1,25 @@
 // 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/.
+/**
+ * Shared SQLite migration engine.
+ *
+ * SQLite schemas evolve through this transaction-per-migration runner backed
+ * by a `schema_migrations` ledger.
+ *
+ * This module factors that runner out once. Each caller supplies only its own
+ * `MIGRATIONS` array.
+ *
+ * Ledger/transaction contract:
+ *   - `id` is permanent and must never be reused.
+ *   - Applied IDs must be an exact ordered prefix of the registry.
+ *   - Each `up` body and its ledger insert commit in the same transaction.
+ *   - Migration bodies run only after `BEGIN IMMEDIATE` is observably active,
+ *     and the transaction must remain active through the body's completion.
+ *   - The caller owns semantic safety classification and any policy gate;
+ *     this generic engine intentionally does not infer risk from SQL text.
+ */
+import { sleepSync } from "../../runtime.js";
 export function assertMigrationRegistry(migrations) {
     const seen = new Set();
     for (const migration of migrations) {
@@ -152,7 +171,7 @@ function isRetryableImmediateBeginError(error) {
 function sleepImmediateRetry(ms) {
     if (ms <= 0)
         return;
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    sleepSync(ms);
 }
 /**
  * Run `fn` inside a `BEGIN IMMEDIATE` transaction.

package/dist/storage/repositories/index-entries-repository.js

@@ -354,9 +354,6 @@ function deleteEntryRows(db, rows, options = {}) {
     }
     return rows.map((row) => row.id);
 }
-export function deleteEntriesByDir(db, dirPath) {
-    db.transaction(() => deleteEntryRows(db, rowsInDirectory(db, dirPath)))();
-}
 export function deleteEntriesByDirAndBundle(db, dirPath, bundleId, options = {}) {
     return db.transaction(() => deleteEntryRows(db, rowsInDirectory(db, dirPath, bundleId), options))();
 }
@@ -704,18 +701,6 @@ export function getEntryRefRowsForStashRoot(db, stashRoot) {
     });
 }
 // ── Indexer-phase helpers (moved from indexer.ts) ────────────────────────────
-/**
- * Compute a cheap FNV-1a hash of a buffer for source-identity tracking.
- * Not security-sensitive; used as an incremental fast-path skip key.
- */
-export function computeSourceHash(content) {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < content.length; i++) {
-        hash ^= content[i];
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return (hash >>> 0).toString(16);
-}
 /**
  * Return distinct zero-result search queries from the `usage_events` table
  * within the given lookback window.

package/dist/tasks/backends/launchd.js

@@ -494,15 +494,20 @@ function assertUnrestorableLaunchdSnapshotUnchanged(entry, currentArtifacts) {
         throw new ConfigError(`Loaded launchd artifact ${JSON.stringify(entry.id)} has no restorable plist and changed after its snapshot; refusing mutation.`, "INVALID_CONFIG_FILE");
     }
 }
+/**
+ * Enumerate the current launchd AKM service namespace (loaded domain members,
+ * print-disabled labels, and on-disk plists) in one pass.
+ *
+ * This used to run the enumeration twice and fail closed if the two passes
+ * disagreed, guarding against launchd state mutating between the two
+ * `launchctl` shell-outs (milliseconds apart, in-process). The only actor
+ * that could cause that is another concurrent akm process or the user
+ * running launchctl by hand at that exact instant; a subsequent `task sync`
+ * (idempotent by design) reconciles any such drift on its own, so the
+ * two-pass fencing added a TOCTOU-shaped guard around a race with a working
+ * self-heal already in place, not a way to avoid one.
+ */
 function inspectStableLaunchdNamespace(seedIds, context) {
-    const first = captureLaunchdNamespacePass(seedIds, context);
-    const second = captureLaunchdNamespacePass(seedIds, context);
-    if (first.stabilityKey !== second.stabilityKey) {
-        throw new ConfigError("The launchd AKM service namespace changed while scheduler state was being stabilized.", "INVALID_CONFIG_FILE");
-    }
-    return second.namespace;
-}
-function captureLaunchdNamespacePass(seedIds, context) {
     const domain = context.exec.run(["launchctl", "print", `gui/${context.exec.uid()}`]);
     if (domain.status !== 0) {
         throw new ConfigError(`launchctl failed to enumerate the loaded user domain during scheduler state inspection: ${domain.stderr || domain.stdout || "no output"}.`, "INVALID_CONFIG_FILE");
@@ -532,9 +537,6 @@ function captureLaunchdNamespacePass(seedIds, context) {
         ids.add(serviceLabel.slice(LAUNCHD_LABEL_PREFIX.length));
     for (const serviceLabel of akmDisabledLabels)
         ids.add(serviceLabel.slice(LAUNCHD_LABEL_PREFIX.length));
-    if (ids.size > MAX_LAUNCHD_AKM_NAMESPACE_ENTRIES) {
-        throw new ConfigError(`launchd AKM scheduler inventory exceeds ${MAX_LAUNCHD_AKM_NAMESPACE_ENTRIES} namespace entries.`, "INVALID_CONFIG_FILE");
-    }
     const plistByNativeId = new Map(plistEntries);
     const entries = [];
     for (const nativeId of [...ids].sort()) {
@@ -566,15 +568,8 @@ function captureLaunchdNamespacePass(seedIds, context) {
         }, parsed.invocation, entry.nativeId));
     }
     return Object.freeze({
-        namespace: Object.freeze({
-            inspection: Object.freeze({ installed: Object.freeze(installed), artifacts: Object.freeze(artifacts) }),
-            entries: Object.freeze(entries),
-        }),
-        stabilityKey: JSON.stringify({
-            loadedLabels: [...loadedLabels].sort(),
-            disabledLabels: akmDisabledLabels,
-            plistEntries,
-        }),
+        inspection: Object.freeze({ installed: Object.freeze(installed), artifacts: Object.freeze(artifacts) }),
+        entries: Object.freeze(entries),
     });
 }
 function restoreLaunchdBindingEntry(entry, context, errors) {

package/dist/tasks/backends/schtasks.js

@@ -106,7 +106,7 @@ export function SCHTASKS_BACKEND(options = {}) {
                     assertSchedulerMutationArtifact(current?.status === 0 && finalNativeId ? schtasksArtifact(finalNativeId, current.stdout) : undefined, expected);
                 }
                 else {
-                    assertSchtasksArtifactUnchanged(exec, taskName(nativeId), query, nativeId, task);
+                    assertSchtasksArtifactUnchanged(exec, taskName(nativeId), nativeId, task);
                 }
                 try {
                     // /F forces overwrite if a task with the same name exists.
@@ -461,8 +461,23 @@ function parsePowerShellSingleQuotedArgs(script, start) {
     }
     return argv;
 }
-/** Close the read/prepare-to-/Create ownership race at the native boundary. */
-function assertSchtasksArtifactUnchanged(exec, nativeTaskName, previous, nativeId, task) {
+/**
+ * Re-verify ownership of the native artifact immediately before `/Create /F`
+ * overwrites it (the read/prepare-to-/Create ownership race at the native
+ * boundary).
+ *
+ * This used to also compare the fresh query against the first read taken
+ * earlier in `install` and refuse the whole operation if anything about the
+ * XML had changed in between -- a freshness re-check on top of the identity
+ * re-check right below it. That extra comparison never caught anything the
+ * owner check didn't already cover (a foreign/changed owner still fails
+ * `assertSchedulerNativeArtifactOwner`), and `task sync` is idempotent, so a
+ * spurious refusal here only cost the user a rerun of a command they'd
+ * already asked for. Dropped; the owner re-check (the actual corruption/
+ * clobber guard -- no fallback exists if a foreign task got silently
+ * overwritten) stays.
+ */
+function assertSchtasksArtifactUnchanged(exec, nativeTaskName, nativeId, task) {
     // This runs outside install's rollback region: no scheduler mutation has
     // occurred, so a raced owner must remain untouched rather than be restored
     // from the stale first read.
@@ -470,11 +485,6 @@ function assertSchtasksArtifactUnchanged(exec, nativeTaskName, previous, nativeI
         isOk: (result) => result.status === 0 || isMissingTaskResult(result),
         message: (result) => `schtasks /Query failed during final ownership check (exit ${result.status}): ${result.stderr || result.stdout || "no output"}.`,
     });
-    const changed = current.status !== previous.status ||
-        (current.status === 0 && normalizeXmlForUtf16File(current.stdout) !== normalizeXmlForUtf16File(previous.stdout));
-    if (changed) {
-        throw new ConfigError(`schtasks task "${nativeTaskName}" changed while it was being prepared; refusing to replace an unverified owner.`, "INVALID_CONFIG_FILE");
-    }
     if (current.status === 0) {
         assertSchedulerNativeArtifactOwner(nativeId, task, extractSchtasksInvocation(current.stdout)?.invocation);
     }

package/dist/tasks/run/run-native-task.js

@@ -20,7 +20,7 @@
 import path from "node:path";
 import { assertNever } from "../../core/assert.js";
 import { runManagedSubprocess, streamCaptureFailure } from "../../core/subprocess.js";
-import { assertFrozenDirectoryIdentity } from "../../execution/directory-identity.js";
+import { assertFrozenDirectoryContained } from "../../execution/directory-identity.js";
 import { cleanupFrozenScript, frozenScriptCommand, materializeFrozenScript } from "../frozen-script.js";
 import { resolveAkmInvocation } from "../resolve-akm-bin.js";
 import { finishAttempt } from "./attempt-lifecycle.js";
@@ -146,11 +146,13 @@ export async function runNativeTask(input) {
     const dbLines = [{ line: header }];
     let exitCode = null;
     try {
-        // The projector froze both canonical paths and filesystem identities before
-        // history mutation. Re-resolve the authored root/cwd immediately before
-        // spawn so a symlink, ancestor, bundle-root, or directory/file swap cannot
-        // redirect execution outside that physical workspace.
-        assertFrozenDirectoryIdentity(task.cwdIdentity);
+        // Re-resolve the authored root/cwd immediately before spawn so a
+        // symlink, ancestor, bundle-root, or directory/file swap cannot redirect
+        // execution outside that physical workspace. This is a live containment
+        // check, not an identity comparison — it does not care whether the
+        // underlying device/inode changed (e.g. a remount), only whether the
+        // resolved cwd still lives inside its root.
+        assertFrozenDirectoryContained(task.cwdIdentity);
         if (task.kind === "script") {
             materialized = materializeFrozenScript(task);
             cmd = frozenScriptCommand(task, materialized.file);

package/dist/tasks/source/bounded-document.js

@@ -53,13 +53,14 @@ import { EXECUTION_MAX_TIMEOUT_MS } from "../../execution/limits.js";
 import { snapshotStrictRecord } from "../../execution/record.js";
 import { WORKFLOW_ENV_VAR_NAME_PATTERN } from "../../workflows/resource-limits.js";
 // ── Resource bounds (D2-N4: owned here, re-exported by source-v3.ts) ───────
-export const TASK_V3_MAX_SOURCE_BYTES = 1024 * 1024;
 export const TASK_V3_MAX_JSON_DEPTH = 64;
 export const TASK_V3_MAX_JSON_NODES = 10_000;
 export const TASK_V3_MAX_COLLECTION_ITEMS = 1024;
 export const TASK_V3_MAX_OBJECT_KEYS = 256;
 export const TASK_V3_MAX_STRING_BYTES = 256 * 1024;
 export const TASK_V3_MAX_SCHEDULES = 64;
+/** Max entries in a task's `redact:` env-name list. */
+export const TASK_V3_MAX_REDACT_NAMES = 32;
 export function own(value, key) {
     return Object.hasOwn(value, key);
 }
@@ -414,9 +415,6 @@ export 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 (utf8Bytes(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 lineCounter = new LineCounter();
     let document;
     try {

package/dist/tasks/source/task-source-v3-frozen.js

@@ -42,8 +42,8 @@ import { parseBuiltinCommandAction } from "../../commands/command/builtin-action
 import { bundleRefToString, parseBundleRef } from "../../core/asset/asset-ref.js";
 import { UsageError } from "../../core/errors.js";
 import { checkJsonSchemaDefinition } from "../../core/json-schema.js";
-import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_EXEC_PASS_ENV, WORKFLOW_MAX_RETRIES, } from "../../workflows/resource-limits.js";
-import { asRecord, checkKeys, cloneBoundedJson, noGithubExpression, own, parseEnvironment, parseStringArray, parseTimeout, parseTools, presentJsonValue, readBoundedTaskSourceYaml, sourceError, stringField, TASK_V3_MAX_SCHEDULES, validateWorkingDirectory, } from "./bounded-document.js";
+import { WORKFLOW_ENV_VAR_NAME_PATTERN } from "../../workflows/resource-limits.js";
+import { asRecord, checkKeys, cloneBoundedJson, noGithubExpression, own, parseEnvironment, parseStringArray, parseTimeout, parseTools, presentJsonValue, readBoundedTaskSourceYaml, sourceError, stringField, TASK_V3_MAX_REDACT_NAMES, TASK_V3_MAX_SCHEDULES, validateWorkingDirectory, } from "./bounded-document.js";
 export const TASK_V3_SCHEMA_VERSION = 3;
 /** Closed authoring vocabulary. Arbitrary GitHub `{0}` shell templates are not accepted. */
 export const TASK_V3_HOST_SHELLS = ["bash", "sh", "zsh", "pwsh", "powershell", "cmd"];
@@ -146,7 +146,7 @@ function parseAkm(value, ctx) {
         out.timeout = parseTimeout(input.timeout, ctx);
     if (own(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)
@@ -160,10 +160,8 @@ function parseAkm(value, ctx) {
         out.maxSteps = input.maxSteps;
     }
     if (own(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;
     }

package/dist/tasks/source/task-source-v4.js

@@ -42,10 +42,10 @@ import { applyInputDefaults, INPUT_NAME_PATTERN, validateInputs, } from "../../e
 import { EXECUTION_MAX_TIMEOUT_MS } from "../../execution/limits.js";
 import { classifyTargetRef } from "../../execution/target-ref.js";
 import { detectSecretShapedParams } from "../../workflows/exec/param-secrets.js";
-import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_EXEC_PASS_ENV, WORKFLOW_MAX_PARAMS, WORKFLOW_MAX_RETRIES, WORKFLOW_MAX_SCHEMA_BYTES, } from "../../workflows/resource-limits.js";
+import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_SCHEMA_BYTES } from "../../workflows/resource-limits.js";
 import { TASK_V3_HOST_SHELLS, TASK_V3_MAX_SCHEDULES } from "../source-v3.js";
 import { TASK_RUN_RESERVED_FLAG_NAMES, TASK_RUN_SELF_DIAGNOSED_FLAGS } from "../task-run-reserved-flags.js";
-import { asRecord, checkKeys, cloneBoundedJson, noGithubExpression, own, parseEnvironment, parseStringArray, presentJsonValue, readBoundedTaskSourceYaml, sourceError, stringField, utf8Bytes, validateWorkingDirectory, } from "./bounded-document.js";
+import { asRecord, checkKeys, cloneBoundedJson, noGithubExpression, own, parseEnvironment, parseStringArray, presentJsonValue, readBoundedTaskSourceYaml, sourceError, stringField, TASK_V3_MAX_REDACT_NAMES, utf8Bytes, validateWorkingDirectory, } from "./bounded-document.js";
 // ── Closed constants (D1, D2-N3, D2-N7) ─────────────────────────────────────
 export const TASK_SOURCE_V4_VERSION = 4;
 /** The exact, closed top-level key set (D2-N7) — `akm` and `on` are deliberately absent. */
@@ -298,7 +298,7 @@ function parseExecutionControls(input, ctx) {
         out.timeout = parseTimeoutTopLevel(input.timeout, ctx);
     if (own(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)
@@ -312,10 +312,8 @@ function parseExecutionControls(input, ctx) {
         out.maxSteps = input.maxSteps;
     }
     if (own(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;
     }
@@ -376,9 +374,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)) {

package/dist/tasks/source/task-to-v3.js

@@ -7,9 +7,9 @@ import path from "node:path";
 import { LineCounter, parseDocument, stringify as stringifyYaml } from "yaml";
 import { bundleRefToString, parseBundleRef } from "../../core/asset/asset-ref.js";
 import { formatExtraParamsIssue, validateExtraParams } from "../../core/extra-params.js";
-import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_EXEC_PASS_ENV, WORKFLOW_MAX_RETRIES, WORKFLOW_MAX_TIMEOUT_MS, } from "../../workflows/resource-limits.js";
+import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_TIMEOUT_MS } from "../../workflows/resource-limits.js";
 import { validateTaskId } from "../task-id.js";
-import { assertBoundedTaskYamlDocument, TASK_V3_MAX_SOURCE_BYTES } from "./bounded-document.js";
+import { assertBoundedTaskYamlDocument, TASK_V3_MAX_REDACT_NAMES } from "./bounded-document.js";
 import { classifyTaskV3Uses, parseTaskV3Yaml } from "./task-source-v3-frozen.js";
 import { parseTaskSourceV4 } from "./task-source-v4.js";
 const V2_KEYS = new Set([
@@ -135,9 +135,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);
@@ -189,7 +186,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.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");
         }
@@ -321,10 +318,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;
         }

package/dist/tasks/source/task-to-v4.js

@@ -18,7 +18,7 @@
 import crypto from "node:crypto";
 import path from "node:path";
 import { LineCounter, parseDocument, stringify as stringifyYaml } from "yaml";
-import { assertBoundedTaskYamlDocument, TASK_V3_MAX_SOURCE_BYTES } from "./bounded-document.js";
+import { assertBoundedTaskYamlDocument } from "./bounded-document.js";
 import { classifyTaskV3Uses } from "./task-source-v3-frozen.js";
 import { parseTaskSourceV4 } from "./task-source-v4.js";
 /** The closed v3 top-level key set (`src/tasks/source-v3.ts`'s own, vendored — not exported there). */
@@ -114,9 +114,6 @@ function exactString(value, label, nonempty = false) {
  * away (C-N1).
  */
 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);

package/dist/tasks/source-v3.js

@@ -1,13 +1,13 @@
 // 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 { TASK_V3_MAX_SCHEDULES, TASK_V3_MAX_SOURCE_BYTES } from "./source/bounded-document.js";
+import { TASK_V3_MAX_SCHEDULES } from "./source/bounded-document.js";
 // D2-N4 (spec docs/plans/specs/p2a-task-source-v4.md §3.1, §9): re-exported
-// at their EXISTING names so no importer changes. Only the two names a
-// surviving `src` consumer still imports (task-source-v4.ts,
-// commands/tasks/tasks.ts) — every other bounded-document re-export this
-// file used to carry was dropped in P4 §3.2.3.
-export { TASK_V3_MAX_SCHEDULES, TASK_V3_MAX_SOURCE_BYTES };
+// at its EXISTING name so no importer changes. The one name a surviving
+// `src` consumer still imports (task-source-v4.ts) — every other
+// bounded-document re-export this file used to carry was dropped in P4
+// §3.2.3.
+export { TASK_V3_MAX_SCHEDULES };
 export const TASK_EXTENSION = ".yml";
 export const TASK_NEAR_MISS_EXTENSION = ".yaml";
 /** Explain why the near-miss `.yaml` spelling is not a task source. */