akm-cli 0.9.30 → 0.10.261001-beta

package/dist/core/config/schema/improve-processes.js

@@ -54,15 +54,14 @@ const allowedTypesField = z.array(z.string().min(1)).optional();
 const excludeRefPrefixesField = z.array(z.string().min(1)).optional();
 /**
  * Consolidate process: hard cap on memories processed per pass.
- * Reflect/distill: max refs processed (same as profile-level `limit`).
- * proactiveMaintenance: fallback when `maxPerRun` is absent.
+ * Reflect: max refs processed (same as profile-level `limit`).
  */
 const processLimitField = positiveInt.optional();
 /**
  * The distill and reflect LLM-as-judge quality gates. Default ON; set
  * `enabled: false` on the process to opt out. A judge error, timeout or
- * unparsable reply never passes: distill sends the lesson to review and
- * reflect refuses the edit. `engine`, `model`, `timeoutMs` and `llm` give the
+ * unparsable reply never passes: distill and reflect both send the content
+ * to a person. `engine`, `model`, `timeoutMs` and `llm` give the
  * gate a judge of its own (#1011), resolved over the process's own settings;
  * with none set, the gate judges with the generator's runner.
  */
@@ -90,19 +89,6 @@ const clsField = z
 })
     .passthrough()
     .optional();
-/**
- * WS-3b: Distill→source fidelity check (step 10). After a distill proposal,
- * check it against its cited source memories; a contradiction flag forces
- * human review. Default OFF. Distill process only.
- */
-const fidelityCheckField = z.object({ enabled: z.boolean().optional() }).passthrough().optional();
-/**
- * #639 — semantic value-floor filter for the `reflect` process. When
- * enabled, proposals classified as "low-value" by the deterministic noise
- * gate are deferred. DEFAULT OFF (absent / { enabled: false } = pre-#639
- * byte-identical behaviour). Reflect process only.
- */
-const lowValueFilterField = z.object({ enabled: z.boolean().optional() }).passthrough().optional();
 /**
  * The wording lists of reflect's pre-judge defect filter (`findReflectDefect`).
  * Each list is optional: one that is set replaces that rule's default list, and
@@ -152,57 +138,28 @@ const triageJudgmentField = z
     .union([z.boolean(), triageJudgmentObjectField])
     .transform((value) => typeof value === "boolean" ? { enabled: value } : { ...value, enabled: value.enabled ?? true })
     .optional();
-/**
- * WS-3b: Anti-collapse guard (step 8), consolidate process only: a small
- * random (non-similarity-driven) fraction of the pool is mixed into the
- * clustered order so consolidation is not purely rich-get-richer. Default ON
- * (opt out via `enabled: false`); `randomClusterFraction` defaults to 0.05.
- * The retired merge guards (`maxGeneration`, `lexicalDiversityCheck`,
- * `mergeInformationFloor`, `minSpecificityRetention`) never refused a merge
- * and are tolerated as unknown keys.
- */
-const antiCollapseField = z
-    .object({
-    enabled: z.boolean().optional(),
-    randomClusterFraction: z.number().min(0).max(1).optional(),
-})
-    .passthrough()
-    .optional();
 const REFLECT_PROCESS_FIELDS = {
     allowedTypes: allowedTypesField,
     excludeRefPrefixes: excludeRefPrefixesField,
     limit: processLimitField,
     qualityGate: qualityGateField,
-    lowValueFilter: lowValueFilterField,
     defectFilter: defectFilterField,
 };
 const DISTILL_PROCESS_FIELDS = {
     allowedTypes: allowedTypesField,
-    limit: processLimitField,
     qualityGate: qualityGateField,
     // Skip distill entirely when reflect produced zero planned refs.
     requirePlannedRefs: z.boolean().optional(),
     cls: clsField,
-    fidelityCheck: fidelityCheckField,
 };
 const CONSOLIDATE_PROCESS_FIELDS = {
     allowedTypes: allowedTypesField,
     limit: processLimitField,
-    // Minimum eligible-memory pool size below which the consolidation pass skips
-    // entirely (emits `pool_below_min_size`). 0 disables the guard. Default 500.
-    minPoolSize: z.number().int().min(0).optional(),
     maxChunkSize: z.number().int().min(1).max(50).optional(),
-    // Fallback p90 wall-clock time per consolidation chunk in seconds, used for
-    // cold-start budget estimation when no telemetry history exists. The actual
-    // p90 is derived from observed run durations once sufficient history
-    // accumulates; this value is only used on the very first run. Default 30s.
-    p90ChunkSecondsDefault: z.number().finite().positive().optional(),
-    antiCollapse: antiCollapseField,
 };
 const MEMORY_INFERENCE_PROCESS_FIELDS = {
     // Minimum pending memory count to run the pass.
     minPendingCount: z.number().int().min(0).optional(),
-    cls: clsField,
 };
 const EXTRACT_PROCESS_FIELDS = {
     defaultSince: z.string().min(1).optional(),
@@ -241,10 +198,8 @@ const TRIAGE_PROCESS_FIELDS = {
 const PROACTIVE_MAINTENANCE_PROCESS_FIELDS = {
     // Staleness gate + rotation cooldown in days (default 30).
     dueDays: z.number().int().min(0).optional(),
-    // Top-N bound per run (default 25). Alias for `limit`; `maxPerRun` wins
-    // when both are set.
+    // Top-N bound per run (default 15).
     maxPerRun: positiveInt.optional(),
-    limit: processLimitField,
 };
 /** distill/consolidate are memory-only and never read `excludeRefPrefixes` (reflect only, R12). */
 function rejectExcludeRefPrefixesOutsideReflect(value, ctx) {
@@ -306,8 +261,10 @@ export const ProactiveMaintenanceProcessConfigSchema = z
  * "unknown enabled process" check below — an old config must keep loading
  * (AGENTS.md "Reading persisted data"). `graphExtraction`: the LLM
  * entity-graph extraction it ran was retired in 0.9.17-alpha.9.
+ * `feedbackDistillation`: a wrapper of `processes.distill.enabled`, removed in
+ * 0.8.0.
  */
-const RETIRED_PROCESS_NAMES = new Set(["graphExtraction"]);
+const RETIRED_PROCESS_NAMES = new Set(["graphExtraction", "feedbackDistillation"]);
 const ImproveProfileProcessesSchema = z
     .object({
     reflect: ReflectProcessConfigSchema.optional(),
@@ -321,19 +278,9 @@ const ImproveProfileProcessesSchema = z
 })
     .passthrough()
     .superRefine((val, ctx) => {
-    // 0.8.0 removed the duplicated `feedbackDistillation` process key — it was
-    // a thin wrapper around `processes.distill.enabled`. Keep the migration
-    // hint so a stale config gets an actionable message rather than silently
-    // doing nothing. Other unknown process keys remain preserved for
-    // cross-version compatibility, but an enabled one is rejected below because
-    // this version cannot execute it.
-    if ("feedbackDistillation" in val) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "feedbackDistillation was removed in 0.8.0 — use processes.distill.enabled instead. " +
-                "It now controls both the orchestration gate and the LLM-call gate.",
-        });
-    }
+    // Unknown process keys remain preserved for cross-version compatibility,
+    // but an enabled one is rejected below because this version cannot
+    // execute it.
     for (const [name, process] of Object.entries(val)) {
         if (!IMPROVE_PROCESS_NAMES.includes(name) &&
             !RETIRED_PROCESS_NAMES.has(name) &&

package/dist/core/config/schema/improve.js

@@ -3,33 +3,14 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * Top-level `improve` config section (salience, state GC, strategies). Retired
- * keys (`salience.replayBudget`, `collapseDetector`, `utilityDecay`) are
+ * keys (`salience.replayBudget`, `salienceThreshold`, `collapseDetector`, `utilityDecay`) are
  * tolerated as unknown keys.
  */
 import { z } from "zod";
 import { ImproveProfileConfigSchema } from "./improve-processes.js";
 import { engineName, nonNegativeNumber } from "./primitives.js";
 // ── Improve top-level (event retention, salience, state GC) ────────────────
-const ImproveSalienceSchema = z
-    .object({
-    /**
-     * WS-2 Part-V gate: enable the outcome-weight term in the salience projection.
-     * Default TRUE/absent (DEFAULT ON since the G2 saturation cap landed — see
-     * salience.ts): uses the WS-2 weights (w_e=0.25, w_o=0.15, w_r=0.60) so the
-     * prediction-error outcome signal shapes rankScore (the R1 loop-closure).
-     * Set to `false` to opt out and restore the WS-1 parity weights
-     * (w_e=0.30, w_r=0.70, w_o=0); the `outcome` sub-score is still computed
-     * and stored for observability in that mode.
-     */
-    outcomeWeightEnabled: z.boolean().optional(),
-    /**
-     * Minimum encoding salience score [0, 1] for a zero-feedback asset to be
-     * admitted to the high-salience improve lane (#608).
-     * Default 0.75. Set to 1.0 to disable the lane entirely.
-     */
-    salienceThreshold: z.number().min(0).max(1).optional(),
-})
-    .passthrough();
+const ImproveSalienceSchema = z.object({}).passthrough();
 // #733 — orphan-GC pass (Workstream C, lean by design: one config gate).
 // The pass ALWAYS runs and ALWAYS reports counts (via the `asset_state_gc`
 // event); this gate controls ONLY whether it actually deletes rows whose

package/dist/core/config/schema/index-config.js

@@ -7,40 +7,14 @@
  * change.
  */
 import { z } from "zod";
-import { warnOnce } from "../../warn.js";
 import { engineName, LlmInvocationOverridesSchema, nonEmptyString, positiveInt } from "./primitives.js";
 // ── Index / per-pass ────────────────────────────────────────────────────────
-const INDEX_PASS_RETIRED_KEYS = new Set([
-    "endpoint",
-    "provider",
-    "apiKey",
-    "baseUrl",
-    "temperature",
-    "maxTokens",
-    "capabilities",
-]);
 /**
- * Per-pass `index.<pass>` entry. The preprocess names and drops the retired
- * engine settings above with a targeted message. Any other unknown key is kept
- * and named once by the config loader's schema walk, like an unknown key
- * anywhere else in config.
+ * Per-pass `index.<pass>` entry. Unknown keys (including inline engine
+ * settings an earlier release carried) are kept and named by the config
+ * loader's schema walk like any other unknown key.
  */
-export const IndexPassConfigSchema = z.preprocess((raw, ctx) => {
-    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-        return raw; // let z.object below produce the type error
-    }
-    const obj = raw;
-    let cleaned;
-    for (const key of Object.keys(obj)) {
-        const dotted = [...(ctx.path ?? []), key].join(".");
-        if (INDEX_PASS_RETIRED_KEYS.has(key)) {
-            warnOnce(`index-pass:retired:${dotted}`, `\`${dotted}\` is a retired engine setting and is ignored; select a named engine and use typed invocation fields instead.`);
-            cleaned ??= { ...obj };
-            delete cleaned[key];
-        }
-    }
-    return cleaned ?? raw;
-}, z
+export const IndexPassConfigSchema = z
     .object({
     engine: engineName.optional(),
     model: nonEmptyString.optional(),
@@ -48,7 +22,7 @@ export const IndexPassConfigSchema = z.preprocess((raw, ctx) => {
     enabled: z.boolean().optional(),
     llm: LlmInvocationOverridesSchema.optional(),
 })
-    .passthrough());
+    .passthrough();
 const IndexDefaultsSchema = z
     .object({
     engine: engineName.optional(),
@@ -80,14 +54,7 @@ const IndexConfigRuntimeSchema = z.preprocess((raw, ctx) => {
     }
     if (typeof raw !== "object")
         return raw;
-    let cleaned;
     for (const [passName, value] of Object.entries(raw)) {
-        if (passName === "stalenessDetection") {
-            warnOnce("index:stalenessDetection", "`index.stalenessDetection` is a retired pass and is ignored.");
-            cleaned ??= { ...raw };
-            delete cleaned.stalenessDetection;
-            continue;
-        }
         if (typeof value !== "object" || value === null || Array.isArray(value)) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
@@ -96,7 +63,7 @@ const IndexConfigRuntimeSchema = z.preprocess((raw, ctx) => {
             return raw;
         }
     }
-    return cleaned ?? raw;
+    return raw;
 }, z
     .object({
     defaults: IndexDefaultsSchema.optional(),

package/dist/core/env-secret-ref.js

@@ -70,50 +70,11 @@ export function listEnvsRecursive(listKeysFn, config = loadConfig()) {
     }
     return result;
 }
-/**
- * The `vault` asset type was removed in 0.9.0. The env/secret input path no
- * longer routes through the legacy stored-ref parser (which carries the removal
- * signpost), so a `vault:`/`vault/` leading token would otherwise be silently
- * qualified into an `env/vault:…` not-found. Detect it here and re-emit the
- * migration signpost so 0.8→0.9 muscle memory still gets pointed at env/secret.
- */
-function assertNotRemovedVaultRef(ref) {
-    const boundary = ref.indexOf("//");
-    const bare = boundary >= 0 ? ref.slice(boundary + 2) : ref;
-    if (/^vault[:/]/.test(bare.trim())) {
-        throw new UsageError("The `vault` asset type was removed in 0.9.0 — use `env/` (whole .env config) or `secrets/` (a single value).", "INVALID_FLAG_VALUE");
-    }
-}
-/**
- * Q-08 ruling: the pre-0.9.0 `type:name` ref grammar taught `env:<name>` /
- * `secret:<name>` (help text and docs also implied `environment:`/`secrets:`
- * variants) as the way to address a single env/secret. That grammar is GONE —
- * NO alias, no re-acceptance (same rule as the retired `vault:` prefix above).
- * Left unchecked, a colon-prefixed ref does not error here at all: it falls
- * through to the "bare name" convenience below and gets silently qualified
- * into a literal `env/env:name` (or `secrets/secret:name`) file that can never
- * exist — a confusing not-found that hides the real mistake instead of naming
- * it. Reject it here, loudly, before that happens.
- */
-function assertNotColonRef(ref, aliases, replacement) {
-    const boundary = ref.indexOf("//");
-    const bare = (boundary >= 0 ? ref.slice(boundary + 2) : ref).trim();
-    const colon = bare.indexOf(":");
-    if (colon <= 0)
-        return;
-    const head = bare.slice(0, colon).toLowerCase();
-    if (!aliases.includes(head))
-        return;
-    const name = bare.slice(colon + 1);
-    throw new UsageError(`The \`${head}:\` ref spelling was removed in 0.9.0 — use the slash form instead: \`${replacement}${name}\`.`, "INVALID_FLAG_VALUE");
-}
 export function parseEnvRef(ref) {
     // Accept a bare env name (`prod`, `sub/prod`) or the new-grammar
     // `[bundle//]env/name` conceptId. A bare name's leading segment maps to no
     // asset type, so it is qualified with the `env/` conceptId prefix; anything
     // already a full new-grammar ref is parsed as-is.
-    assertNotRemovedVaultRef(ref);
-    assertNotColonRef(ref, ["env", "environment"], "env/");
     return parseRefInput(isFullRefInput(ref) ? ref : `env/${ref}`);
 }
 export function findEnvSource(origin, type, name) {
@@ -152,10 +113,8 @@ export function makeEnvRef(name, source, config = loadConfig()) {
 }
 /**
  * Resolve an env ref to an absolute `.env` path. Accepts the `env/<name>`
- * conceptId (or a bare name, auto-qualified into it) — the retired
- * `env:`/`environment:` colon spelling is rejected loudly (Q-08), never
- * silently resolved. The path is returned even when the file does not yet
- * exist (so `create` writes under `env/`).
+ * conceptId (or a bare name, auto-qualified into it). The path is returned
+ * even when the file does not yet exist (so `create` writes under `env/`).
  */
 export function resolveEnvPath(ref) {
     const parsed = parseEnvRef(ref);
@@ -177,8 +136,6 @@ export function resolveEnvPath(ref) {
 export function parseSecretRef(ref) {
     // Same bare-name-vs-full-ref rule as parseEnvRef; a bare name is qualified
     // with the `secrets/` conceptId prefix (secret's stash subdir).
-    assertNotRemovedVaultRef(ref);
-    assertNotColonRef(ref, ["secret", "secrets"], "secrets/");
     return parseRefInput(isFullRefInput(ref) ? ref : `secrets/${ref}`);
 }
 export function makeSecretRef(name, source) {

package/dist/core/errors.js

@@ -38,8 +38,7 @@ const USAGE_HINTS = {
     INVALID_FLAG_VALUE: "Run `akm <command> --help` to see accepted values.",
     INVALID_SOURCE_VALUE: "Pick one of: local, registry, all, or a configured source name.",
     INVALID_FORMAT_VALUE: "Pick one of: json, jsonl, yaml, text, md, html.",
-    INVALID_DETAIL_VALUE: "Pick one of: brief, normal, full. For agent/summary projections use --shape.",
-    INVALID_SHAPE_VALUE: "Pick one of: human, agent, summary (summary falls back to agent, with a warning, on commands with no summary projection).",
+    INVALID_DETAIL_VALUE: "Pick one of: brief, normal, full, agent.",
     INVALID_JSON_CONFIG_VALUE: 'Quote JSON values in your shell, for example: akm config set embedding \'{"endpoint":"http://localhost:11434/v1/embeddings","model":"nomic-embed-text"}\'.',
     MISSING_OR_AMBIGUOUS_TARGET: "Use `akm bundle update --all` or pass a target like `akm bundle update npm:@scope/pkg` (not both).",
     TARGET_NOT_UPDATABLE: "Run `akm bundle list` to view your sources, then retry with one of those values.",

package/dist/core/extra-params.js

@@ -1,7 +1,6 @@
 // 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 { isRecord } from "./common.js";
 export const EXTRA_PARAMS_PROTECTED_TOP_LEVEL_KEYS = [
     "model",
     "messages",
@@ -31,8 +30,7 @@ const CREDENTIAL_KEYS = new Set(EXTRA_PARAMS_CREDENTIAL_KEYS);
 // `EXTRA_PARAMS_PROTECTED_TOP_LEVEL_KEYS` rightly stops a provider extra from
 // shadowing an AKM-managed field, but naming the rule without naming the fix
 // leaves the reader stuck (#852). Every protected key gets a one-line remedy
-// baked into its issue message; keys with a genuine scalar first-class field
-// are also eligible for the automatic config-load lift below.
+// baked into its issue message.
 /** normalizeExtraParamKey(key) -> the first-class engine field it shadows. */
 const LEGACY_EXTRA_PARAMS_FIELD = {
     model: "model",
@@ -41,16 +39,7 @@ const LEGACY_EXTRA_PARAMS_FIELD = {
     enablethinking: "enableThinking",
     reasoningeffort: "reasoningEffort",
 };
-/**
- * Subset of {@link LEGACY_EXTRA_PARAMS_FIELD} that {@link liftLegacyEngineExtraParams}
- * will move onto the first-class field automatically. `model` is deliberately
- * excluded: unlike the others it was never a "no first-class field yet"
- * workaround (`model` has always been required on an LLM engine), so a
- * mismatch is far more likely a genuine mistake than a stale 0.9.1 config —
- * it stays a hard rejection rather than being silently reinterpreted.
- */
-const LIFTABLE_EXTRA_PARAMS_KEYS = new Set(["temperature", "maxtokens", "enablethinking", "reasoningeffort"]);
-/** Remedies for protected keys with no scalar first-class field to lift onto. */
+/** Remedies for protected keys with no scalar first-class field. */
 const EXTRA_PARAMS_NO_FIELD_REMEDY = {
     messages: "AKM builds the request messages internally — remove it from extraParams",
     responseformat: "AKM controls the response format internally — remove it from extraParams",
@@ -117,76 +106,3 @@ export function formatExtraParamsIssue(label, issue) {
     const suffix = issue.path.map((part) => (typeof part === "number" ? `[${part}]` : `.${part}`)).join("");
     return `${label}${suffix} ${issue.message}`;
 }
-/**
- * Compute the legacy `extraParams` -> first-class-field lift for a raw
- * parsed config object: a 0.9.1-shaped config using (e.g.)
- * `extraParams.reasoning_effort` now needs `reasoningEffort` set instead,
- * since that field became first-class — and therefore protected — in 0.9.2
- * (#852, following #815).
- *
- * Pure: never touches the filesystem. Two callers use this differently:
- * `akm migrate apply` (scripts/akm-migrate/migrate/config-extra-params.ts) uses the
- * returned `config` to persist the rewrite to disk, once; `parseAndValidateConfigText`
- * (src/core/config/config.ts) calls this only to detect whether a lift is
- * needed and discards `config` — an unmigrated config fails closed there
- * with a pointer to `akm migrate apply` rather than silently drifting from
- * what's on disk. `conflicts` (an extraParams key and its first-class field
- * set to different values) is a genuine authoring error in both callers and
- * is never auto-resolved.
- */
-export function liftLegacyEngineExtraParams(raw) {
-    const lifted = [];
-    const conflicts = [];
-    const rawEngines = raw.engines;
-    if (!isRecord(rawEngines)) {
-        return { config: raw, lifted, conflicts };
-    }
-    const engines = {};
-    let anyEngineChanged = false;
-    for (const [name, engineValue] of Object.entries(rawEngines)) {
-        if (!isRecord(engineValue) || !isRecord(engineValue.extraParams)) {
-            engines[name] = engineValue;
-            continue;
-        }
-        const engine = { ...engineValue };
-        const extraParams = { ...engineValue.extraParams };
-        let engineChanged = false;
-        for (const [rawKey, value] of Object.entries(engineValue.extraParams)) {
-            const normalized = normalizeExtraParamKey(rawKey);
-            if (!LIFTABLE_EXTRA_PARAMS_KEYS.has(normalized))
-                continue;
-            const field = LEGACY_EXTRA_PARAMS_FIELD[normalized];
-            if (!field)
-                continue;
-            const existing = engine[field];
-            if (existing !== undefined && existing !== value) {
-                conflicts.push({ engine: name, key: rawKey, field, extraParamsValue: value, fieldValue: existing });
-                continue;
-            }
-            delete extraParams[rawKey];
-            engineChanged = true;
-            if (existing === value) {
-                lifted.push(`engines.${name}.extraParams.${rawKey} is redundant — engines.${name}.${field} is already set to the same value; dropped the extraParams entry`);
-                continue;
-            }
-            engine[field] = value;
-            lifted.push(`engines.${name}.extraParams.${rawKey} -> engines.${name}.${field}`);
-        }
-        if (!engineChanged) {
-            engines[name] = engineValue;
-            continue;
-        }
-        anyEngineChanged = true;
-        if (Object.keys(extraParams).length > 0) {
-            engine.extraParams = extraParams;
-        }
-        else {
-            delete engine.extraParams;
-        }
-        engines[name] = engine;
-    }
-    if (!anyEngineChanged) {
-        return { config: raw, lifted, conflicts };
-    }
-    return { config: { ...raw, engines }, lifted, conflicts };
-}

package/dist/core/file-lock.js

@@ -8,8 +8,7 @@
  * makes atomic: exactly one creator wins, so no further mutex or barrier is
  * needed around acquisition. The payload records the holder's PID (and the
  * launcher PID under a scheduler) so a probe can tell a live holder from a
- * dead one; only a verifiably dead holder — or, when the caller opts in via
- * `staleAfterMs`, an over-age one — is ever reclaimed. Reclaim moves the
+ * dead one; only a verifiably dead holder is ever reclaimed. Reclaim moves the
  * stale file aside, re-verifies it is the very file that was probed, and only
  * then unlinks it, so two reclaimers cannot both "win" the same stale lock.
  */
@@ -51,14 +50,23 @@ function releaseLockRaw(lockPath) {
 }
 /** Create the lock file atomically; `undefined` when another holder already has it. */
 export function tryAcquireLockSync(lockPath, payload) {
+    // Write the payload under a private name, then hard-link it into place: the
+    // link is the exclusive step and the lock never exists without its payload.
+    // A `wx` write creates the file empty and fills it in afterwards; a contender
+    // probing in that gap reads no pid, calls the live lock stale and reclaims it.
+    const tmpPath = `${lockPath}.tmp-${process.pid}-${randomUUID()}`;
+    fs.writeFileSync(tmpPath, payload, { flag: "wx" });
     try {
-        fs.writeFileSync(lockPath, payload, { flag: "wx" });
+        fs.linkSync(tmpPath, lockPath);
     }
     catch (err) {
         if (err.code === "EEXIST")
             return undefined;
         throw err;
     }
+    finally {
+        releaseLockRaw(tmpPath);
+    }
     let snapshot;
     try {
         snapshot = readLockSnapshot(lockPath);
@@ -89,7 +97,7 @@ export function createLockPayload(metadata = {}) {
         lockId: randomUUID(),
     });
 }
-export function probeLock(lockPath, opts) {
+export function probeLock(lockPath) {
     let snapshot;
     try {
         snapshot = readLockSnapshot(lockPath);
@@ -111,9 +119,6 @@ export function probeLock(lockPath, opts) {
     if (!isProcessAlive(holderPid)) {
         return { state: "stale", reason: "pid_dead", holderPid, launcherPid, ageMs, rawContent, identity };
     }
-    if (opts?.staleAfterMs !== undefined && ageMs > opts.staleAfterMs) {
-        return { state: "stale", reason: "age_exceeded", holderPid, launcherPid, ageMs, rawContent, identity };
-    }
     return { state: "held", holderPid, launcherPid, ageMs, rawContent, identity };
 }
 /**

package/dist/core/improve-result.js

@@ -60,6 +60,7 @@ const COMMON_FIELDS = [
     "cycleMetrics",
     "runId",
     "sync",
+    "preRunSync",
     "writtenPaths",
     "terminated",
     "usageReport",
@@ -126,6 +127,8 @@ function validateConsolidationPlan(value) {
     ]));
     if (!isRecord(value.configured))
         fail("plan.consolidation.configured must be an object");
+    // `minPoolSize` is no longer written (the minimum-pool guard was removed in 0.10, #1131); runs an
+    // older release persisted still carry it, ignored — AGENTS.md "Reading persisted data".
     requireExactFields(value.configured, new Set(["enabled", "minPoolSize", "limit", "maxChunkSize"]));
     if (value.configured.enabled !== undefined && typeof value.configured.enabled !== "boolean") {
         fail("plan.consolidation.configured.enabled must be a boolean");
@@ -140,7 +143,8 @@ function validateConsolidationPlan(value) {
     requireExactFields(value.effective, new Set(["enabled", "minPoolSize", "limit", "chunkSize"]));
     if (typeof value.effective.enabled !== "boolean")
         fail("plan.consolidation.effective.enabled must be a boolean");
-    requireCount(value.effective, "minPoolSize", "plan.consolidation.effective");
+    if (value.effective.minPoolSize !== undefined)
+        requireCount(value.effective, "minPoolSize", "plan.consolidation.effective");
     requireCount(value.effective, "chunkSize", "plan.consolidation.effective");
     if (value.effective.limit !== undefined && typeof value.effective.limit !== "number") {
         fail("plan.consolidation.effective.limit must be a number");
@@ -157,6 +161,9 @@ function validateConsolidationPlan(value) {
     requireExactFields(value.gates, new Set(["profile", "minimumPool", "delta"]));
     for (const gateName of ["profile", "minimumPool", "delta"]) {
         const gate = value.gates[gateName];
+        // `minimumPool` is no longer written; only an older release's persisted plan has it.
+        if (gate === undefined && gateName === "minimumPool")
+            continue;
         if (!isRecord(gate))
             fail(`plan.consolidation.gates.${gateName} must be an object`);
         requireExactFields(gate, new Set(["passed", "reason"]));
@@ -171,6 +178,8 @@ function validateProactivePlan(value) {
     requireExactFields(value, new Set(["configured", "effective", "candidatePool", "dueTotal", "neverReflected", "selected", "selectedRefs"]));
     if (!isRecord(value.configured))
         fail("plan.proactive.configured must be an object");
+    // `limit` is no longer written (the `proactiveMaintenance.limit` alias of `maxPerRun` was removed in 0.10, #1091);
+    // runs an older release stored may carry it.
     requireExactFields(value.configured, new Set(["dueDays", "maxPerRun", "limit"]));
     for (const field of ["dueDays", "maxPerRun", "limit"]) {
         if (value.configured[field] !== undefined && typeof value.configured[field] !== "number") {
@@ -424,6 +433,8 @@ function validateImprovePlan(value, dryRun, plannedRefNames) {
     }
     if (!isRecord(value.triage))
         fail("plan.triage must be an object");
+    // `maxDiffLines` is no longer written (the triage config key was dropped before 0.10, #1091); runs an older
+    // release stored may carry it.
     requireExactFields(value.triage, new Set(["enabled", "configuredMode", "mode", "maxAcceptsPerRun", "maxDiffLines"]));
     if (typeof value.triage.enabled !== "boolean")
         fail("plan.triage.enabled must be a boolean");
@@ -520,6 +531,7 @@ function validateCommon(value) {
         "proactiveMaintenance",
         "cycleMetrics",
         "sync",
+        "preRunSync",
         "terminated",
         "plan",
         "deadUrlCoverage",

package/dist/core/mutation-target.js

@@ -51,12 +51,12 @@ function resolveExplicitMutationTarget(config, explicitTarget, options) {
     }
 }
 /**
- * Reconcile a qualified mutation ref with the explicit target (`--target`, or
+ * Reconcile a qualified mutation ref with the explicit target (`--bundle`, or
  * the `options.flag` the caller's command spells), then resolve the write
  * destination.
  */
 export function resolveMutationTarget(config, ref, explicitTarget, options = {}) {
-    const flag = options.flag ?? "--target";
+    const flag = options.flag ?? "--bundle";
     const writeOptions = { requireWritable: options.requireWritable, flag };
     const qualifiedTarget = ref.origin ? resolveBundleWriteTarget(config, ref.origin, writeOptions) : undefined;
     const explicitResolved = explicitTarget

package/dist/core/paths.js

@@ -352,6 +352,10 @@ export function getStashLocksDir(stashDir) {
 export function getTaskLogDir() {
     return path.join(getCacheDir(), "tasks", "logs");
 }
+/** Per-run `akm improve` / `akm index` log files: flat `<ISO>.log` files under `$CACHE/logs/<kind>`. */
+export function getRunLogDir(kind) {
+    return path.join(getCacheDir(), "logs", kind);
+}
 export function getTaskHistoryDir() {
     return path.join(getCacheDir(), "tasks", "history");
 }

package/dist/core/recognition-util.js

@@ -34,13 +34,12 @@ export const SCRIPT_EXTENSIONS = new Set([
     ".kts",
 ]);
 /**
- * Recognized workflow asset extensions. Markdown remains first-class and the
- * strict local GitHub-shaped source adapter adds `.yml` as a peer format.
- * `workflows/<name>` refs resolve against this list.
+ * Recognized workflow asset extensions. `workflows/<name>` refs resolve against
+ * this list.
  */
-export const WORKFLOW_EXTENSIONS = [".md", ".yml"];
+export const WORKFLOW_EXTENSIONS = [".md"];
 /**
- * Strip a recognized workflow extension (`.md` or `.yml`) from a workflow asset
+ * Strip the recognized workflow extension (`.md`) from a workflow asset
  * *name* so `foo` and `foo.md` collapse to one canonical identity — the same
  * collapse `workflowSpec.toCanonicalName` performs on a resolved file path.
  * Callers that turn a `workflows/<name>` ref into run identity (the

package/dist/core/run-lock.js

@@ -6,7 +6,7 @@
  * whole-run lock (`commands/improve/locks.ts`) and the index rebuild lock
  * (`indexer/index-rebuild-lock.ts`, #956).
  *
- * No `staleAfterMs`: only a verifiably dead holder is ever reclaimed. This is
+ * Only a verifiably dead holder is ever reclaimed, never an old one. This is
  * the #872 lesson encoded at the mechanics layer so every future caller gets
  * it for free — an age-based stale window let a live-but-wedged holder's
  * lease survive forever from the holder's own point of view while stranding