akm-cli 0.9.0-rc.3 → 0.9.0-rc.4

package/dist/commands/tasks/tasks.js

@@ -19,13 +19,15 @@ import { getTaskHistoryDir, getTaskLogDir } from "../../core/paths.js";
 import { commitWriteTargetBoundary, deleteAssetFromSource, resolveWriteTarget, writeAssetToSource, } from "../../core/write-source.js";
 import { resolveAssetPath } from "../../sources/resolve.js";
 import { backendNameForPlatform, selectBackend } from "../../tasks/backends/index.js";
+import { findBareAkmExecutableIndex } from "../../tasks/command-executable.js";
 import { parseTaskDocument } from "../../tasks/parser.js";
 import { resolveAkmInvocation } from "../../tasks/resolve-akm-bin.js";
-import { exitCodeForStatus, readTaskHistory, runTask } from "../../tasks/runner.js";
+import { exitCodeForStatus, INVALID_TASK_ATTEMPT_ID, readTaskHistory, recordTaskAttemptFailure, runTask, } from "../../tasks/runner.js";
 import { parseSchedule, SCHEDULE_SUPPORTED_SUBSET_HINT, translateToCron } from "../../tasks/schedule.js";
+import { normaliseTaskId } from "../../tasks/task-id.js";
 import { validateTaskDocument } from "../../tasks/validator.js";
 import { resolveImproveStrategy } from "../improve/improve-strategies.js";
-export async function akmTasksAdd(input) {
+export async function akmTasksAdd(input, deps = {}) {
     const id = normaliseTaskId(input.id);
     const hasCommand = input.command !== undefined &&
         input.command !== null &&
@@ -47,7 +49,6 @@ export async function akmTasksAdd(input) {
     const target = resolveTaskWriteTarget();
     const stashDir = target.source.path;
     const typeRoot = path.join(stashDir, "tasks");
-    fs.mkdirSync(typeRoot, { recursive: true });
     const assetPath = resolveAssetPathFromName("task", typeRoot, id);
     if (!isWithin(assetPath, typeRoot)) {
         throw new UsageError(`Resolved task path escapes the stash: "${id}".`, "PATH_ESCAPE_VIOLATION");
@@ -73,25 +74,103 @@ export async function akmTasksAdd(input) {
     });
     const task = parseTaskDocument({ yaml, filePath: assetPath, id });
     await validateTaskDocument(task, { backend, stashDir });
+    const obsoleteReason = obsoleteBackupTaskReason(task);
+    if (obsoleteReason)
+        throw new UsageError(obsoleteReason, "INVALID_FLAG_VALUE");
     const ref = taskAssetRef(id);
-    await writeAssetToSource(target.source, target.config, ref, yaml);
-    // Install in the OS scheduler. If install fails after the file was written,
-    // delete the file so the on-disk state never claims a task is registered
-    // when it isn't.
+    const previousYaml = fs.existsSync(assetPath) ? fs.readFileSync(assetPath, "utf8") : undefined;
+    let previousTask;
+    let previousTaskError;
+    if (previousYaml !== undefined) {
+        try {
+            previousTask = parseTaskDocument({ yaml: previousYaml, filePath: assetPath, id });
+        }
+        catch (err) {
+            previousTaskError = err;
+        }
+    }
+    const sched = deps.backend ?? selectBackend();
+    const writeAsset = deps.writeAsset ?? writeAssetToSource;
+    const deleteAsset = deps.deleteAsset ?? deleteAssetFromSource;
+    const commitBoundary = deps.commitBoundary ?? commitWriteTargetBoundary;
+    const wasInstalled = previousYaml !== undefined && (await sched.list()).some((entry) => entry.id === id);
+    let sourceRestoreArmed = false;
+    let installSucceeded = false;
     try {
-        const sched = selectBackend();
+        sourceRestoreArmed = true;
+        await writeAsset(target.source, target.config, ref, yaml);
         await sched.install(task);
+        installSucceeded = true;
+        commitBoundary(target, `Update task:${id}`);
     }
     catch (err) {
-        try {
-            await deleteAssetFromSource(target.source, target.config, ref);
+        const rollbackErrors = [];
+        let sourceRestored = false;
+        if (sourceRestoreArmed) {
+            try {
+                if (previousYaml === undefined) {
+                    if (fs.existsSync(assetPath)) {
+                        await deleteAsset(target.source, target.config, ref);
+                        sourceRestored = true;
+                    }
+                }
+                else {
+                    await restoreTaskSourceBytes(writeAsset, target.source, target.config, ref, assetPath, previousYaml);
+                    sourceRestored = true;
+                }
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
         }
-        catch {
-            /* ignore */
+        if (installSucceeded && !wasInstalled) {
+            try {
+                await sched.uninstall(id);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+        }
+        else if (installSucceeded && previousTask) {
+            try {
+                await sched.install(previousTask);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+                try {
+                    if (typeof sched.setEnabled !== "function") {
+                        throw new Error(`Scheduler backend "${sched.name}" cannot disable task "${id}".`);
+                    }
+                    await sched.setEnabled(id, false);
+                }
+                catch (disableError) {
+                    rollbackErrors.push(disableError);
+                    try {
+                        await sched.uninstall(id);
+                    }
+                    catch (uninstallError) {
+                        rollbackErrors.push(uninstallError);
+                    }
+                }
+            }
+        }
+        else if (installSucceeded && wasInstalled) {
+            rollbackErrors.push(previousTaskError ?? new Error(`Prior task "${id}" could not be restored.`));
+        }
+        if (sourceRestored) {
+            try {
+                commitBoundary(target, `Restore task:${id}`);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+        }
+        if (rollbackErrors.length > 0) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new AggregateError([err, ...rollbackErrors], `${message}; rollback for task "${id}" was incomplete.`);
         }
         throw err;
     }
-    commitWriteTargetBoundary(target, `Update task:${id}`);
     return {
         id,
         ref: `task:${id}`,
@@ -206,38 +285,68 @@ export async function akmTasksShow(id) {
         tags: task.tags,
     };
 }
-export async function akmTasksRemove(id) {
+export async function akmTasksRemove(id, deps = {}) {
     const normalised = normaliseTaskId(id);
     const target = resolveTaskWriteTarget();
     const stashDir = target.source.path;
     const typeRoot = path.join(stashDir, "tasks");
     if (fs.existsSync(typeRoot))
         warnLegacyMdTaskFiles(typeRoot);
-    await resolveAssetPath(stashDir, "task", normalised);
+    const filePath = await resolveAssetPath(stashDir, "task", normalised);
+    const yaml = fs.readFileSync(filePath, "utf8");
     const ref = taskAssetRef(normalised);
-    const sched = selectBackend();
-    let uninstallError;
-    let deleteError;
+    const sched = deps.backend ?? selectBackend();
+    const writeAsset = deps.writeAsset ?? writeAssetToSource;
+    const deleteAsset = deps.deleteAsset ?? deleteAssetFromSource;
+    const commitBoundary = deps.commitBoundary ?? commitWriteTargetBoundary;
+    const wasInstalled = (await sched.list()).some((entry) => entry.id === normalised);
+    const previousTask = wasInstalled ? parseTaskDocument({ yaml, filePath, id: normalised }) : undefined;
+    let uninstallAttempted = false;
+    let deleteAttempted = false;
     try {
+        uninstallAttempted = true;
         await sched.uninstall(normalised);
+        deleteAttempted = true;
+        await deleteAsset(target.source, target.config, ref);
+        commitBoundary(target, `Remove task:${normalised}`);
     }
     catch (err) {
-        uninstallError = err;
-    }
-    try {
-        await deleteAssetFromSource(target.source, target.config, ref);
-    }
-    catch (err) {
-        deleteError = err;
+        const rollbackErrors = [];
+        let sourceRestored = false;
+        if (deleteAttempted) {
+            try {
+                await restoreTaskSourceBytes(writeAsset, target.source, target.config, ref, filePath, yaml);
+                sourceRestored = true;
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+        }
+        if (uninstallAttempted && previousTask) {
+            try {
+                await sched.install(previousTask);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+        }
+        if (sourceRestored) {
+            try {
+                commitBoundary(target, `Restore task:${normalised}`);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+        }
+        if (rollbackErrors.length > 0) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new AggregateError([err, ...rollbackErrors], `${message}; rollback for task "${normalised}" was incomplete.`);
+        }
+        throw err;
     }
-    if (uninstallError !== undefined)
-        throw uninstallError;
-    if (deleteError !== undefined)
-        throw deleteError;
-    commitWriteTargetBoundary(target, `Remove task:${normalised}`);
     return { id: normalised, removed: true, backend: sched.name };
 }
-export async function akmTasksSetEnabled(id, enabled) {
+export async function akmTasksSetEnabled(id, enabled, deps = {}) {
     const normalised = normaliseTaskId(id);
     const target = resolveTaskWriteTarget();
     const stashDir = target.source.path;
@@ -246,42 +355,111 @@ export async function akmTasksSetEnabled(id, enabled) {
         warnLegacyMdTaskFiles(typeRoot);
     const filePath = await resolveAssetPath(stashDir, "task", normalised);
     const yaml = fs.readFileSync(filePath, "utf8");
-    // Parse before writing so stale v1 tasks are diagnosed without changing the
-    // source file or its installed scheduler entry.
-    parseTaskDocument({ yaml, filePath, id: normalised });
+    // Parse before writing so unsupported tasks are diagnosed without changing
+    // the source file or its installed scheduler entry.
+    const previousTask = parseTaskDocument({ yaml, filePath, id: normalised });
     const updated = setEnabledInYaml(yaml, enabled);
+    const task = parseTaskDocument({ yaml: updated, filePath, id: normalised });
+    const obsoleteReason = obsoleteBackupTaskReason(task);
+    if (obsoleteReason)
+        throw new UsageError(obsoleteReason, "INVALID_FLAG_VALUE");
     const ref = taskAssetRef(normalised);
-    await writeAssetToSource(target.source, target.config, ref, updated);
-    const sched = selectBackend();
+    const sched = deps.backend ?? selectBackend();
+    const writeAsset = deps.writeAsset ?? writeAssetToSource;
+    const commitBoundary = deps.commitBoundary ?? commitWriteTargetBoundary;
+    const wasInstalled = (await sched.list()).some((entry) => entry.id === normalised);
+    let sourceRestoreArmed = false;
+    let installSucceeded = false;
     try {
+        sourceRestoreArmed = true;
+        await writeAsset(target.source, target.config, ref, updated);
         // Reinstall from the (just-updated) definition rather than only toggling
         // the comment. A plain toggle leaves a stale schedule in place if the
         // .yml's `schedule:` changed while the task was disabled — re-enabling
         // would silently keep the old cron line. install() renders the block with
         // both the current schedule and the new enabled state, and is idempotent.
-        const task = parseTaskDocument({ yaml: updated, filePath, id: normalised });
         await sched.install(task);
+        installSucceeded = true;
+        commitBoundary(target, `Update task:${normalised}`);
     }
     catch (err) {
-        // Roll the file back so the YAML source-of-truth and the OS
-        // scheduler don't diverge silently when the backend call fails.
-        await writeAssetToSource(target.source, target.config, ref, yaml);
+        const rollbackErrors = [];
+        let sourceRestored = false;
+        if (sourceRestoreArmed) {
+            try {
+                await restoreTaskSourceBytes(writeAsset, target.source, target.config, ref, filePath, yaml);
+                sourceRestored = true;
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+        }
+        if (installSucceeded) {
+            try {
+                if (wasInstalled)
+                    await sched.install(previousTask);
+                else
+                    await sched.uninstall(normalised);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+        }
+        if (sourceRestored) {
+            try {
+                commitBoundary(target, `Restore task:${normalised}`);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+        }
+        if (rollbackErrors.length > 0) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new AggregateError([err, ...rollbackErrors], `${message}; rollback for task "${normalised}" was incomplete.`);
+        }
         throw err;
     }
-    commitWriteTargetBoundary(target, `Update task:${normalised}`);
     return { id: normalised, enabled, backend: sched.name };
 }
-export async function akmTasksRun(id) {
-    const normalised = normaliseTaskId(id);
-    const stashDir = resolveStashDir();
+export async function akmTasksRun(id, options = {}) {
+    const startedAt = new Date();
+    let normalised;
+    try {
+        normalised = parseTaskRef(id).id;
+    }
+    catch (failure) {
+        recordTaskAttemptFailure({
+            taskId: INVALID_TASK_ATTEMPT_ID,
+            reason: "invalid_task_id",
+            failure,
+            startedAt,
+        });
+        throw failure;
+    }
+    let stashDir;
+    try {
+        stashDir = resolveStashDir();
+    }
+    catch (failure) {
+        recordTaskAttemptFailure({
+            taskId: normalised,
+            reason: "task_load_failed",
+            failure,
+            startedAt,
+        });
+        throw failure;
+    }
     const typeRoot = path.join(stashDir, "tasks");
     if (fs.existsSync(typeRoot))
         warnLegacyMdTaskFiles(typeRoot);
-    const result = await runTask(normalised);
+    const result = await runTask(normalised, { stashDir, scheduled: options.scheduled === true });
+    const exitCode = result.status === "failed" && result.target.kind === "command" && result.detail?.exitCode === 78
+        ? 78
+        : exitCodeForStatus(result.status);
     return {
         ok: result.status === "completed" || result.status === "disabled",
         result,
-        exitCode: exitCodeForStatus(result.status),
+        exitCode,
     };
 }
 export async function akmTasksHistory(input) {
@@ -314,7 +492,7 @@ export async function akmTasksSync(deps = {}) {
             .map((f) => f.slice(0, -4))
         : [];
     const sched = deps.backend ?? selectBackend();
-    const backend = backendNameForPlatform();
+    const backend = sched.name;
     // Map id → installed signature so sync can detect schedule/enabled drift on
     // tasks that already exist in the scheduler, not just presence/absence.
     const present = new Map((await sched.list()).map((t) => [t.id, t.signature]));
@@ -327,16 +505,26 @@ export async function akmTasksSync(deps = {}) {
         let task;
         try {
             task = parseTaskDocument({ yaml: fs.readFileSync(filePath, "utf8"), filePath, id });
-        }
-        catch (err) {
-            skipped.push({ id, reason: err instanceof Error ? err.message : String(err) });
-            continue;
-        }
-        try {
             await validateTaskDocument(task, { backend, stashDir });
+            const obsoleteReason = obsoleteBackupTaskReason(task);
+            if (obsoleteReason)
+                throw new UsageError(obsoleteReason, "INVALID_FLAG_VALUE");
         }
         catch (err) {
             skipped.push({ id, reason: err instanceof Error ? err.message : String(err) });
+            if (present.has(id)) {
+                try {
+                    await sched.setEnabled(id, false);
+                }
+                catch (disableError) {
+                    try {
+                        await sched.uninstall(id);
+                    }
+                    catch (uninstallError) {
+                        throw new AggregateError([err, disableError, uninstallError], `Task "${id}" is invalid and its installed scheduler entry could not be disabled or removed.`);
+                    }
+                }
+            }
             continue;
         }
         if (!present.has(id)) {
@@ -368,6 +556,19 @@ export async function akmTasksSync(deps = {}) {
     }
     return { installed, updated, removed, unchanged, skipped, backend: sched.name };
 }
+function obsoleteBackupTaskReason(task) {
+    if (!task.enabled || task.target.kind !== "command")
+        return undefined;
+    const executableIndex = findBareAkmExecutableIndex(task.target.cmd);
+    if (executableIndex === undefined)
+        return undefined;
+    const args = task.target.cmd.slice(executableIndex + 1);
+    if (args.length !== 2 || args[0] !== "db" || args[1] !== "backups")
+        return undefined;
+    return (`Task "${task.id}" invokes obsolete \`akm db backups\`, which only listed legacy backups and is not a 0.9 backup command. ` +
+        "AKM will not install or enable it; sync will keep any existing scheduler entry disabled, and the task file is unchanged. " +
+        "Use `akm backup create --for 0.9.0` for an explicit migration recovery snapshot.");
+}
 export async function akmTasksDoctor() {
     const warnings = [];
     let invocation = { argv: [], via: "unresolved" };
@@ -417,22 +618,14 @@ export async function akmTasksDoctor() {
     };
 }
 // ── helpers ─────────────────────────────────────────────────────────────────
-const VALID_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-function normaliseTaskId(raw) {
-    // Accept both .yml and .md suffixes from users so muscle memory from the
-    // pre-0.8.0 markdown task format doesn't produce a confusing "task not found".
-    const id = raw.trim().replace(/\.(yml|md)$/, "");
-    if (!id) {
-        throw new UsageError("Task id must be non-empty.", "MISSING_REQUIRED_ARGUMENT");
-    }
-    if (!VALID_ID_RE.test(id)) {
-        throw new UsageError(`Task id "${id}" is invalid. Use letters, digits, dots, underscores, and dashes only.`, "INVALID_FLAG_VALUE");
-    }
-    return id;
-}
 function taskAssetRef(id) {
     return { type: "task", name: id };
 }
+async function restoreTaskSourceBytes(writeAsset, source, config, ref, filePath, yaml) {
+    await writeAsset(source, config, ref, yaml);
+    // The normal write path adds a trailing newline; rollback restores the raw snapshot exactly.
+    fs.writeFileSync(filePath, yaml, "utf8");
+}
 function resolveTaskWriteTarget() {
     return resolveWriteTarget(loadConfig());
 }
@@ -475,8 +668,8 @@ function isStaleTaskError(err) {
     return err instanceof UsageError && err.code === "TASK_SCHEMA_VERSION_UNSUPPORTED";
 }
 function warnStaleTaskFiles(ids) {
-    process.stderr.write(`WARNING: ${ids.length} task file(s) use retired task schema v1 and were not loaded.\n` +
-        `         Rewrite them with version: 2 and replace profile with engine. See docs/migration/v0.8-to-v0.9.md#task-assets.\n` +
+    process.stderr.write(`WARNING: ${ids.length} task file(s) use an unsupported task schema version and were not loaded.\n` +
+        `         Use version: 2. See docs/migration/v0.8-to-v0.9.md#engine-and-task-assets.\n` +
         `         Affected: ${ids.map((id) => `tasks/${id}.yml`).join(", ")}\n`);
 }
 function collectStaleTaskIds() {

package/dist/core/improve-result.js

@@ -44,8 +44,26 @@ const COMMON_FIELDS = [
     "sync",
     "terminated",
 ];
-const V1_FIELDS = new Set([...COMMON_FIELDS, "profile", "profileFilteredRefs"]);
+const V1_FIELDS = new Set([...COMMON_FIELDS, "profile", "profileFilteredRefs", "stalenessDetection"]);
 const V2_FIELDS = new Set([...COMMON_FIELDS, "strategy", "strategyFilteredRefs"]);
+const STALENESS_DETECTION_FIELDS = new Set([
+    "considered",
+    "deprecated",
+    "confirmed",
+    "skipped",
+    "durationMs",
+    "warnings",
+]);
+const INTERRUPTED_V1_FIELDS = new Set([
+    "schemaVersion",
+    "ok",
+    "profile",
+    "scope",
+    "dryRun",
+    "plannedRefs",
+    "actions",
+    "terminated",
+]);
 function fail(message) {
     throw new Error(`invalid improve-result envelope: ${message}`);
 }
@@ -57,6 +75,33 @@ function requireExactFields(value, allowed) {
     if (unknown.length > 0)
         fail(`unknown field${unknown.length === 1 ? "" : "s"}: ${unknown.sort().join(", ")}`);
 }
+function isKnownInterruptedV1Partial(value) {
+    if (Object.keys(value).some((key) => !INTERRUPTED_V1_FIELDS.has(key)))
+        return false;
+    if (value.ok !== false || typeof value.dryRun !== "boolean")
+        return false;
+    if (value.profile !== undefined && typeof value.profile !== "string")
+        return false;
+    if (!Array.isArray(value.plannedRefs) || value.plannedRefs.length !== 0)
+        return false;
+    if (!Array.isArray(value.actions) || value.actions.length !== 0)
+        return false;
+    if (!isRecord(value.scope))
+        return false;
+    if (Object.keys(value.scope).some((key) => key !== "mode" && key !== "value"))
+        return false;
+    if (value.scope.mode !== "all" && value.scope.mode !== "type" && value.scope.mode !== "ref")
+        return false;
+    if (value.scope.value !== undefined && typeof value.scope.value !== "string")
+        return false;
+    if (!isRecord(value.terminated))
+        return false;
+    if (Object.keys(value.terminated).some((key) => !["reason", "at", "errorMessage"].includes(key)))
+        return false;
+    if (typeof value.terminated.reason !== "string" || typeof value.terminated.at !== "string")
+        return false;
+    return value.terminated.errorMessage === undefined || typeof value.terminated.errorMessage === "string";
+}
 function validateCommon(value) {
     if (typeof value.ok !== "boolean")
         fail("ok must be a boolean");
@@ -131,6 +176,32 @@ function validateCommon(value) {
         if (value[field] !== undefined && !isRecord(value[field]))
             fail(`${field} must be an object`);
     }
+    if (isRecord(value.terminated)) {
+        requireExactFields(value.terminated, new Set(["reason", "at", "errorMessage"]));
+        if (typeof value.terminated.reason !== "string" || typeof value.terminated.at !== "string") {
+            fail("terminated.reason and terminated.at must be strings");
+        }
+        if (value.terminated.errorMessage !== undefined && typeof value.terminated.errorMessage !== "string") {
+            fail("terminated.errorMessage must be a string when present");
+        }
+    }
+}
+function validateV1StalenessDetection(value) {
+    if (value === undefined)
+        return;
+    if (!isRecord(value))
+        fail("stalenessDetection must be an object");
+    const unknown = Object.keys(value).filter((key) => !STALENESS_DETECTION_FIELDS.has(key));
+    if (unknown.length > 0) {
+        fail(`stalenessDetection has unknown field${unknown.length === 1 ? "" : "s"}: ${unknown.sort().join(", ")}`);
+    }
+    for (const field of ["considered", "deprecated", "confirmed", "skipped", "durationMs"]) {
+        if (typeof value[field] !== "number")
+            fail(`stalenessDetection.${field} must be a number`);
+    }
+    if (!Array.isArray(value.warnings) || value.warnings.some((warning) => typeof warning !== "string")) {
+        fail("stalenessDetection.warnings must be an array of strings");
+    }
 }
 /** Decode the persisted public v1/v2 contract without guessing across versions. */
 export function decodeImproveResult(input) {
@@ -146,17 +217,25 @@ export function decodeImproveResult(input) {
     if (!isRecord(parsed))
         fail("root must be an object");
     if (parsed.schemaVersion === 1) {
-        requireExactFields(parsed, V1_FIELDS);
-        validateCommon(parsed);
-        if (parsed.profile !== undefined && typeof parsed.profile !== "string")
+        let normalized = parsed;
+        let normalizedLegacyPartial = false;
+        if (normalized.memorySummary === undefined && isKnownInterruptedV1Partial(normalized)) {
+            normalized = { ...normalized, memorySummary: { eligible: 0, derived: 0 } };
+            normalizedLegacyPartial = true;
+        }
+        requireExactFields(normalized, V1_FIELDS);
+        validateCommon(normalized);
+        validateV1StalenessDetection(normalized.stalenessDetection);
+        if (normalized.profile !== undefined && typeof normalized.profile !== "string")
             fail("profile must be a string");
-        if (parsed.profileFilteredRefs !== undefined && !Array.isArray(parsed.profileFilteredRefs)) {
+        if (normalized.profileFilteredRefs !== undefined && !Array.isArray(normalized.profileFilteredRefs)) {
             fail("profileFilteredRefs must be an array");
         }
         return {
-            envelope: parsed,
+            envelope: normalized,
             strategy: null,
-            legacyProfile: typeof parsed.profile === "string" ? parsed.profile : null,
+            legacyProfile: typeof normalized.profile === "string" ? normalized.profile : null,
+            normalizedLegacyPartial,
         };
     }
     if (parsed.schemaVersion === 2) {
@@ -172,6 +251,7 @@ export function decodeImproveResult(input) {
             envelope: parsed,
             strategy: parsed.strategy,
             legacyProfile: null,
+            normalizedLegacyPartial: false,
         };
     }
     fail(`unsupported schemaVersion: ${String(parsed.schemaVersion)}`);

package/dist/core/state-db.js

@@ -115,6 +115,7 @@ export function openStateDatabase(dbPath) {
         if (existed) {
             const preflight = openDatabase(resolvedPath, { readonly: true });
             try {
+                preflight.exec("PRAGMA busy_timeout = 30000");
                 if (isCanonical)
                     assertCurrentMigrationLedger(preflight, STATE_MIGRATIONS);
                 else

package/dist/scripts/migrate-storage.js

@@ -17737,6 +17737,7 @@ function openStateDatabase(dbPath) {
     if (existed) {
       const preflight = openDatabase(resolvedPath, { readonly: true });
       try {
+        preflight.exec("PRAGMA busy_timeout = 30000");
         if (isCanonical)
           assertCurrentMigrationLedger(preflight, STATE_MIGRATIONS);
         else
@@ -17993,10 +17994,12 @@ var init_events_repository = __esm(() => {
 var exports_task_history_repository = {};
 __export(exports_task_history_repository, {
   upsertTaskHistory: () => upsertTaskHistory,
+  reserveTaskHistoryAttempt: () => reserveTaskHistoryAttempt,
   queryTaskHistory: () => queryTaskHistory,
   queryCompletedTaskIntervals: () => queryCompletedTaskIntervals,
   getTaskHistoryRuns: () => getTaskHistoryRuns,
   getTaskHistory: () => getTaskHistory,
+  finalizeTaskHistoryAttempt: () => finalizeTaskHistoryAttempt,
   decodeTaskHistoryMetadata: () => decodeTaskHistoryMetadata
 });
 function metadataError(message) {
@@ -18075,6 +18078,21 @@ function decodeTaskHistoryMetadata(input) {
   }
   metadataError(`unsupported metadataVersion: ${String(version)}`);
 }
+function reserveTaskHistoryAttempt(db, row) {
+  const result = db.prepare(`INSERT OR IGNORE INTO task_history
+         (task_id, status, started_at, completed_at, failed_at, log_path,
+          target_kind, target_ref, metadata_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.task_id, row.status, row.started_at, row.completed_at ?? null, row.failed_at ?? null, row.log_path ?? null, row.target_kind ?? null, row.target_ref ?? null, row.metadata_json);
+  return Number(result.changes) === 1;
+}
+function finalizeTaskHistoryAttempt(db, row) {
+  const result = db.prepare(`UPDATE task_history
+       SET status = ?, completed_at = ?, failed_at = ?, log_path = ?,
+           target_kind = ?, target_ref = ?, metadata_json = ?
+       WHERE task_id = ? AND started_at = ?
+         AND status = 'active' AND completed_at IS NULL`).run(row.status, row.completed_at ?? null, row.failed_at ?? null, row.log_path ?? null, row.target_kind ?? null, row.target_ref ?? null, row.metadata_json, row.task_id, row.started_at);
+  return Number(result.changes) === 1;
+}
 function upsertTaskHistory(db, row) {
   db.prepare(`
     INSERT OR IGNORE INTO task_history
@@ -18086,12 +18104,12 @@ function upsertTaskHistory(db, row) {
 function getTaskHistory(db, taskId) {
   return db.prepare(`SELECT id, task_id, status, started_at, completed_at, failed_at, log_path,
               target_kind, target_ref, metadata_json
-       FROM task_history WHERE task_id = ? ORDER BY started_at DESC LIMIT 1`).get(taskId);
+       FROM task_history WHERE task_id = ? ORDER BY started_at DESC, id DESC LIMIT 1`).get(taskId);
 }
 function getTaskHistoryRuns(db, taskId, limit = 50) {
   return db.prepare(`SELECT id, task_id, status, started_at, completed_at, failed_at, log_path,
               target_kind, target_ref, metadata_json
-       FROM task_history WHERE task_id = ? ORDER BY started_at DESC LIMIT ?`).all(taskId, limit);
+       FROM task_history WHERE task_id = ? ORDER BY started_at DESC, id DESC LIMIT ?`).all(taskId, limit);
 }
 function queryTaskHistory(db, options = {}) {
   const conditions = [];
@@ -18119,7 +18137,7 @@ function queryTaskHistory(db, options = {}) {
   const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   return db.prepare(`SELECT task_id, status, started_at, completed_at, failed_at, log_path,
               target_kind, target_ref, metadata_json
-       FROM task_history ${where} ORDER BY started_at DESC`).all(...params);
+       FROM task_history ${where} ORDER BY started_at DESC, id DESC`).all(...params);
 }
 function queryCompletedTaskIntervals(db, since, until) {
   const sql = until ? "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND started_at < ? AND completed_at IS NOT NULL ORDER BY started_at" : "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND completed_at IS NOT NULL ORDER BY started_at";