akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

package/dist/setup/steps/platforms.js

@@ -8,23 +8,24 @@
 import * as p from "../../cli/clack.js";
 import { detectAgentCliProfiles, pickDefaultAgentProfile } from "../../integrations/agent/index.js";
 import { detectAgentPlatforms } from "../detect.js";
-import { getCurrentAgentBlock } from "../legacy-config.js";
+import { readAgentEngineSelection } from "../engine-config.js";
 import { prompt } from "../prompt.js";
+// The just-computed source list is threaded through the private setup draft.
 export async function stepAgentPlatforms(current) {
     const platforms = detectAgentPlatforms();
     if (platforms.length === 0) {
         p.log.info("No agent platform configurations detected.");
         return [];
     }
-    const existingPaths = new Set((current.sources ?? []).map((s) => s.path));
+    const existingPaths = new Set((current.additionalSources ?? []).map((s) => s.path));
     // Filter out platforms already configured
     const newPlatforms = platforms.filter((pl) => !existingPaths.has(pl.path));
     if (newPlatforms.length === 0) {
-        p.log.info(`Detected ${platforms.length} agent platform(s), all already configured as stash sources.`);
+        p.log.info(`Detected ${platforms.length} agent platform(s), all already configured as bundle sources.`);
         return [];
     }
     const selected = await prompt(() => p.multiselect({
-        message: "Found agent platform configurations. Add as stash sources?",
+        message: "Found agent platform configurations. Add as bundle sources?",
         options: newPlatforms.map((pl) => ({
             value: pl.path,
             label: pl.name,
@@ -50,23 +51,23 @@ export async function stepAgentPlatforms(current) {
  */
 export function printCapabilitySummary(smallModelSkipped, agentConfigured) {
     const lines = ["Setup complete. Here's what's enabled:", ""];
-    lines.push("  ✓ akm search, akm curate, akm show — always available");
+    lines.push("  ✓ akm search, akm curate, akm show, akm index, akm remember — always available");
     if (!smallModelSkipped) {
-        lines.push("  ✓ akm index, akm distill, akm remember — small model configured");
+        lines.push("  ✓ index metadata enhancement, akm improve, akm remember --enrich — small model configured");
     }
     else {
-        lines.push("  ✗ akm index, akm distill, akm remember — run `akm setup` to enable");
+        lines.push("  ✗ index metadata enhancement, akm improve, akm remember --enrich — run `akm setup` to enable");
     }
     if (agentConfigured) {
-        lines.push("  ✓ akm propose, akm improve, akm tasks — agent configured");
+        lines.push("  ✓ akm proposal new, akm improve, akm task — agent configured");
     }
     else {
-        lines.push("  ✗ akm propose, akm improve, akm tasks — run `akm setup` to enable");
+        lines.push("  ✗ akm proposal new, akm improve, akm task — run `akm setup` to enable");
     }
     p.note(lines.join("\n"), "Feature Summary");
 }
 export async function stepAgentSelection(current, detections) {
-    const currentAgentBlock = getCurrentAgentBlock(current);
+    const currentAgentBlock = readAgentEngineSelection(current);
     const available = detections.filter((d) => d.available);
     if (available.length === 0) {
         return currentAgentBlock;
@@ -85,7 +86,7 @@ export async function stepAgentSelection(current, detections) {
         initialValue,
     }));
     if (selectedDefault === "disabled") {
-        if (!currentAgentBlock?.profiles && !currentAgentBlock?.timeoutMs) {
+        if (!currentAgentBlock?.engines) {
             return undefined;
         }
         return {
@@ -110,7 +111,7 @@ export async function stepAgentSelection(current, detections) {
  */
 export function stepAgentCliDetection(current, detectFn = detectAgentCliProfiles) {
     const detections = detectFn(current);
-    const currentAgentBlock = getCurrentAgentBlock(current);
+    const currentAgentBlock = readAgentEngineSelection(current);
     const defaultName = pickDefaultAgentProfile(detections, currentAgentBlock?.default);
     // No installed agents found and no existing config → leave block absent.
     if (!defaultName && !currentAgentBlock) {

package/dist/setup/steps/semantic.js

@@ -8,15 +8,27 @@
 import * as p from "../../cli/clack.js";
 import { prompt } from "../prompt.js";
 import { describeSemanticSearchAssets, isRemoteEmbeddingConfig } from "../semantic-assets.js";
-export async function stepSemanticSearch(current, embedding) {
+export async function stepSemanticSearch(
+// Owner ruling 9 (R-039): the runtime default is "off" (a bare/headless
+// install must never silently pull the ~130 MB model), but the interactive
+// wizard pre-selects semantic search ON — a human is present to read the
+// warning below and decide. `_current` is intentionally unused for the
+// enable/disable pre-selection below: it must NOT track
+// `semanticSearchMode`, or this pre-selection would silently flip to off
+// along with the runtime default. Kept in the signature for call-site
+// stability (callers pass the in-progress setup config positionally).
+_current, embedding) {
+    // Show the warning (asset sizes; "no local model download" when a remote
+    // embedding endpoint is configured) BEFORE the prompt so the pre-checked
+    // default is an informed choice, not a surprise.
+    p.note(describeSemanticSearchAssets(embedding).join("\n"), "Semantic Search Assets");
     const enabled = await prompt(() => p.confirm({
         message: "Enable semantic search?",
-        initialValue: current.semanticSearchMode !== "off",
+        initialValue: true,
     }));
     if (!enabled) {
         return { mode: "off", prepareAssets: false };
     }
-    p.note(describeSemanticSearchAssets(embedding).join("\n"), "Semantic Search Assets");
     const prepareAssets = await prompt(() => p.confirm({
         message: isRemoteEmbeddingConfig(embedding)
             ? "Check the embedding endpoint and verify semantic search now?"

package/dist/setup/steps/sources.js

@@ -7,7 +7,8 @@
  * built-in registries.
  */
 import * as p from "../../cli/clack.js";
-import { DEFAULT_CONFIG, getEffectiveRegistries } from "../../core/config/config.js";
+import { DEFAULT_CONFIG, getEffectiveRegistries, getSources } from "../../core/config/config.js";
+import { readLockfile } from "../../integrations/lockfile.js";
 import { prompt, promptOrBack } from "../prompt.js";
 import { loadSetupStashes } from "../registry-stash-loader.js";
 function configuredSourceKey(source) {
@@ -30,15 +31,15 @@ function renderConfiguredSourceList(sources) {
     })
         .join("\n");
 }
-function renderInstalledSourceList(installed) {
-    return installed.map((entry) => `- ${entry.id} (${entry.source})`).join("\n");
+function renderInstalledSourceList(managed) {
+    return managed.map((entry) => `- ${entry.name ?? entry.url ?? entry.path ?? "unknown"} (${entry.type})`).join("\n");
 }
 export async function stepAdditionalSources(currentSources) {
     const sources = [...currentSources];
     let addMore = true;
     while (addMore) {
         const action = await prompt(() => p.select({
-            message: "Add another stash source?",
+            message: "Add another bundle source?",
             options: [
                 { value: "done", label: "Done — no more sources" },
                 { value: "github-repo", label: "GitHub repository", hint: "custom URL" },
@@ -62,7 +63,7 @@ export async function stepAdditionalSources(currentSources) {
             if (url === null)
                 continue;
             const name = await promptOrBack(() => p.text({
-                message: "Give this stash a name (optional):",
+                message: "Give this bundle a name (optional):",
                 placeholder: "my-repo",
             }));
             if (name === null)
@@ -80,7 +81,7 @@ export async function stepAdditionalSources(currentSources) {
         if (action === "filesystem") {
             const fsPath = await promptOrBack(() => p.text({
                 message: "Enter the directory path:",
-                placeholder: "/path/to/stash",
+                placeholder: "/path/to/bundle",
                 validate: (v) => {
                     if (!v?.trim())
                         return "Path cannot be empty";
@@ -90,8 +91,8 @@ export async function stepAdditionalSources(currentSources) {
                 continue;
             const resolved = fsPath.trim();
             const name = await promptOrBack(() => p.text({
-                message: "Give this stash a name (optional):",
-                placeholder: "my-stash",
+                message: "Give this bundle a name (optional):",
+                placeholder: "my-bundle",
             }));
             if (name === null)
                 continue;
@@ -150,13 +151,18 @@ export async function stepRegistries(current) {
  * @internal Exported for testing only.
  */
 export async function stepAddSources(current, options) {
-    const existingSources = [...(current.sources ?? [])];
+    // The wizard toggles plain additional bundles, not the default bundle or
+    // lock-backed registry installs, which are preserved untouched.
+    const lockIds = new Set(readLockfile().map((entry) => entry.id));
+    const allSources = getSources(current);
+    const existingSources = allSources.filter((source) => !source.primary && !(source.name && lockIds.has(source.name)));
+    const managedSources = allSources.filter((source) => source.name != null && lockIds.has(source.name));
     const sources = [];
     if (existingSources.length > 0) {
-        p.note(renderConfiguredSourceList(existingSources), "Configured stash sources");
+        p.note(renderConfiguredSourceList(existingSources), "Configured bundle sources");
         const options = existingSources.map(describeConfiguredSource);
         const selected = await prompt(() => p.multiselect({
-            message: "Configured stash sources — uncheck any you want to disable:",
+            message: "Configured bundle sources — uncheck any you want to disable:",
             options,
             initialValues: options.map((option) => option.value),
             required: false,
@@ -167,8 +173,8 @@ export async function stepAddSources(current, options) {
             }
         }
     }
-    if ((current.installed?.length ?? 0) > 0) {
-        p.note(renderInstalledSourceList(current.installed ?? []), "Installed managed stashes (preserved)");
+    if (managedSources.length > 0) {
+        p.note(renderInstalledSourceList(managedSources), "Installed managed bundles (preserved)");
     }
     // ── Registry-driven stash recommendations ─────────────────────────────
     // Fetch available stashes from the official registry (cached, stale-ok).
@@ -189,8 +195,8 @@ export async function stepAddSources(current, options) {
             : availableStashes.filter((s) => s.defaultSelected).map((s) => s.url);
         const selectedUrls = await prompt(() => p.multiselect({
             message: availableStashes[0]?.source === "registry"
-                ? "Available stashes from the AKM registry — toggle to add or remove:"
-                : "Recommended stash sources — toggle to add or remove:",
+                ? "Available bundles from the AKM registry — toggle to add or remove:"
+                : "Recommended bundle sources — toggle to add or remove:",
             options: stashOptions,
             initialValues,
             required: false,

package/dist/setup/steps/stashdir.js

@@ -6,24 +6,26 @@
  * and other assets).
  */
 import * as p from "../../cli/clack.js";
+import { primaryBundlePath } from "../../core/config/config.js";
 import { assertSafeStashDir, getDefaultStashDir } from "../../core/paths.js";
 import { prompt } from "../prompt.js";
 export async function stepStashDir(current, options) {
-    const defaultDir = options?.preferredDir ?? current.stashDir ?? getDefaultStashDir();
+    const currentPrimary = primaryBundlePath(current);
+    const defaultDir = options?.preferredDir ?? currentPrimary ?? getDefaultStashDir();
     if (options?.nonInteractive) {
         return defaultDir;
     }
     const choice = await prompt(() => p.select({
         message: "Where should akm store skills, commands, and other assets?",
         options: [
-            { value: "default", label: defaultDir, hint: current.stashDir ? "current" : "default" },
+            { value: "default", label: defaultDir, hint: currentPrimary ? "current" : "default" },
             { value: "custom", label: "Enter a custom path..." },
         ],
     }));
     if (choice === "default")
         return defaultDir;
     const customPath = await prompt(() => p.text({
-        message: "Enter the stash directory path:",
+        message: "Enter the bundle directory path:",
         placeholder: defaultDir,
         validate: (v) => {
             if (!v?.trim())
@@ -34,7 +36,7 @@ export async function stepStashDir(current, options) {
             catch (err) {
                 if (err instanceof Error)
                     return err.message;
-                return "Refused: unsafe stash directory";
+                return "Refused: unsafe bundle directory";
             }
         },
     }));

package/dist/setup/steps/tasks.js

@@ -1,152 +1,269 @@
 // 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/.
-/**
- * Setup wizard steps: register the default improve task set and enable/disable
- * scheduled core tasks.
- */
+/** Setup wizard step for reviewing task definitions and activating schedules. */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 import * as p from "../../cli/clack.js";
-import { detectServerDefault, isCiEnvironment, registerDefaultTasks } from "../../commands/tasks/default-tasks.js";
-import { akmTasksAdd, akmTasksList, akmTasksSetEnabled, akmTasksSync } from "../../commands/tasks/tasks.js";
-import { saveGitStash } from "../../sources/providers/git.js";
+import { akmTasksSync, setEnabledInYaml } from "../../commands/tasks/tasks.js";
+import { loadConfig } from "../../core/config/config.js";
+import { UsageError } from "../../core/errors.js";
+import { commitWriteTargetBoundary, deleteAssetFromSource, prepareWriteTargetForMutation, resolveWriteTarget, writeAssetToSource, } from "../../core/write-source.js";
 import { backendNameForPlatform } from "../../tasks/backends/index.js";
 import { listEmbeddedTasks } from "../../tasks/embedded.js";
+import { parseTaskDocument } from "../../tasks/parser.js";
 import { parseSchedule } from "../../tasks/schedule.js";
 import { prompt } from "../prompt.js";
 /**
- * Normalise a task id the same way `akm tasks` does (strip a trailing `.yml`
- * / `.md` suffix, trim) so the wizard can match embedded template ids against
- * the ids reported by `akmTasksList()`.
+ * 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.
  */
-function normaliseTaskIdForMatch(raw) {
-    return raw.trim().replace(/\.(yml|md)$/, "");
+const SERVER_SUGGESTED_TASK_ID = "akm-improve-nightly";
+let scheduledTasksEnvOverrides;
+/** TEST-ONLY. Swap the CI/server-detection probes; pass undefined to restore. */
+export function _setScheduledTasksEnvForTests(fakes) {
+    scheduledTasksEnvOverrides = fakes;
 }
 /**
- * Setup sub-step (issue #552): idempotently register the default improve task
- * set. Asks a single "Is this a server install?" question (defaulting per
- * platform) to decide whether the nightly sweep is enabled, then delegates to
- * {@link registerDefaultTasks}, which is CI-aware and never duplicates an
- * existing task. Skipped entirely under CI (the registration helper short-
- * circuits, and we never even prompt).
- *
- * Exported for testing.
+ * Decide whether `akm setup` is running in a CI environment, where it must
+ * register NO scheduled tasks. Mirrors the common `CI=true` convention used by
+ * GitHub Actions, GitLab CI, CircleCI, etc.
  */
-export async function stepDefaultImproveTasks(register = registerDefaultTasks) {
-    // CI: register nothing and don't prompt.
-    if (isCiEnvironment()) {
-        p.log.info("CI detected — skipping default improve task registration.");
-        return;
+export function isCiEnvironment(env = process.env) {
+    if (scheduledTasksEnvOverrides?.isCiEnvironment)
+        return scheduledTasksEnvOverrides.isCiEnvironment(env);
+    const ci = env.CI;
+    if (ci === undefined || ci === null)
+        return false;
+    const v = String(ci).trim().toLowerCase();
+    return v !== "" && v !== "0" && v !== "false";
+}
+/**
+ * Platform-appropriate default for "Is this a server install?":
+ *  - Linux without a battery → `true` (server).
+ *  - macOS / any host with a battery (laptop) → `false`.
+ * Used to preselect {@link SERVER_SUGGESTED_TASK_ID} in the task-review
+ * multiselect.
+ */
+export function detectServerDefault() {
+    if (scheduledTasksEnvOverrides?.detectServerDefault)
+        return scheduledTasksEnvOverrides.detectServerDefault();
+    if (os.platform() !== "linux")
+        return false;
+    // A laptop exposes a battery under /sys/class/power_supply/BAT*. Absence of
+    // any battery is our heuristic for "server / desktop".
+    try {
+        const entries = fs.readdirSync("/sys/class/power_supply");
+        const hasBattery = entries.some((e) => /^BAT/i.test(e));
+        return !hasBattery;
+    }
+    catch {
+        // If we cannot read power-supply info, prefer the safe server default on
+        // Linux (the nightly sweep is low-impact and re-runnable).
+        return true;
     }
-    const platformDefault = detectServerDefault();
-    const serverInstall = await prompt(() => p.confirm({
-        message: "Is this a server install? (enables the nightly quality sweep at 2am)",
-        initialValue: platformDefault,
-    }));
-    const result = await register({ serverInstall: serverInstall === true });
-    if (result.skipped)
-        return;
-    const total = result.created.length + result.existing.length;
-    p.log.success(`Default improve tasks registered (${result.created.length} new, ${result.existing.length} already present, ${total} total).`);
+}
+function normaliseTaskIdForMatch(raw) {
+    return raw.trim().replace(/\.(yml|md)$/, "");
+}
+export function listSetupTaskDefinitions() {
+    const config = loadConfig();
+    const target = resolveWriteTarget(config, config.defaultBundle, { requireWritable: false });
+    const taskDir = path.join(target.source.path, "tasks");
+    if (!fs.existsSync(taskDir))
+        return [];
+    const tasks = [];
+    for (const file of fs.readdirSync(taskDir)) {
+        if (!file.endsWith(".yml"))
+            continue;
+        const id = file.slice(0, -4);
+        const filePath = path.join(taskDir, file);
+        try {
+            const task = parseTaskDocument({ yaml: fs.readFileSync(filePath, "utf8"), filePath, id });
+            tasks.push({ id: task.id, schedule: task.schedule, enabled: task.enabled, description: task.description });
+        }
+        catch (error) {
+            throw new UsageError(`Cannot review task definition ${filePath}: ${error instanceof Error ? error.message : String(error)} ` +
+                "Fix or remove the invalid task, then rerun `akm setup`. No task files or scheduler state were changed.", "INVALID_FLAG_VALUE", "Fix or remove the invalid task definition, then rerun `akm setup`.");
+        }
+    }
+    return tasks.sort((a, b) => a.id.localeCompare(b.id));
+}
+export async function prepareSetupTaskDefinitions(tasks, deps = {}) {
+    const config = loadConfig();
+    const target = prepareWriteTargetForMutation(resolveWriteTarget(config, config.defaultBundle, { requireWritable: true }));
+    const taskDir = path.join(target.source.path, "tasks");
+    const writeAsset = deps.writeAsset ?? writeAssetToSource;
+    const deleteAsset = deps.deleteAsset ?? deleteAssetFromSource;
+    const commitBoundary = deps.commitBoundary ?? commitWriteTargetBoundary;
+    const prepared = tasks.map((plan) => {
+        const filePath = path.join(taskDir, `${plan.task.id}.yml`);
+        const original = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : undefined;
+        let yaml;
+        if (original !== undefined) {
+            yaml = setEnabledInYaml(original, plan.enabled);
+        }
+        else {
+            const document = yamlParse(plan.task.yaml);
+            document.schedule = plan.schedule;
+            document.enabled = plan.enabled;
+            yaml = yamlStringify(document);
+        }
+        parseTaskDocument({ yaml, filePath, id: plan.task.id });
+        parseSchedule(plan.schedule, backendNameForPlatform());
+        return { filePath, original, yaml, ref: { type: "task", name: plan.task.id } };
+    });
+    const changed = prepared.filter((entry) => entry.original !== entry.yaml);
+    if (changed.length === 0)
+        return 0;
+    const attempted = [];
+    try {
+        for (const entry of changed) {
+            attempted.push(entry);
+            await writeAsset(target.source, target.config, entry.ref, entry.yaml);
+        }
+        commitBoundary(target, "Prepare scheduled tasks");
+    }
+    catch (error) {
+        const rollbackErrors = [];
+        for (const entry of [...attempted].reverse()) {
+            try {
+                if (entry.original === undefined) {
+                    if (fs.existsSync(entry.filePath))
+                        await deleteAsset(target.source, target.config, entry.ref);
+                }
+                else {
+                    await writeAsset(target.source, target.config, entry.ref, entry.original);
+                    fs.writeFileSync(entry.filePath, entry.original, "utf8");
+                }
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+        }
+        try {
+            commitBoundary(target, "Restore scheduled tasks after failed setup");
+        }
+        catch (rollbackError) {
+            rollbackErrors.push(rollbackError);
+        }
+        if (rollbackErrors.length > 0) {
+            throw new AggregateError([error, ...rollbackErrors], `Task definition preparation failed and rollback was incomplete: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        throw error;
+    }
+    return changed.length;
 }
 const DEFAULT_SCHEDULED_TASKS_DEPS = {
-    list: akmTasksList,
-    add: akmTasksAdd,
-    setEnabled: akmTasksSetEnabled,
+    list: listSetupTaskDefinitions,
+    prepare: prepareSetupTaskDefinitions,
     sync: akmTasksSync,
-    gitSync: saveGitStash,
 };
-export async function stepScheduledTasks(deps = DEFAULT_SCHEDULED_TASKS_DEPS) {
+export async function stepScheduledTasks(deps = DEFAULT_SCHEDULED_TASKS_DEPS, options = {}) {
+    if (options.nonInteractive || isCiEnvironment()) {
+        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
+    // with `enabled: false`, so its YAML exists for `akm task run <id>` while
+    // nothing lands in the scheduler uncommented. Filtering on `task.enabled`
+    // here would make ships-disabled templates invisible and unpreparable.
     const embedded = listEmbeddedTasks();
     if (embedded.length === 0)
         return;
-    // Snapshot current state so we can diff against the user's selection.
-    let installed = [];
-    try {
-        installed = (await deps.list()).tasks;
-    }
-    catch {
-        // A missing/empty tasks dir is fine — treat as nothing installed.
-        installed = [];
-    }
+    const installed = await deps.list();
     const byId = new Map();
-    for (const t of installed)
-        byId.set(normaliseTaskIdForMatch(t.id), t);
-    // Pre-check tasks that are installed AND enabled.
-    const preChecked = embedded.filter((e) => byId.get(e.id)?.enabled === true).map((e) => e.id);
-    const stateLabel = (e) => {
-        const cur = byId.get(e.id);
-        if (!cur)
-            return "not installed";
-        return cur.enabled ? "enabled" : "disabled";
-    };
+    for (const task of installed)
+        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
+    // as every other embedded template, still gated behind the confirmation
+    // below.
+    if (!byId.has(SERVER_SUGGESTED_TASK_ID) &&
+        !preChecked.includes(SERVER_SUGGESTED_TASK_ID) &&
+        embedded.some((task) => task.id === SERVER_SUGGESTED_TASK_ID) &&
+        detectServerDefault()) {
+        preChecked.push(SERVER_SUGGESTED_TASK_ID);
+    }
     const selected = await prompt(() => p.multiselect({
-        message: "Enable scheduled core tasks? (space to toggle, enter to confirm)",
+        message: "Which task definitions should be enabled? (scheduler activation is confirmed separately)",
         required: false,
         initialValues: preChecked,
-        options: embedded.map((e) => ({
-            value: e.id,
-            label: e.label,
-            hint: `${e.description} — ${e.schedule} [${stateLabel(e)}]`,
-        })),
+        options: embedded.map((task) => {
+            const current = byId.get(task.id);
+            const schedule = current?.schedule ?? task.schedule;
+            const state = current ? (current.enabled ? "enabled" : "disabled") : "not prepared";
+            return {
+                value: task.id,
+                label: task.label,
+                hint: `${task.description} - ${schedule} [${state}]`,
+            };
+        }),
     }));
     const selectedSet = new Set(selected);
-    // Resolve per-task schedule edits for newly-checked, not-yet-installed tasks.
     const scheduleFor = new Map();
-    for (const e of embedded) {
-        const cur = byId.get(e.id);
-        if (selectedSet.has(e.id) && !cur) {
-            const edited = await prompt(() => p.text({
-                message: `Schedule for ${e.label}?`,
-                initialValue: e.schedule,
-                validate(value) {
-                    const candidate = (value ?? "").trim() || e.schedule;
-                    try {
-                        parseSchedule(candidate, backendNameForPlatform());
-                    }
-                    catch (err) {
-                        return err instanceof Error ? err.message : "Invalid schedule.";
-                    }
-                    return undefined;
-                },
-            }));
-            const sched = (edited ?? "").trim() || e.schedule;
-            scheduleFor.set(e.id, sched);
-        }
+    for (const task of embedded) {
+        if (!selectedSet.has(task.id) || byId.has(task.id))
+            continue;
+        const edited = await prompt(() => p.text({
+            message: `Schedule for ${task.label}?`,
+            initialValue: task.schedule,
+            validate(value) {
+                const candidate = (value ?? "").trim() || task.schedule;
+                try {
+                    parseSchedule(candidate, backendNameForPlatform());
+                }
+                catch (error) {
+                    return error instanceof Error ? error.message : "Invalid schedule.";
+                }
+                return undefined;
+            },
+        }));
+        scheduleFor.set(task.id, (edited ?? "").trim() || task.schedule);
     }
-    let syncNeeded = false;
-    for (const e of embedded) {
-        const cur = byId.get(e.id);
-        const checked = selectedSet.has(e.id);
-        if (checked && !cur) {
-            // New task: copy template into the primary stash + install scheduler entry.
-            const schedule = scheduleFor.get(e.id) ?? e.schedule;
-            await deps.add({
-                id: e.id,
-                schedule,
-                command: e.command,
-                description: e.description,
-            });
-            syncNeeded = true;
-        }
-        else if (checked && cur && !cur.enabled) {
-            // Present but disabled → re-enable.
-            await deps.setEnabled(e.id, true);
-        }
-        else if (!checked && cur?.enabled) {
-            // Previously enabled, now unchecked → disable (keep the stash file).
-            await deps.setEnabled(e.id, false);
-        }
-        // No state change → no action.
+    const plans = embedded.map((task) => {
+        const current = byId.get(task.id);
+        return {
+            task,
+            schedule: current?.schedule ?? scheduleFor.get(task.id) ?? task.schedule,
+            enabled: selectedSet.has(task.id),
+            installed: current !== undefined,
+        };
+    });
+    const embeddedIds = new Set(embedded.map((task) => task.id));
+    const custom = installed.filter((task) => !embeddedIds.has(normaliseTaskIdForMatch(task.id)));
+    p.note([
+        ...plans.map((plan) => `${plan.task.label}: ${plan.enabled ? "enabled" : "disabled"} | ${plan.schedule} | ${plan.task.description}`),
+        ...custom.map((task) => `${task.id}: ${task.enabled ? "enabled" : "disabled"} | ${task.schedule}${task.description ? ` | ${task.description}` : ""}`),
+    ].join("\n"), "Task Schedule Review");
+    const activate = await prompt(() => p.confirm({
+        message: `Activate these schedules now? This will update task files and sync them to the ${backendNameForPlatform()} scheduler.`,
+        initialValue: false,
+    }));
+    if (!activate) {
+        p.log.info("Task definitions and scheduler state were not changed.");
+        return;
     }
-    if (syncNeeded) {
-        // Reconcile scheduler entries with on-disk YAML, then commit the new file
-        // to git (a no-op for non-git stashes).
-        await deps.sync();
-        try {
-            deps.gitSync(undefined, "akm setup: enable scheduled tasks");
-        }
-        catch {
-            // Non-fatal — the task is installed regardless of git sync outcome.
+    const changed = await deps.prepare(plans);
+    if (changed > 0)
+        p.log.success(`Prepared ${changed} task definition${changed === 1 ? "" : "s"}.`);
+    const syncResult = await deps.sync();
+    if (syncResult.skipped.length > 0) {
+        for (const skipped of syncResult.skipped) {
+            p.log.warn(`Task "${skipped.id}" was not activated: ${skipped.reason}`);
         }
+        const activeCount = syncResult.installed.length + syncResult.updated.length + syncResult.unchanged.length;
+        p.log.warn(`${activeCount === 0 ? "No task schedules were activated." : "Task schedule activation was incomplete."} ` +
+            "If you are running AKM from source, run the installed `akm setup`. " +
+            "To migrate or repair existing scheduler bindings explicitly, run `akm task sync --rebind`.");
+        return;
     }
+    p.log.success("Task schedules activated. Verify them with `akm task doctor`.");
 }