akm-cli 0.9.5 → 0.9.7

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/sources/snapshot-fetchers/website-ingest.js

@@ -23,6 +23,9 @@ const CACHE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
 const QUEUE_EXPANSION_FACTOR = 5;
 const MAX_PAGES_DEFAULT = 50;
 const MAX_DEPTH_DEFAULT = 3;
+/** Byte cap for the `llms.txt` manifest itself — a curated link list, never a large file. */
+const LLMS_TXT_BYTE_CAP = 512 * 1024;
+const LLMS_TXT_BODY_TIMEOUT_MS = 15_000;
 /**
  * Per-page body cap for website scraping. HTML pages this large are
  * almost never useful as agent knowledge sources and a runaway server
@@ -531,6 +534,38 @@ async function crawlWebsite(startUrl, options) {
         ? createAllowAllRobotsPolicy()
         : createRobotsPolicy((robotsUrl) => loadRobotsTxt(robotsUrl, { allowPrivateHosts: options.allowPrivateHosts, signal: crawlSignal }));
     await assertStartUrlAllowedByRobots(robots, start, options.rawStartUrl);
+    // llms.txt fast path: an increasing number of doc sites publish a curated,
+    // deduplicated link list at `/llms.txt` specifically for tools like this
+    // one. When present, use it as the crawl frontier instead of discovering
+    // links by parsing HTML — each linked page still goes through the exact
+    // same robots-compliant, host-guarded `fetchWebsitePage` call below, so
+    // ingested pages stay individually addressable. Gated to origin-root start
+    // URLs only (mirrors `extractGithubRepository`'s repo-root restriction):
+    // adding a specific page must fetch that page, not silently pull in the
+    // whole site's manifest.
+    if (isOriginRootUrl(start)) {
+        const manifest = await fetchLlmsManifest(start, robots, {
+            allowPrivateHosts: options.allowPrivateHosts,
+            signal: crawlSignal,
+        });
+        if (manifest) {
+            warn("[akm] Using llms.txt manifest from %s", manifest.manifestUrl);
+            queue.length = 0;
+            for (const link of manifest.links) {
+                // A manifest can name arbitrary hosts; only same-origin links are
+                // honored by default, same as links discovered mid-crawl below.
+                if (link.origin !== allowedOrigin)
+                    continue;
+                const candidate = normalizeCrawlUrl(link.toString());
+                if (!candidate)
+                    continue;
+                // depth = maxDepth: fetch each manifest page individually, but don't
+                // treat it as a fresh BFS seed — the manifest is already the
+                // author-curated set of pages worth ingesting.
+                queue.push({ url: candidate, rawUrl: link.toString(), depth: options.maxDepth, deferrals: 0 });
+            }
+        }
+    }
     // Counts actual `fetchWebsitePage` invocations (regardless of outcome) so
     // Crawl-delay pacing skips the first fetch and never charges a delay slot
     // to a URL that robots.txt skipped without ever being fetched (C-11).
@@ -870,6 +905,97 @@ function buildMarkdownSnapshot(page, slug, tags) {
         "",
     ].join("\n");
 }
+/**
+ * True for a start URL that names an origin's root (no path, no query).
+ * Matches how `extractGithubRepository` restricts its own special-case match
+ * to repository-root URLs — the llms.txt probe must not fire for a
+ * user-supplied deep link, or `akm bundle add <site>/guides/foo` would
+ * silently ingest the whole site's manifest instead of the page requested.
+ */
+export function isOriginRootUrl(url) {
+    return url.pathname === "/" && !url.search;
+}
+/**
+ * Parses the `llms.txt` link-list format: list items shaped like
+ * `- [title](path) - description` (the description, and its separator, are
+ * ignored — only the link target is needed). Any line that isn't a markdown
+ * link list item — headings, the leading `# Title`/`> summary` lines, prose —
+ * is simply not a link line and is skipped.
+ */
+export function parseLlmsTxtLinks(text, baseUrl) {
+    const links = [];
+    const seen = new Set();
+    for (const line of text.split(/\r?\n/)) {
+        const match = line.trim().match(/^-\s*\[[^\]]*\]\(([^)\s]+)\)/);
+        const href = match?.[1];
+        if (!href)
+            continue;
+        let resolved;
+        try {
+            resolved = new URL(href, baseUrl);
+        }
+        catch {
+            continue;
+        }
+        if (resolved.protocol !== "http:" && resolved.protocol !== "https:")
+            continue;
+        const key = resolved.toString();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        links.push(resolved);
+    }
+    return links;
+}
+/**
+ * Probes `<origin>/llms.txt` and, if present, returns its parsed link list.
+ * Reuses `fetchWebsiteResponse` so the manifest fetch itself gets the exact
+ * same SSRF host guard, redirect handling, and (via `robots`) robots.txt
+ * compliance as any other page fetch — this is still a fetch against a
+ * user-supplied host, no different from the rest of the crawl.
+ *
+ * `llms-full.txt` (the single-file concatenation of every page) is
+ * deliberately NOT read here. Its `## <path>` separators are ambiguous — page
+ * content legitimately contains `##` headings too — so recovered page
+ * boundaries can't be trusted, whereas per-page fetches through the existing
+ * pipeline are cheap, bounded by this author-curated list, and produce
+ * cleanly addressable assets. See the issue's "alternatives considered".
+ */
+async function fetchLlmsManifest(start, robots, options) {
+    const manifestUrl = new URL("/llms.txt", start.origin).toString();
+    const decision = await resolveCrawlRobotsDecision(robots, manifestUrl);
+    if (!decision.allowed)
+        return null;
+    let fetched;
+    try {
+        fetched = await fetchWebsiteResponse(decision.fetchUrl, 0, {
+            allowPrivateHosts: options.allowPrivateHosts,
+            signal: options.signal,
+            robots,
+        });
+    }
+    catch {
+        return null;
+    }
+    if (!fetched.response.ok) {
+        await fetched.response.body?.cancel().catch(() => undefined);
+        return null;
+    }
+    let text;
+    try {
+        text = await readBodyWithByteCap(fetched.response, LLMS_TXT_BYTE_CAP, {
+            bodyTimeoutMs: LLMS_TXT_BODY_TIMEOUT_MS,
+            signal: options.signal,
+        });
+    }
+    catch {
+        return null;
+    }
+    const links = parseLlmsTxtLinks(text, fetched.finalUrl);
+    if (links.length === 0)
+        return null;
+    return { manifestUrl: fetched.finalUrl, links };
+}
 function normalizeCrawlUrl(rawUrl) {
     try {
         const parsed = new URL(rawUrl);

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-connection.js

@@ -10,10 +10,12 @@
  * import their opener from a sibling here instead of reaching up into the
  * indexer — inverting the old storage→indexer arrow.
  */
+import fs from "node:fs";
 import { createRequire } from "node:module";
 import { ConfigError } from "../../core/errors.js";
 import { classifyPathAccess, describeInaccessiblePath } from "../../core/path-access.js";
 import { getDbPath } from "../../core/paths.js";
+import { warn } from "../../core/warn.js";
 import { openDatabase } from "../database.js";
 import { openManagedDatabase } from "../managed-db.js";
 import { SQLITE_BUSY_TIMEOUT_MS } from "../sqlite-pragmas.js";
@@ -21,9 +23,23 @@ import { openSqliteReadSnapshot } from "../sqlite-read-snapshot.js";
 import { isCanonicalIndexGeneration } from "./index-entry-schema.js";
 import { ensureSchema } from "./index-schema.js";
 import { loadVecExtension, warnIfVecMissing } from "./index-vec-repository.js";
+/**
+ * Whether `error` is SQLite reporting on-disk corruption (`SQLITE_CORRUPT`,
+ * "database disk image is malformed") rather than a permission, lock, or
+ * schema problem. Matched on both `code` (bun:sqlite, better-sqlite3) and
+ * message text, since driver error shapes are not perfectly uniform.
+ */
+function isCorruptionError(error) {
+    const code = error?.code;
+    if (code === "SQLITE_CORRUPT")
+        return true;
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("database disk image is malformed") || message.includes("SQLITE_CORRUPT");
+}
 export function openIndexDatabase(dbPath, options) {
-    return openManagedDatabase({
-        path: dbPath ?? getDbPath(),
+    const resolvedPath = dbPath ?? getDbPath();
+    const spec = {
+        path: resolvedPath,
         init: (db) => {
             // Try to load sqlite-vec extension
             loadVecExtension(db);
@@ -41,7 +57,33 @@ export function openIndexDatabase(dbPath, options) {
             // Warn once at init if using JS fallback with many entries
             warnIfVecMissing(db, { once: true });
         },
-    });
+    };
+    try {
+        return openManagedDatabase(spec);
+    }
+    catch (error) {
+        // index.db is a derived cache, fully regenerable from the stash on disk
+        // (see src/core/state-db.ts's "Why a separate database from index.db"
+        // note) — so real on-disk corruption is recovered by deleting the file
+        // and rebuilding, not by surfacing a raw SQLITE_CORRUPT to the caller or
+        // quietly falling through to an unreadable index. This mirrors the
+        // existing stale-version-marker rebuild below, one layer further down
+        // (that path opens fine and rewrites tables in place; corruption prevents
+        // even opening, so the file itself has to go first).
+        if (!isCorruptionError(error))
+            throw error;
+        warn(`Index database is corrupt at ${resolvedPath} — rebuilding.`);
+        for (const suffix of ["", "-wal", "-shm"]) {
+            try {
+                fs.rmSync(`${resolvedPath}${suffix}`, { force: true });
+            }
+            catch {
+                // Best-effort cleanup; the retried open below still fails loudly if
+                // the file could not actually be removed.
+            }
+        }
+        return openManagedDatabase(spec);
+    }
 }
 /**
  * Read the operator-configured embedding dimension from the on-disk config.

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/cron.js

@@ -31,7 +31,7 @@ import { getTaskLogDir } from "../../core/paths.js";
 import { resolveAkmInvocation } from "../resolve-akm-bin.js";
 import { parseSchedule, translateToCron } from "../schedule.js";
 import { assertSchedulerExecutionEvidenceDigest, assertSchedulerExpectationIdentity, assertSchedulerMutationArtifact, assertSchedulerNativeArtifactCardinality, assertSchedulerNativeArtifactOwner, assertSchedulerRemovalArtifact, assertSchedulerRollbackArtifactCardinality, schedulerBindingNativeId, schedulerLogicalBindingId, schedulerLogicalBindingOwner, schedulerNativeArtifactKey, } from "../scheduler-binding.js";
-import { buildScheduledBindingInvocation, parseScheduledBindingArgv, resolveScheduledTaskContext, schedulerContextDescriptor, schedulerContextPath, } from "../scheduler-invocation.js";
+import { buildScheduledBindingInvocation, parsePublicSchedulerInvocation, parseScheduledBindingArgv, resolveScheduledTaskContext, SCHEDULER_CONTEXT_ARG, schedulerContextDescriptor, schedulerContextPath, } from "../scheduler-invocation.js";
 import { nodeFs, throwIfNotOk } from "./exec-utils.js";
 const BEGIN = (id) => `# akm:task ${assertCronValue(id)} BEGIN`;
 const END = (id) => `# akm:task ${assertCronValue(id)} END`;
@@ -105,7 +105,7 @@ export function CRON_BACKEND(options = {}) {
             replaceCrontab(exec, existing, next);
         },
         list() {
-            return [...inspectCronState(readCrontab(exec)).installed];
+            return [...inspectCronState(readCrontab(exec), defaultContextPath).installed];
         },
         listForRebind() {
             const existing = readCrontab(exec);
@@ -123,14 +123,14 @@ export function CRON_BACKEND(options = {}) {
             });
         },
         listNativeArtifacts() {
-            return [...inspectCronState(readCrontab(exec)).artifacts];
+            return [...inspectCronState(readCrontab(exec), defaultContextPath).artifacts];
         },
         inspectBindings() {
-            return inspectCronState(readCrontab(exec));
+            return inspectCronState(readCrontab(exec), defaultContextPath);
         },
         snapshotBindings(ids) {
             const crontab = readCrontab(exec);
-            const inspection = inspectCronState(crontab);
+            const inspection = inspectCronState(crontab, defaultContextPath);
             const keys = new Set(ids.map(schedulerNativeArtifactKey));
             return Object.freeze({
                 kind: CRON_SNAPSHOT,
@@ -144,7 +144,7 @@ export function CRON_BACKEND(options = {}) {
                 throw new ConfigError("Invalid cron scheduler snapshot.", "INVALID_CONFIG_FILE");
             }
             const existing = readCrontab(exec);
-            const current = inspectCronState(existing);
+            const current = inspectCronState(existing, defaultContextPath);
             const safeNativeIds = [];
             const errors = [];
             if (expectedCurrent) {
@@ -192,7 +192,7 @@ export function CRON_BACKEND(options = {}) {
         },
     };
 }
-function inspectCronState(crontab) {
+function inspectCronState(crontab, fallbackContextPath) {
     const installed = [];
     const artifacts = [];
     for (const { id, body } of listBlocks(crontab)) {
@@ -207,7 +207,14 @@ function inspectCronState(crontab) {
             signature: fingerprint,
             ...(parsed.target !== undefined ? { target: parsed.target } : {}),
             binding: parsed.binding,
-            contextPath: parsed.contextPath,
+            // A legacy (pre-`--scheduler-context`) row has no real descriptor
+            // path to report — `extractLegacyCronInvocation` leaves it "". Fall
+            // back to the current default so downstream consumers (context
+            // validation in `akm task prune`/`explain`, `sync`'s reuse of an
+            // existing binding's contextPath) see a real, resolvable descriptor
+            // rather than an empty path, since the row is about to be reconciled
+            // to a current one anyway (#881).
+            contextPath: parsed.contextPath || fallbackContextPath,
         };
         Object.defineProperty(ref, "nativeId", { value: id });
         Object.defineProperty(ref, "invocation", { value: Object.freeze([...parsed.invocation]) });
@@ -323,7 +330,40 @@ export function extractCronInvocation(body) {
     const redirectIndex = fields.indexOf(">>", commandStart);
     if (redirectIndex === -1)
         return undefined;
-    return parseScheduledBindingArgv(fields.slice(commandStart, redirectIndex));
+    const tail = fields.slice(commandStart, redirectIndex);
+    const parsed = parseScheduledBindingArgv(tail);
+    if (parsed)
+        return parsed;
+    // Rows written by akm < 0.9.2 (before `--scheduler-context` existed) have
+    // no context argument at all — just the akm argv immediately followed by
+    // the public `task run …` / `workflow run …` tail. `extractCronInvocation`
+    // only ever runs on a body already isolated between this backend's own
+    // `# akm:task … BEGIN/END` sentinels (see `parseBlocks`), so recognizing
+    // this older shape here doesn't extend trust to any unmarked crontab
+    // line — it only lets sync see and reconcile a row akm already owns
+    // instead of treating it as absent and colliding with the still-present
+    // artifact (#881). Guarded on the marker's absence so a row that DOES
+    // carry `--scheduler-context` but fails to parse for some other reason
+    // is never silently reinterpreted as legacy.
+    if (tail.includes(SCHEDULER_CONTEXT_ARG))
+        return undefined;
+    return extractLegacyCronInvocation(tail);
+}
+function extractLegacyCronInvocation(tail) {
+    for (let index = 0; index < tail.length - 1; index += 1) {
+        if ((tail[index] === "task" || tail[index] === "workflow") && tail[index + 1] === "run") {
+            const publicInvocation = parsePublicSchedulerInvocation(tail.slice(index));
+            if (!publicInvocation)
+                return undefined;
+            return {
+                binding: tail.slice(0, index),
+                contextPath: "",
+                invocation: publicInvocation.invocation,
+                ...(publicInvocation.target !== undefined ? { target: publicInvocation.target } : {}),
+            };
+        }
+    }
+    return undefined;
 }
 /** Reverse {@link quoteForCron} for a single whitespace-free token. */
 function splitCronShellWords(value) {

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);
     }