akm-cli 0.9.31 → 0.10.261002-beta

package/dist/setup/detect.js

@@ -14,6 +14,7 @@ import { runManagedSubprocess } from "../core/subprocess.js";
 import { defaultWhich } from "../integrations/agent/detect.js";
 import { getBuiltinAgentProfile, OPENCODE_SDK_SERVER_BIN } from "../integrations/agent/profiles.js";
 import { AGENT_DISPATCH_HARNESSES, SESSION_LOG_HARNESSES } from "../integrations/harnesses/index.js";
+import { detectOpencodeMajor, resolveOpencodeBin } from "../integrations/harnesses/opencode/version.js";
 import { detectHarnessConfigs } from "./harness-config-import.js";
 let detectOverrides;
 /** TEST-ONLY. Swap the network/host probes; pass undefined to restore. */
@@ -342,7 +343,8 @@ function findGitRepoRoot(start) {
  *   3. none.
  *
  * The SDK import resolving is NOT evidence the SDK path can run: `@opencode-ai/sdk`
- * is a hard dependency of akm-cli itself, so `import()` always succeeds and an
+ * (OpenCode 1) and `@opencode/client` (OpenCode 2; the binary's detected major
+ * selects) are hard dependencies of akm-cli itself, so `import()` always succeeds and an
  * import-only check would report `opencode-sdk` on every machine — including
  * ones where the first agentic command then dies with spawn ENOENT. The SDK
  * runner spawns `opencode serve` (see `harnesses/opencode-sdk/sdk-runner.ts`),
@@ -355,10 +357,14 @@ function findGitRepoRoot(start) {
 export async function detectHarness(whichFn = defaultWhich) {
     // Probed once; reused below so the `opencode` CLI fallback doesn't repeat
     // the identical full-PATH walk this just performed.
-    const opencodePath = whichFn(OPENCODE_SDK_SERVER_BIN);
+    const opencodePath = whichFn(resolveOpencodeBin(undefined, whichFn));
     if (opencodePath) {
         try {
-            await import("@opencode-ai/sdk");
+            // The client package of the major the binary reports.
+            if (detectOpencodeMajor(opencodePath).major === 1)
+                await import("@opencode-ai/sdk");
+            else
+                await import("@opencode/client");
             return "opencode-sdk";
         }
         catch {
@@ -368,7 +374,7 @@ export async function detectHarness(whichFn = defaultWhich) {
     }
     for (const harness of AGENT_DISPATCH_HARNESSES) {
         // The SDK harness dispatches without a CLI profile and was decided above;
-        // an explicit skip so a future BUILTINS entry for it can't silently
+        // an explicit skip so a future `profile` for it can't silently
         // reintroduce it here after the import guard already rejected it.
         if (harness.id === "opencode-sdk")
             continue;

package/dist/setup/harness-config-import.js

@@ -8,8 +8,8 @@
  * no network) and, if so, reads its config to extract LLM connection details.
  * API key VALUES are never stored — only the env var names that hold them.
  *
- * To add a new harness: implement {@link HarnessConfigImporter} and append it
- * to {@link HARNESS_CONFIG_IMPORTERS}.
+ * To add a new harness importer: declare `configImporter` on the harness
+ * descriptor (`integrations/harnesses/<id>/index.ts`).
  *
  * NOTE: The `detect()` method in each importer overlaps intentionally with
  * `detectAgentPlatforms()` in `detect.ts`. That function scans for harness
@@ -17,18 +17,9 @@
  * further by reading and parsing the harness config. They serve different
  * purposes and should not be deduplicated.
  */
-import { claudeCodeImporter } from "../integrations/harnesses/claude/config-import.js";
-import { openCodeImporter } from "../integrations/harnesses/opencode/config-import.js";
-// The Claude Code importer was migrated to its harness directory in #563
-// (`harnesses/claude/config-import.ts`) and the OpenCode importer in #564
-// (`harnesses/opencode/config-import.ts`). Both are imported back into
-// HARNESS_CONFIG_IMPORTERS below so detection order is unchanged.
-// ── Registry ─────────────────────────────────────────────────────────────────
-/**
- * Registry of all supported harness config importers.
- * To add a new harness: implement {@link HarnessConfigImporter} and append here.
- */
-export const HARNESS_CONFIG_IMPORTERS = [claudeCodeImporter, openCodeImporter];
+import { HARNESS_REGISTRY } from "../integrations/harnesses/index.js";
+/** Importers declared by the registered harnesses, in registry order. */
+export const HARNESS_CONFIG_IMPORTERS = HARNESS_REGISTRY.flatMap((h) => h.configImporter ? [h.configImporter] : []);
 /**
  * Run all importers whose `detect()` returns `true` and collect their configs.
  *

package/dist/setup/setup.js

@@ -625,7 +625,7 @@ export async function runSetupWizard(opts) {
         }
     }
     p.outro(`Configuration saved to ${configPath}\n` +
-        'Next: `akm bundle add <source>`, `akm index`, `akm search "<query>"`, `akm help agents`');
+        'Next: `akm bundle add <source>`, `akm index`, `akm search "<query>"`, `akm hints`');
 }
 // ── Non-interactive / scripting entry points ─────────────────────────────────
 /**

package/dist/setup/steps/tasks.js

@@ -19,13 +19,12 @@ import { parseSchedule } from "../../tasks/schedule.js";
 import { parseTaskSource } from "../../tasks/source/parse-task-source.js";
 import { prompt } from "../prompt.js";
 /**
- * A scheduled server-only nightly full sweep exists among the embedded
- * improve-schedule templates (folded in from the retired
- * `registerDefaultTasks`/`akm tasks init` path in 0.9, S6). This id is
- * preselected in the review multiselect on a detected server install — the
- * "battery heuristic" {@link detectServerDefault} preserved from that path.
+ * The nightly improve template (`core/improve`). This id is preselected in the
+ * review multiselect on a detected server install — the "battery heuristic"
+ * {@link detectServerDefault} preserved from the retired
+ * `registerDefaultTasks`/`akm tasks init` path (0.9, S6).
  */
-const SERVER_SUGGESTED_TASK_ID = "akm-improve-nightly";
+const SERVER_SUGGESTED_TASK_ID = "improve";
 let scheduledTasksEnvOverrides;
 /** TEST-ONLY. Swap the CI/server-detection probes; pass undefined to restore. */
 export function _setScheduledTasksEnvForTests(fakes) {
@@ -66,7 +65,7 @@ export function detectServerDefault() {
     }
     catch {
         // If we cannot read power-supply info, prefer the safe server default on
-        // Linux (the nightly sweep is low-impact and re-runnable).
+        // Linux (the nightly improve run is low-impact and re-runnable).
         return true;
     }
 }
@@ -200,11 +199,11 @@ export async function stepScheduledTasks(deps = DEFAULT_SCHEDULED_TASKS_DEPS, op
         p.log.info("Non-interactive setup leaves task files and scheduler state unchanged. Run `akm setup` interactively to review tasks.");
         return;
     }
-    // ALL templates are offered, including ships-disabled ones (e.g. the
-    // manual-recovery catchup task): an unselected template is still PREPARED,
-    // so its YAML exists for `akm task run <id>` while its ref remains absent
-    // from local scheduler activation. Filtering on `task.enabled`
-    // here would make ships-disabled templates invisible and unpreparable.
+    // ALL templates are offered, including ships-disabled ones: an unselected
+    // template is still PREPARED, so its YAML exists for `akm task run <id>`
+    // while its ref remains absent from local scheduler activation. Filtering on
+    // `task.enabled` here would make ships-disabled templates invisible and
+    // unpreparable.
     const embedded = listEmbeddedTasks();
     if (embedded.length === 0)
         return;
@@ -228,7 +227,7 @@ export async function stepScheduledTasks(deps = DEFAULT_SCHEDULED_TASKS_DEPS, op
         byId.set(normaliseTaskIdForMatch(task.id), task);
     const preChecked = embedded.filter((task) => byId.get(task.id)?.enabled === true).map((task) => task.id);
     // Battery heuristic preserved from the retired `registerDefaultTasks` path
-    // (S6): suggest the nightly full sweep on a detected server install, same
+    // (S6): suggest the nightly improve task on a detected server install, same
     // as every other embedded template, still gated behind the confirmation
     // below.
     if (!byId.has(SERVER_SUGGESTED_TASK_ID) &&

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

@@ -257,8 +257,11 @@ export function saveGitStash(name, message, writableOverride, options) {
     if (statusResult.error || statusResult.status !== 0) {
         throw new Error(`git status failed: ${statusResult.error?.message || statusResult.stderr?.trim() || "unknown error"}`);
     }
+    const hasRemote = readHasRemote(repoDir);
+    // `--no-push`, a read-only bundle and a bundle without a remote never touch the network.
+    const syncWithRemote = hasRemote && writable && allowPush;
     if (!statusResult.stdout.trim() && options?.paths === undefined) {
-        return { committed: false, pushed: false, skipped: false, output: "nothing to commit, working tree clean" };
+        return nothingToCommit(repoDir, "nothing to commit, working tree clean", syncWithRemote);
     }
     // Scoped staging (#476 + the auto-sync incident): NEVER refuse akm's commit
     // because unrelated non-akm files exist in the working tree. When the stash
@@ -277,22 +280,14 @@ export function saveGitStash(name, message, writableOverride, options) {
         : "";
     const changedPaths = listGitChangedPaths(repoDir);
     const requestedPaths = normalizeExactPaths(repoDir, options?.paths ??
-        (managedRelativeRoot && managedRelativeRoot !== ".." && !managedRelativeRoot.startsWith("../")
+        withoutIgnoredPaths(repoDir, managedRelativeRoot && managedRelativeRoot !== ".." && !managedRelativeRoot.startsWith("../")
             ? changedPaths.filter((changedPath) => changedPath === managedRelativeRoot || changedPath.startsWith(`${managedRelativeRoot}/`))
             : managedFallbackPaths(repoDir, changedPaths)));
     if (requestedPaths.length === 0) {
-        return { committed: false, pushed: false, skipped: false, output: "nothing to commit" };
+        return nothingToCommit(repoDir, "nothing to commit", syncWithRemote);
     }
     assertNoIgnoredExactPaths(repoDir, requestedPaths);
     const baseHead = readOptionalHead(repoDir);
-    const remoteResult = runGit(["-C", repoDir, "remote"]);
-    if (remoteResult.status !== 0) {
-        throw new Error(`git remote failed: ${remoteResult.stderr?.trim() || "unknown error"}`);
-    }
-    const hasRemote = remoteResult.stdout.trim().length > 0;
-    // A branch that cannot be pushed still gets its commit: only the push is skipped, and the result says why.
-    const upstream = hasRemote && writable && allowPush ? readActualUpstream(repoDir, baseHead) : undefined;
-    const pushTarget = typeof upstream === "object" ? upstream : undefined;
     const exactCommit = createExactPathCommit(repoDir, {
         baseHead,
         commitMessage,
@@ -301,8 +296,17 @@ export function saveGitStash(name, message, writableOverride, options) {
         expectedSnapshots: options?.expectedSnapshots,
     });
     if (!exactCommit) {
-        return { committed: false, pushed: false, skipped: false, output: "nothing to commit" };
-    }
+        return nothingToCommit(repoDir, "nothing to commit", syncWithRemote);
+    }
+    // Bring in whatever another host pushed, then push. A branch that cannot be pushed still keeps its
+    // commit: only the push is skipped, and the result says why.
+    const integration = syncWithRemote ? integrateUpstream(repoDir) : undefined;
+    const upstream = integration && "blocked" in integration
+        ? integration.blocked
+        : syncWithRemote
+            ? readActualUpstream(repoDir, readOptionalHead(repoDir))
+            : undefined;
+    const pushTarget = typeof upstream === "object" ? upstream : undefined;
     if (!pushTarget) {
         return {
             committed: true,
@@ -319,7 +323,7 @@ export function saveGitStash(name, message, writableOverride, options) {
         "push",
         `--force-with-lease=${pushTarget.mergeRef}:${pushTarget.upstreamHead}`,
         pushTarget.remote,
-        `${exactCommit}:${pushTarget.mergeRef}`,
+        `${readOptionalHead(repoDir) ?? exactCommit}:${pushTarget.mergeRef}`,
     ], { timeout: GIT_PUSH_TIMEOUT_MS });
     if (pushResult.status !== 0) {
         throw new GitStashPushError(`git push failed: ${pushResult.stderr?.trim() || "unknown error"}`, exactCommit);
@@ -332,11 +336,98 @@ export function saveGitStash(name, message, writableOverride, options) {
         commit: exactCommit,
     };
 }
+function readHasRemote(repoDir) {
+    const remoteResult = runGit(["-C", repoDir, "remote"]);
+    if (remoteResult.status !== 0) {
+        throw new Error(`git remote failed: ${remoteResult.stderr?.trim() || "unknown error"}`);
+    }
+    return remoteResult.stdout.trim().length > 0;
+}
+/** Nothing to commit still brings in the upstream, so a host with no changes of its own keeps up. */
+function nothingToCommit(repoDir, output, syncWithRemote) {
+    const integration = syncWithRemote ? integrateUpstream(repoDir) : undefined;
+    if (integration && "blocked" in integration) {
+        return { committed: false, pushed: false, skipped: false, reason: `not pushed: ${integration.blocked}`, output };
+    }
+    return { committed: false, pushed: false, skipped: false, output: integration?.integrated ?? output };
+}
+function readUpstreamConfig(repoDir) {
+    const branchRef = runGit(["-C", repoDir, "symbolic-ref", "--quiet", "HEAD"]);
+    if (branchRef.status !== 0 || !branchRef.stdout.trim())
+        return undefined;
+    const branch = branchRef.stdout.trim().replace(/^refs\/heads\//, "");
+    const remote = runGit(["-C", repoDir, "config", "--get", `branch.${branch}.remote`]);
+    const merge = runGit(["-C", repoDir, "config", "--get", `branch.${branch}.merge`]);
+    if (remote.status !== 0 || merge.status !== 0)
+        return undefined;
+    return { remote: remote.stdout.trim(), mergeRef: merge.stdout.trim() };
+}
+function isAncestor(repoDir, ancestor, descendant) {
+    return runGit(["-C", repoDir, "merge-base", "--is-ancestor", ancestor, descendant]).status === 0;
+}
+/**
+ * Fetch the branch's remote and bring its upstream into HEAD: nothing to do when HEAD already has it,
+ * a fast-forward when HEAD is behind, otherwise git's default merge. A merge that conflicts is aborted
+ * so the working tree and the local commits stay exactly as they were. `blocked` says why the branch
+ * could not be brought up to date (and therefore must not be pushed); `integrated` describes what moved.
+ */
+function integrateUpstream(repoDir) {
+    const config = readUpstreamConfig(repoDir);
+    if (!config)
+        return {};
+    const fetch = runGit(["-C", repoDir, "fetch", config.remote], { timeout: GIT_PUSH_TIMEOUT_MS });
+    if (fetch.status !== 0) {
+        return { blocked: `could not fetch ${config.remote}: ${fetch.stderr?.trim() || "unknown error"}` };
+    }
+    const upstream = runGit(["-C", repoDir, "rev-parse", "--verify", "@{u}"]);
+    const head = readOptionalHead(repoDir);
+    if (upstream.status !== 0 || !head)
+        return {};
+    const upstreamHead = upstream.stdout.trim();
+    if (isAncestor(repoDir, upstreamHead, head))
+        return {};
+    const fastForward = isAncestor(repoDir, head, upstreamHead);
+    const merge = runGit([
+        "-C",
+        repoDir,
+        "-c",
+        "user.name=akm",
+        "-c",
+        "user.email=akm@local",
+        "merge",
+        ...(fastForward ? ["--ff-only"] : ["--no-edit", "-m", `akm sync: merge ${config.remote} upstream`]),
+        upstreamHead,
+    ]);
+    if (merge.status === 0)
+        return { integrated: fastForward ? "fast-forwarded to upstream" : "merged upstream" };
+    const conflicted = runGit(["-C", repoDir, "diff", "--name-only", "--diff-filter=U"])
+        .stdout.split("\n")
+        .filter(Boolean);
+    // Not every refusal leaves a merge in progress (e.g. local changes in the way); abort only if one is.
+    if (runGit(["-C", repoDir, "rev-parse", "--verify", "--quiet", "MERGE_HEAD"]).status === 0) {
+        runGit(["-C", repoDir, "merge", "--abort"]);
+    }
+    return {
+        blocked: conflicted.length > 0
+            ? `merging upstream conflicts in ${conflicted.join(", ")}; the merge was aborted and the local commit kept`
+            : `could not merge upstream (${merge.stderr?.trim() || merge.stdout?.trim() || "unknown error"}); the local commit was kept`,
+    };
+}
 function managedFallbackPaths(repoDir, changedPaths) {
     const ownedDirs = akmAdapter.directoryList?.({ id: "akm", adapter: "akm", root: repoDir, writable: false }) ?? stashDirNames();
     const prefixes = [...ownedDirs, ".akm"];
     return changedPaths.filter((changedPath) => prefixes.some((prefix) => changedPath === prefix || changedPath.startsWith(`${prefix}/`)));
 }
+/**
+ * Drop paths a `.gitignore` rule matches from the paths sync picks for itself. Ignoring means "do
+ * not publish", also for a file committed before the rule existed (`.akm/evals/runs/latest` in a
+ * stash whose eval runs are ignored): git refuses to stage such a file, which would fail the whole
+ * sync. Only an explicit `paths` request still reaches {@link assertNoIgnoredExactPaths}.
+ */
+function withoutIgnoredPaths(repoDir, paths) {
+    const ignored = new Set(listIgnoredExactPaths(repoDir, paths, { includeTracked: true }));
+    return ignored.size === 0 ? paths : paths.filter((candidate) => !ignored.has(candidate));
+}
 function normalizeExactPaths(repoDir, paths) {
     const normalized = [...new Set(paths.map((value) => value.replaceAll(path.sep, "/")))];
     for (const filePath of normalized) {
@@ -363,11 +454,17 @@ function runExactPathChunks(repoDir, command, paths, options = {}) {
     }
     return results;
 }
-export function listIgnoredExactPaths(repoDir, paths) {
+/**
+ * The subset of `paths` a `.gitignore` rule matches. By default a tracked file never counts (git's
+ * own `check-ignore` skips it); `includeTracked` asks about the rule alone, as `git add` does.
+ */
+export function listIgnoredExactPaths(repoDir, paths, options = {}) {
     if (paths.length === 0)
         return [];
     const input = `${paths.join("\0")}\0`;
-    const result = runGit(["-C", repoDir, "check-ignore", "-z", "--stdin"], { input });
+    const result = runGit(["-C", repoDir, "check-ignore", "-z", "--stdin", ...(options.includeTracked ? ["--no-index"] : [])], {
+        input,
+    });
     if (result.status === 1)
         return [];
     if (result.status !== 0) {

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

@@ -5,11 +5,10 @@
  * `index.db` utility-score + retrieval-count repository (MemRL signals).
  *
  * Owns the raw SQL for `utility_scores` and the retrieval-frequency counting
- * over `usage_events`. The bounded-step EMA policy itself lives in
- * `indexer/feedback/utility-policy`; this repo only reads/writes.
+ * over `usage_events`. The utility formula itself lives in
+ * `recomputeUtilityScores` (`indexer/indexer.ts`); this repo only reads/writes.
  */
 import { conceptIdFromTypeName, parseRefInput } from "../../core/asset/resolve-ref.js";
-import { computeNextUtility } from "../../indexer/feedback/utility-policy.js";
 import { SQLITE_CHUNK_SIZE } from "./index-sql.js";
 /**
  * Get the utility score for an entry, or undefined if none exists.
@@ -242,35 +241,6 @@ function getSourceScopedRetrievalCounts(indexDb, stateDb, refs, options) {
     }
     return result;
 }
-/**
- * Apply accumulated feedback counts to the utility score of an entry, persisting
- * the result. The bounded-step EMA policy itself (MemRL, F-5 / #386,
- * arXiv:2601.03192) lives in {@link computeNextUtility} (feedback/utility-policy);
- * this function only reads the current utility, applies the policy, and writes
- * the new value.
- *
- * A new entry starts at 0.5 (neutral midpoint) before the EMA step is applied.
- * When there is no feedback (both counts zero) the score is left untouched — no
- * DB write. Returns a {@link FeedbackUtilityResult} so the caller can detect a
- * previously high-utility asset crossing below the review threshold and escalate.
- */
-export function applyFeedbackToUtilityScore(db, entryId, positiveCount, negativeCount) {
-    const existing = getUtilityScore(db, entryId);
-    const previousUtility = existing?.utility ?? 0.5;
-    const result = computeNextUtility(previousUtility, positiveCount, negativeCount);
-    if (positiveCount === 0 && negativeCount === 0) {
-        return result;
-    }
-    const now = new Date().toISOString();
-    db.prepare(`
-    INSERT INTO utility_scores (entry_id, utility, show_count, search_count, select_rate, last_used_at, updated_at)
-    VALUES (?, ?, 0, 0, 0, ?, ?)
-    ON CONFLICT(entry_id) DO UPDATE SET
-      utility    = ?,
-      updated_at = ?
-  `).run(entryId, result.nextUtility, now, now, result.nextUtility, now);
-    return result;
-}
 /**
  * Every indexed entry with its `utility_scores` row (when it has one), for
  * `akm metrics`. `utility_scores` is keyed by the unstable `entry_id`, so the

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

@@ -140,6 +140,10 @@ export function getNeighborsByEntryId(db, id, k, scope) {
         return [];
     return searchVec(db, new Float32Array(row.embedding.slice().buffer), k, scope);
 }
+/** Whether the entry has a stored vector (what {@link getNeighborsByEntryId} reads). */
+export function hasStoredEmbedding(db, id) {
+    return db.prepare("SELECT 1 FROM embeddings WHERE id = ?").get(id) != null;
+}
 /**
  * Every entry that has no embedding row for `model` (any row when no model is
  * given), with its embedding input derived from the stored document

package/dist/storage/repositories/task-history-repository.js

@@ -67,10 +67,6 @@ export function decodeTaskHistoryMetadata(input) {
     // A malformed `engine` (wrong type) is dropped like any other unrecognized
     // field rather than rejecting the whole row over a non-essential value.
     const engine = parsed.engine === null || typeof parsed.engine === "string" ? parsed.engine : undefined;
-    if (parsed.targetVocab !== undefined && parsed.targetVocab !== 2) {
-        warnOnce(`task-history-target-vocab:${String(parsed.targetVocab)}`, `task_history row has targetVocab ${String(parsed.targetVocab)}, newer than this akm's 2 — falling back to ` +
-            "the legacy target_kind mapping rather than rejecting the row.");
-    }
     validateDetail(detail);
     const cleanDetail = detail
         ? {
@@ -85,7 +81,6 @@ export function decodeTaskHistoryMetadata(input) {
         durationMs: parsed.durationMs,
         detail: cleanDetail,
         ...(engine !== undefined ? { engine } : {}),
-        ...(parsed.targetVocab === 2 ? { targetVocab: 2 } : {}),
     };
 }
 /**

package/dist/storage/repositories/workflow-runs-repository.js

@@ -353,15 +353,6 @@ export class WorkflowRunsRepository {
             return db.prepare("SELECT * FROM workflow_runs WHERE id = ?").get(input.run.id);
         });
     }
-    /**
-     * Persist a run's resolved declared `outputs:` (migration 024, P3b §4.3).
-     * Called from INSIDE `completeWorkflowStep`'s own write transaction — this
-     * method opens none of its own, matching `updateStepCompletion` /
-     * `updateRunState` immediately above.
-     */
-    setRunOutputs(runId, outputsJson) {
-        this.db.prepare("UPDATE workflow_runs SET outputs_json = ? WHERE id = ?").run(outputsJson, runId);
-    }
     /** Every child run published under `parentRunId`, oldest first. `[]` when none. */
     childRunsOf(parentRunId) {
         return this.db
@@ -432,13 +423,13 @@ export class WorkflowRunsRepository {
             const dispatchId = randomUUID();
             db.prepare(`INSERT INTO workflow_run_unit_attempts (
            run_id, unit_id, attempt, dispatch_id, step_id, node_id, phase,
-           runner, engine, model, input_hash, status, worktree_path, started_at,
+           runner, engine, model, input_hash, status, started_at,
            claim_holder, claim_expires_at
-         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?)`).run(input.runId, input.unitId, attemptNumber, dispatchId, input.stepId, input.nodeId, input.phase, input.runner, input.engine, input.model, input.inputHash, input.worktreePath ?? null, input.now, holder, input.now);
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?)`).run(input.runId, input.unitId, attemptNumber, dispatchId, input.stepId, input.nodeId, input.phase, input.runner, input.engine, input.model, input.inputHash, input.now, holder, input.now);
             db.prepare(`INSERT INTO workflow_run_units (
            run_id, unit_id, step_id, node_id, parent_unit_id, phase, runner, engine, model,
-           status, input_hash, worktree_path, started_at, claim_holder, claim_expires_at, attempts
-         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?)
+           status, input_hash, started_at, claim_holder, claim_expires_at, attempts
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?)
          ON CONFLICT(run_id, unit_id) DO UPDATE SET
            step_id = excluded.step_id,
            node_id = excluded.node_id,
@@ -449,7 +440,6 @@ export class WorkflowRunsRepository {
            model = excluded.model,
            status = 'running',
            input_hash = excluded.input_hash,
-           worktree_path = excluded.worktree_path,
            started_at = excluded.started_at,
            claim_holder = excluded.claim_holder,
            claim_expires_at = excluded.claim_expires_at,
@@ -458,7 +448,7 @@ export class WorkflowRunsRepository {
            failure_reason = NULL,
            session_id = NULL,
            finished_at = NULL,
-           attempts = excluded.attempts`).run(input.runId, input.unitId, input.stepId, input.nodeId, input.parentUnitId ?? null, input.phase, input.runner, input.engine, input.model, input.inputHash, input.worktreePath ?? null, input.now, holder, input.now, attemptNumber);
+           attempts = excluded.attempts`).run(input.runId, input.unitId, input.stepId, input.nodeId, input.parentUnitId ?? null, input.phase, input.runner, input.engine, input.model, input.inputHash, input.now, holder, input.now, attemptNumber);
             insertEventStrict(db, {
                 eventType: "workflow_unit_started",
                 ts: input.now,

package/dist/tasks/embedded.js

@@ -25,7 +25,8 @@ import { getDirname } from "../runtime.js";
 import { parseTaskSource } from "./source/parse-task-source.js";
 /** Directory holding the bundled task template categories. */
 const TASKS_ASSETS_DIR = path.join(getDirname(import.meta.url), "../assets/tasks");
-const DEFAULT_DISABLED_TASKS = new Set(["improve/akm-improve-catchup"]);
+/** Templates setup offers but ships disabled (`category/id`). None ship disabled since catchup was removed (#1130). */
+const DEFAULT_DISABLED_TASKS = new Set();
 /**
  * Enumerate the embedded task templates from every category subdirectory of
  * the bundled assets directory. Sorted by category then id for deterministic

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

@@ -3,6 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { dispatchPreparedCommandInvocation } from "../../commands/command/command-execution.js";
 import { finishAttempt } from "./attempt-lifecycle.js";
+import { DEFAULT_SCHEDULED_TASK_TIMEOUT_MS } from "./run-workflow-task.js";
 import { appendHistory } from "./task-history.js";
 import { persistRunLog, scrubTaskOutput, streamLines } from "./task-log.js";
 export async function runPreparedCommandTask(input) {
@@ -15,7 +16,14 @@ export async function runPreparedCommandTask(input) {
         // into the dispatched engine's child env and the recorded usage events.
         eventSource: provenance.eventSource,
     };
-    const result = await dispatchPreparedCommandInvocation(task.invocation, dispatchOptions);
+    // Unset anywhere (task `timeout:`, command asset, engine) → the unattended
+    // default; an explicit value or `null` (opt-out) already sits on the request.
+    const { request, runner } = task.invocation;
+    const unset = !Object.hasOwn(request.runtime, "timeoutMs") && runner.timeoutMs === undefined;
+    const invocation = unset
+        ? { ...task.invocation, runner: { ...runner, timeoutMs: DEFAULT_SCHEDULED_TASK_TIMEOUT_MS } }
+        : task.invocation;
+    const result = await dispatchPreparedCommandInvocation(invocation, dispatchOptions);
     const engineName = result.engine;
     const finishedAt = finishAttempt(startedAt, now());
     const log = renderPromptLog({ task, engineName, result, notices: result.notices, warnings: result.warnings });

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

@@ -50,11 +50,12 @@ import { persistRunLog, scrubTaskOutput } from "./task-log.js";
  */
 export const DEFAULT_WORKFLOW_TASK_TIMEOUT_MS = 6 * 60 * 60 * 1000;
 /**
- * The same unattended default for command and prompt tasks.
+ * The same unattended default for the other scheduled task kinds: `uses: commands/…`
+ * command tasks and native shell/script tasks.
  *
  * The reasoning above is about SCHEDULED runs, not about workflows: nobody is
- * watching, and one wedged run silently stops the schedule. Command tasks
- * defaulted to `null` (no kill timer) and prompt tasks inherited
+ * watching, and one wedged run silently stops the schedule. Native shell/script
+ * tasks defaulted to `null` (no kill timer) and command tasks inherited
  * DEFAULT_AGENT_TIMEOUT_MS, also null — so a hung `curl`, a prompting agent
  * waiting on stdin, or a stuck engine wedged the task forever while the
  * workflow arm was protected. Same value, same opt-out: an explicit

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

@@ -49,8 +49,6 @@ export function appendHistory(result, historyReserved = false) {
             metadataVersion: 2,
             durationMs: result.durationMs,
             detail: result.detail ?? null,
-            // D8 (spec §5.3): every NEW row carries the vocabulary marker.
-            targetVocab: 2,
             ...(result.target.kind === "command" ? { engine: result.target.engine } : {}),
         }),
     };

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

@@ -20,7 +20,7 @@ import path from "node:path";
 import { loadConfig } from "../../core/config/config.js";
 import { rethrowIfTestIsolationError } from "../../core/errors.js";
 import { buildTaskRunId, insertTaskLogLines, openLogsDatabase, } from "../../core/logs-db.js";
-import { getTaskLogDir } from "../../core/paths.js";
+import { getRunLogDir, getTaskLogDir } from "../../core/paths.js";
 import { redactCredentialPatterns, redactSensitiveText } from "../../core/redaction.js";
 import { collectTaskLogSensitiveValues } from "../log-redaction.js";
 function taskLogPath(logDir, taskId, startedAtIso) {
@@ -95,6 +95,43 @@ export function purgeOldTaskLogFiles(logDir, retentionDays = 90) {
     }
     return deleted;
 }
+/**
+ * Delete the flat per-run `akm improve` and `akm index` log files
+ * (`$CACHE/logs/{improve,index}/<ISO>.log`) older than `retentionDays`. Same
+ * best-effort contract as {@link purgeOldTaskLogFiles}; `.log` files directly
+ * inside each directory only.
+ */
+export function purgeOldRunLogFiles(retentionDays = 90) {
+    if (!Number.isFinite(retentionDays) || retentionDays <= 0)
+        return 0;
+    const cutoffMs = Date.now() - retentionDays * 86_400_000;
+    let deleted = 0;
+    for (const dir of [getRunLogDir("improve"), getRunLogDir("index")]) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            rethrowIfTestIsolationError(error);
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".log"))
+                continue;
+            const filePath = path.join(dir, entry.name);
+            try {
+                if (fs.statSync(filePath).mtimeMs < cutoffMs) {
+                    fs.unlinkSync(filePath);
+                    deleted++;
+                }
+            }
+            catch (error) {
+                rethrowIfTestIsolationError(error);
+            }
+        }
+    }
+    return deleted;
+}
 /**
  * Redact logs.db rows against the SAME contiguous text the file sink sees.
  *

package/dist/tasks/schedule-gates.js

@@ -0,0 +1,39 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * The two per-source schedule gates `akm task sync` runs before it installs a
+ * schedule, kept in a leaf module so `akm lint` can run them without importing
+ * the scheduler's task-preparation graph (which reaches the adapter registry
+ * that lint itself is part of).
+ */
+import { UsageError } from "../core/errors.js";
+import { applyInputDefaults, validateInputs } from "../execution/input-contract.js";
+import { parseSchedule } from "./schedule.js";
+/**
+ * Validate every v4 `schedule:` entry's `inputs` against the task's own
+ * declared contract with defaults applied — the exact set of values a
+ * compiled invocation delivers — so a violation is reported at sync rather
+ * than when the scheduler fires. Shared with `akm lint`.
+ */
+export function assertTaskScheduleInputsSatisfyContract(v4, refLabel) {
+    const contract = v4.inputs ?? {};
+    for (const scheduleEntry of v4.schedule) {
+        const defaultedInputs = applyInputDefaults(contract, { ...scheduleEntry.inputs });
+        const errors = validateInputs(contract, defaultedInputs);
+        if (errors.length > 0) {
+            throw new UsageError(`Task ${JSON.stringify(refLabel)} schedule[${scheduleEntry.ordinal}].inputs does not satisfy ` +
+                `its declared inputs once defaults are applied: ${errors.join("; ")}`, "TASK_SOURCE_INVALID");
+        }
+    }
+}
+/**
+ * Validate every v4 `schedule:` entry's `cron` against the active backend's
+ * dialect: cron is the most permissive of the three, so a task authored on
+ * Linux can carry an expression launchd/schtasks cannot translate. Shared
+ * with `akm lint`.
+ */
+export function assertTaskScheduleCronValid(v4, backend) {
+    for (const scheduleEntry of v4.schedule)
+        parseSchedule(scheduleEntry.cron, backend);
+}

package/dist/tasks/scheduler-binding.js

@@ -62,22 +62,6 @@ function schedulerInputFlagValueText(value) {
         return String(value);
     return canonicalInputJson(value);
 }
-export function compileWorkflowSchedulerBindings(input) {
-    const ref = assertQualifiedRef(input.qualifiedRef, "workflow");
-    return Object.freeze(input.schedules.map((schedule) => {
-        const bindingId = digestBindingId("workflow", ref, schedule.ordinal);
-        return freezeBinding({
-            id: bindingId,
-            nativeId: bindingId,
-            logicalSource: { kind: "workflow", ref },
-            cron: schedule.cron,
-            source: schedule.source,
-            ordinal: schedule.ordinal,
-            enabled: true,
-            invocation: ["workflow", "run", ref],
-        });
-    }));
-}
 /**
  * Map a logical binding id to the flat portable token persisted by native
  * schedulers. Flat ids are byte-for-byte stable; only nested standalone