@namzu/cli 29.1.0 → 32.0.0

package/dist/tui/schedule/tool-host.js

@@ -8,22 +8,38 @@
  * "Create paused" creates a job. A job created here records
  * `confirmation.surface: tool-confirmed`.
  */
+import { realpathSync } from 'node:fs';
 import { isAbsolute, relative, resolve } from 'node:path';
-import { describeSchedule, hostTimeZone, revealHiddenCharacters, upcomingFireTimes, } from '@namzu/sdk';
+import { describeSchedule, hostTimeZone, installedCommandShellForDialect, upcomingFireTimes, validateTimeZone, } from '@namzu/sdk';
 import { readPermissionLayers } from '../../config/load.js';
 import { discoverProviders } from '../../integrations/providers/discover.js';
-import { DEFAULT_MAX_ITERATIONS, DEFAULT_TIMEOUT_MS, DEFAULT_TOKEN_BUDGET, buildJob, confirmJob, previewLines, runsPerDay, } from '../../schedule/build.js';
+import { DEFAULT_MAX_ITERATIONS, DEFAULT_TIMEOUT_MS, DEFAULT_TOKEN_BUDGET, JobRequestError, buildJob, confirmJob, editedJob, previewLines, runsPerDay, } from '../../schedule/build.js';
+import { changesBlock, changesSinceConfirmed, confirmationView, describeChanges, permissionsChanged, } from '../../schedule/changes.js';
+import { callsCount } from '../../schedule/fire/calls.js';
 import { schedulePaths } from '../../schedule/paths.js';
-import { compileJobPolicy } from '../../schedule/policy.js';
+import { allowsCommands, compileJobPolicy, compileScriptCheckPolicy, } from '../../schedule/policy.js';
+import { verifyScheduledScript } from '../../schedule/script-check.js';
+import { scriptShellUnavailableReason } from '../../schedule/script-shell.js';
 import { readManifest } from '../../schedule/service/manifest.js';
-import { appendHistory } from '../../schedule/store/history.js';
-import { createJob, deleteJob, findJob, listJobs, updateJob } from '../../schedule/store/jobs.js';
+import { appendHistory, readHistory } from '../../schedule/store/history.js';
+import { ScheduleConflictError, createJob, deleteJob, findJob, listJobs, updateJob, } from '../../schedule/store/jobs.js';
 import { nextFireOf, readState } from '../../schedule/store/state.js';
+import { visibleScheduleMessage } from '../../schedule/visible-source.js';
 function within(root, path) {
     const rel = relative(root, path);
     return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
 }
-function summary(job, withPrompt, home) {
+/** The session's folder as a job records its own: canonical, symbolic links resolved. */
+function canonicalCwd(cwd) {
+    try {
+        return realpathSync(cwd);
+    }
+    catch {
+        return resolve(cwd);
+    }
+}
+/** A job as the tool reports it; `here` when it runs in the session's folder, which alone shows its prompt. */
+function summary(job, here, home) {
     const tz = job.schedule.kind === 'cron' ? job.schedule.tz : hostTimeZone();
     const state = readState(schedulePaths(home), job.id);
     return {
@@ -32,8 +48,14 @@ function summary(job, withPrompt, home) {
         state: job.state,
         schedule: describeSchedule(job.schedule, { tz }),
         ...(nextFireOf(job, state) ? { nextFireAt: nextFireOf(job, state) } : {}),
-        ...(state.lastRun ? { lastStatus: state.lastRun.status } : {}),
-        ...(withPrompt ? { prompt: job.prompt } : {}),
+        ...(state.lastRun
+            ? {
+                lastStatus: callsCount(state.lastRun)
+                    ? `${state.lastRun.status} (${callsCount(state.lastRun)})`
+                    : state.lastRun.status,
+            }
+            : {}),
+        ...(here ? { prompt: job.prompt, inSessionFolder: true } : {}),
     };
 }
 async function credentialText(provider) {
@@ -50,20 +72,145 @@ async function credentialText(provider) {
         return 'unknown';
     }
 }
-/** The preview lines, the full prompt with hidden characters shown, and the tripwire's findings. */
-export function renderConfirmation(request, lines) {
-    const p = request.preview;
+/** The preview lines, the credential, the warnings, and the full prompt with hidden characters shown. */
+function confirmationBody(p, findings, lines) {
+    const scriptSection = p.runKind && p.runKind !== 'agent' && p.script
+        ? [
+            `${p.runKind === 'script' ? 'Script' : 'Wake-gate script'} (exactly as it will run, ${p.script.shell}; verified against the scheduled-run floor and any deny rules)`,
+            ...p.script.body.split('\n').map((l) => `  │ ${l}`),
+            p.runKind === 'script'
+                ? 'Runs exactly as shown; the scheduled-run floor and every deny rule apply to this script'
+                : 'Runs exactly as shown; the scheduled-run floor and every deny rule apply to the gate, and the permission set governs the agent phase',
+        ]
+        : [];
+    const promptSection = p.prompt.trim()
+        ? [
+            p.runKind === 'script+agent'
+                ? 'Prompt (used only when the wake-gate says wake: true)'
+                : 'Prompt (exactly as the run will read it)',
+            ...p.prompt.split('\n').map((l) => `  │ ${l}`),
+        ]
+        : [];
     return [
-        '⏲ PROPOSED BY THE MODEL, NOT BY YOU — a scheduled job that runs later with nobody watching.',
         ...lines,
-        `Credential  ${p.credentialSource ?? 'unknown'}`,
+        ...(p.runKind === 'script' ? [] : [`Credential  ${p.credentialSource ?? 'unknown'}`]),
         ...p.warnings.map((w) => `Warning     ${w}`),
-        ...request.promptFindings.map((f) => `Warning     ${f}`),
-        'Prompt (exactly as the run will read it)',
-        ...revealHiddenCharacters(p.prompt)
-            .split('\n')
-            .map((l) => `  │ ${l}`),
-    ].join('\n');
+        ...findings.map((f) => `Warning     ${f}`),
+        ...scriptSection,
+        ...promptSection,
+    ];
+}
+/** The preview lines, the full prompt with hidden characters shown, and the tripwire's findings. */
+export function renderConfirmation(request, lines) {
+    return visibleScheduleMessage([
+        '⏲ PROPOSED BY THE MODEL, NOT BY YOU — a scheduled job that runs later with nobody watching.',
+        ...confirmationBody(request.preview, request.promptFindings, lines),
+    ].join('\n'));
+}
+/**
+ * A change the model proposed: what changes first (`-`/`+` lines, as
+ * `schedule edit` shows them), a warning when the permissions change, then
+ * the job as it would run, whole.
+ */
+export function renderUpdateConfirmation(request, lines) {
+    return visibleScheduleMessage([
+        `⏲ PROPOSED BY THE MODEL, NOT BY YOU — a change to the scheduled job ${request.preview.name}, which runs later with nobody watching.`,
+        ...changesBlock(request.changes),
+        ...(request.permissionsChange
+            ? [
+                'Warning     THE PERMISSIONS CHANGE: from its next run the job may do what the rules below allow.',
+            ]
+            : []),
+        ...confirmationBody(request.preview, request.promptFindings, lines),
+    ].join('\n'));
+}
+/**
+ * The request `buildJob` rebuilds a job from, for a change the model
+ * proposed: every field it left out as the job has it. A new permission set
+ * keeps the job's `execution` unless it names one, and the job's additional
+ * directories (which only the operator sets).
+ */
+export function updateRequest(current, changes, cwd, fallbackModel) {
+    const cron = current.schedule.kind === 'cron' ? current.schedule : undefined;
+    let spec;
+    if (changes.when === undefined) {
+        if (changes.tz === undefined)
+            spec = current.schedule;
+        else if (cron)
+            spec = { ...cron, tz: validateTimeZone(changes.tz) };
+        else
+            throw new JobRequestError(`a time zone changes only a cron schedule, and "${current.name}" is not one; give when as well.`);
+    }
+    const tz = changes.tz ?? cron?.tz;
+    const dirs = current.permissions.additionalDirectories;
+    const kept = dirs && dirs.length > 0 ? { additionalDirectories: [...dirs] } : {};
+    const proposed = changes.permissions;
+    const permissions = proposed
+        ? {
+            ...(proposed.preset ? { preset: proposed.preset } : {}),
+            ...(proposed.rules ? { rules: proposed.rules } : {}),
+            unmatched: proposed.unmatched,
+            execution: proposed.execution ?? current.permissions.execution,
+            ...kept,
+            ...(proposed.browser ? { browser: proposed.browser } : {}),
+        }
+        : {
+            rules: current.permissions.rules,
+            unmatched: current.permissions.unmatched,
+            execution: current.permissions.execution,
+            ...kept,
+            ...(current.permissions.browser ? { browser: current.permissions.browser } : {}),
+        };
+    // A kind or script the tool did not touch carries the job's own forward
+    // unchanged, exactly as `editedJob` does for a terminal edit. Moving TO
+    // `'agent'` always drops the script — whether or not one was given here,
+    // since an agent job cannot carry one (`buildJob` refuses that
+    // combination outright) — and the wake-gate cap only ever applies to a
+    // `runKind` that stays (or becomes) `'script+agent'`.
+    const runKind = changes.runKind ?? current.runKind;
+    if (runKind === 'script' && changes.prompt !== undefined)
+        throw new JobRequestError('a pure script job has no prompt; remove prompt');
+    if (runKind === 'script' && changes.budget !== undefined)
+        throw new JobRequestError('a pure script job has no agent budget; remove budget and use script.timeoutMs for its timeout');
+    if (runKind === 'script' &&
+        permissions.browser &&
+        (current.runKind !== 'script' || changes.permissions !== undefined))
+        throw new JobRequestError('a pure script job cannot use a browser grant; remove permissions.browser');
+    const script = runKind === 'agent' ? undefined : (changes.script ?? current.script);
+    return {
+        name: current.name,
+        prompt: runKind === 'script' ? '' : (changes.prompt ?? current.prompt),
+        when: changes.when ?? '',
+        ...(spec ? { spec } : {}),
+        folder: changes.folder !== undefined ? resolve(cwd, changes.folder) : current.folder.path,
+        ...(tz ? { tz } : {}),
+        ...(runKind ? { runKind } : {}),
+        ...(script ? { script } : {}),
+        ...(runKind === 'script+agent' && current.wakeGate ? { wakeGate: current.wakeGate } : {}),
+        permissions,
+        budget: { ...current.budget, ...(changes.budget ?? {}) },
+        ...(runKind === 'script'
+            ? {}
+            : current.model
+                ? {
+                    model: `${current.model.provider}${current.model.model ? `/${current.model.model}` : ''}`,
+                    ...(current.model.effort ? { effort: current.model.effort } : {}),
+                }
+                : fallbackModel
+                    ? {
+                        model: `${fallbackModel.provider}${fallbackModel.model ? `/${fallbackModel.model}` : ''}`,
+                    }
+                    : {}),
+        includeSummary: current.notify.includeSummary,
+        keepSessions: current.retention.keepSessions,
+        pauseAfterFailures: current.failurePolicy.pauseAfterFailures,
+        approvalTtlMs: current.approvalTtlMs,
+        createdBy: current.createdBy,
+        // `unmatched: allow` on the host is the operator's choice
+        // (`--allow-unattended-host`); a change that keeps the permissions
+        // keeps it, and the tool can never propose it.
+        allowUnattendedHost: proposed === undefined && current.permissions.unmatched === 'allow',
+    };
 }
 /**
  * Each optional value the model set to something other than what the
@@ -97,6 +244,96 @@ export function chosenByTheModel(draft, job, cwd, config) {
 }
 export function createScheduleToolHost(ui) {
     const built = new WeakMap();
+    const proposedUpdates = new WeakMap();
+    /** What the person is shown for a job, every field computed here; `extra` warnings last. */
+    const previewOf = async (job, extra, now) => {
+        const layers = readPermissionLayers({ cwd: job.folder.canonical });
+        const policy = compileJobPolicy(job.permissions, {
+            layers,
+            namzuHome: ui.home(),
+            folder: job.folder,
+        });
+        if (policy.diagnostics.length > 0)
+            throw new Error(`The rules do not compile: ${policy.diagnostics.join('; ')}`);
+        if (job.runKind && job.runKind !== 'agent' && !job.script)
+            throw new Error(`The ${job.runKind} job has no script to preview.`);
+        // A model-proposed script/wake-gate gets the same static check
+        // `schedule add` runs before anything is shown, so a proposal the
+        // floor or a `deny` rule refuses never reaches this confirmation
+        // screen at all.
+        if (job.runKind && job.runKind !== 'agent' && job.script) {
+            const selectedShell = installedCommandShellForDialect(job.script.shell);
+            if (!selectedShell)
+                throw new Error(scriptShellUnavailableReason(job.script.shell));
+            const scriptPolicy = compileScriptCheckPolicy(job.permissions, {
+                layers,
+                namzuHome: ui.home(),
+                folder: job.folder,
+            });
+            const checked = verifyScheduledScript(job.script.body, selectedShell.dialect, scriptPolicy);
+            if (!checked.ok) {
+                throw new Error(`The ${job.runKind === 'script' ? 'script' : 'wake-gate script'} was refused: ${checked.reason}`);
+            }
+        }
+        const roots = [ui.cwd(), ...ui.extraRoots()];
+        const outside = !roots.some((root) => within(root, job.folder.canonical));
+        const perDay = runsPerDay(job.schedule, now);
+        const hasScriptPhase = job.runKind === 'script' || job.runKind === 'script+agent';
+        const networkCapable = policy.network ||
+            (job.permissions.execution === 'host' && (hasScriptPhase || allowsCommands(job.permissions)));
+        const warnings = [
+            ...(outside
+                ? ['The folder is outside this session’s working directory and added directories.']
+                : []),
+            ...(networkCapable ? ['This run can reach the network.'] : []),
+            ...(job.permissions.browser && job.runKind !== 'script'
+                ? [
+                    `This run drives the browser signed in as you (profile ${job.permissions.browser.profile}) on ${Object.keys(job.permissions.browser.sites).join(', ')}.`,
+                ]
+                : []),
+            ...extra,
+        ];
+        const preview = {
+            name: job.name,
+            folder: job.folder.canonical,
+            outsideSessionRoots: outside,
+            prompt: job.prompt,
+            ...(job.runKind && job.runKind !== 'agent' ? { runKind: job.runKind } : {}),
+            ...(job.script ? { script: job.script } : {}),
+            schedule: describeSchedule(job.schedule, {
+                tz: job.schedule.kind === 'cron' ? job.schedule.tz : hostTimeZone(),
+            }),
+            nextFireTimes: upcomingFireTimes(job.schedule, now, 3).map((t) => t.toISOString()),
+            rules: policy.lines,
+            unmatched: job.permissions.unmatched,
+            execution: job.permissions.execution,
+            networkAccess: networkCapable,
+            networkGrantAccess: policy.network,
+            budget: job.runKind === 'script' && job.script
+                ? {
+                    maxIterations: 0,
+                    tokenBudget: 0,
+                    timeoutMs: job.script.timeoutMs,
+                }
+                : {
+                    maxIterations: job.budget.maxIterations,
+                    tokenBudget: job.budget.tokenBudget,
+                    timeoutMs: job.budget.timeoutMs,
+                },
+            ...(job.runKind === 'script' || job.schedule.kind === 'at'
+                ? {}
+                : { dailyTokenCeiling: perDay * job.budget.tokenBudget }),
+            ...(job.runKind === 'script' || !job.model
+                ? {}
+                : {
+                    model: `${job.model.provider}${job.model.model ? `/${job.model.model}` : ''}`,
+                    credentialSource: await credentialText(job.model.provider),
+                }),
+            warnings,
+        };
+        return { preview, policy };
+    };
+    const NOT_INSTALLED_NOTE = 'No scheduler is installed on this machine, so the job does not run until the operator runs `namzu schedule install`. Tell them; do not say it will run.';
     const paths = () => schedulePaths(ui.home());
     const history = (job, action) => appendHistory(paths(), job.id, {
         v: 1,
@@ -110,16 +347,22 @@ export function createScheduleToolHost(ui) {
         // confirmation shows it line by line, so the model may propose one.
         browserGrants: true,
         async preview(draft) {
+            if (draft.runKind === 'script' && draft.budget !== undefined)
+                throw new JobRequestError('a pure script job has no agent budget; remove budget and use script.timeoutMs for its timeout');
+            if (draft.runKind === 'script' && draft.permissions.browser !== undefined)
+                throw new JobRequestError('a pure script job cannot use a browser grant; remove permissions.browser');
             const model = ui.model();
-            if (!model)
+            if (!model && draft.runKind !== 'script')
                 throw new Error('This session has no model; a scheduled job runs on the session’s model.');
             const now = new Date();
             const folder = resolve(ui.cwd(), draft.folder ?? '.');
             const job = buildJob({
                 name: draft.name,
-                prompt: draft.prompt,
+                prompt: draft.prompt ?? '',
                 when: draft.when,
                 folder,
+                ...(draft.runKind ? { runKind: draft.runKind } : {}),
+                ...(draft.script ? { script: draft.script } : {}),
                 ...(draft.tz ? { tz: draft.tz } : {}),
                 permissions: {
                     ...(draft.permissions.preset ? { preset: draft.permissions.preset } : {}),
@@ -129,59 +372,18 @@ export function createScheduleToolHost(ui) {
                     ...(draft.permissions.browser ? { browser: draft.permissions.browser } : {}),
                 },
                 ...(draft.budget ? { budget: draft.budget } : {}),
-                model: `${model.provider}${model.model ? `/${model.model}` : ''}`,
+                ...(model && draft.runKind !== 'script'
+                    ? {
+                        model: `${model.provider}${model.model ? `/${model.model}` : ''}`,
+                    }
+                    : {}),
                 createdBy: {
                     surface: 'tool',
                     ...(ui.sessionId() ? { sessionId: ui.sessionId() } : {}),
                 },
             }, { paths: paths(), config: ui.config(), now });
-            const policy = compileJobPolicy(job.permissions, {
-                layers: readPermissionLayers({ cwd: job.folder.canonical }),
-                namzuHome: ui.home(),
-                folder: job.folder,
-            });
-            if (policy.diagnostics.length > 0)
-                throw new Error(`The rules do not compile: ${policy.diagnostics.join('; ')}`);
-            const roots = [ui.cwd(), ...ui.extraRoots()];
-            const outside = !roots.some((root) => within(root, job.folder.canonical));
-            const perDay = runsPerDay(job.schedule, now);
-            const warnings = [
-                ...(outside
-                    ? ['The folder is outside this session’s working directory and added directories.']
-                    : []),
-                ...(policy.network ? ['This run can reach the network.'] : []),
-                ...(job.permissions.browser
-                    ? [
-                        `This run drives the browser signed in as you (profile ${job.permissions.browser.profile}) on ${Object.keys(job.permissions.browser.sites).join(', ')}.`,
-                    ]
-                    : []),
-                ...chosenByTheModel(draft, job, ui.cwd(), ui.config()).map((line) => `Chosen by the model, not the default: ${line}`),
-            ];
-            const preview = {
-                name: job.name,
-                folder: job.folder.canonical,
-                outsideSessionRoots: outside,
-                prompt: job.prompt,
-                schedule: describeSchedule(job.schedule, {
-                    tz: job.schedule.kind === 'cron' ? job.schedule.tz : hostTimeZone(),
-                }),
-                nextFireTimes: upcomingFireTimes(job.schedule, now, 3).map((t) => t.toISOString()),
-                rules: policy.lines,
-                unmatched: job.permissions.unmatched,
-                execution: job.permissions.execution,
-                networkAccess: policy.network,
-                budget: {
-                    maxIterations: job.budget.maxIterations,
-                    tokenBudget: job.budget.tokenBudget,
-                    timeoutMs: job.budget.timeoutMs,
-                },
-                ...(job.schedule.kind === 'at'
-                    ? {}
-                    : { dailyTokenCeiling: perDay * job.budget.tokenBudget }),
-                model: `${job.model.provider}${job.model.model ? `/${job.model.model}` : ''}`,
-                credentialSource: await credentialText(job.model.provider),
-                warnings,
-            };
+            const chosen = chosenByTheModel(draft, job, ui.cwd(), ui.config()).map((line) => `Chosen by the model, not the default: ${line}`);
+            const { preview, policy } = await previewOf(job, chosen, now);
             built.set(preview, { job, lines: previewLines(job, policy, now) });
             return preview;
         },
@@ -192,7 +394,7 @@ export function createScheduleToolHost(ui) {
             ui.say(renderConfirmation(request, entry.lines));
             const answer = await ui.ask({
                 questionId: `schedule:${entry.job.id}`,
-                question: `Create the scheduled job "${entry.job.name}" the model proposed? (details above)`,
+                question: visibleScheduleMessage(`Create the scheduled job "${entry.job.name}" the model proposed? (details above)`),
                 header: 'Proposed by the model',
                 options: [
                     { id: 'cancel', label: 'Cancel', description: 'Create nothing' },
@@ -219,7 +421,9 @@ export function createScheduleToolHost(ui) {
             const entry = built.get(preview);
             if (!entry)
                 throw new Error('That proposal is no longer current; propose it again.');
-            const job = createJob(paths(), confirmJob(entry.job, 'tool-confirmed', new Date(), { paused: options.paused }));
+            const job = createJob(paths(), confirmJob(entry.job, 'tool-confirmed', new Date(), {
+                paused: options.paused,
+            }));
             history(job, 'created');
             // A job with no scheduler to run it does nothing, and the model's
             // "done" said nothing about that.
@@ -227,23 +431,115 @@ export function createScheduleToolHost(ui) {
             ui.say(`⏲ Scheduled job ${job.name} created${options.paused ? ' (paused)' : ''}. /schedule lists it.${installed ? '' : ' The scheduler is not installed, so it does not run until you install it: namzu schedule install.'}`);
             return {
                 name: job.name,
-                ...(installed
-                    ? {}
-                    : {
-                        note: 'No scheduler is installed on this machine, so the job does not run until the operator runs `namzu schedule install`. Tell them; do not say it will run.',
-                    }),
+                ...(installed ? {} : { note: NOT_INSTALLED_NOTE }),
             };
         },
-        async list(options) {
-            const cwd = ui.cwd();
-            return listJobs(paths())
-                .jobs.filter((job) => options.allFolders || job.folder.canonical === cwd)
-                .map((job) => summary(job, job.folder.canonical === cwd, ui.home()));
+        // A change is confirmed like a new job, whole, with what changes
+        // above it, and saved to the same job: its id, name and history stay.
+        // Every field it can touch is in the confirmation's digest, so the
+        // saved job carries the operator's new confirmation, as an edit on a
+        // terminal does.
+        async previewUpdate(ref, changes) {
+            const current = findJob(paths(), ref);
+            const now = new Date();
+            const job = editedJob(current, buildJob(updateRequest(current, changes, ui.cwd(), ui.model()), {
+                paths: paths(),
+                config: ui.config(),
+                now,
+            }));
+            const { preview, policy } = await previewOf(job, [], now);
+            const view = (j) => confirmationView(j, compileJobPolicy(j.permissions, {
+                layers: readPermissionLayers({ cwd: j.folder.canonical }),
+                namzuHome: ui.home(),
+                folder: j.folder,
+            }), now);
+            const differs = describeChanges(view(current), view(job));
+            if (differs.length === 0)
+                throw new Error(`That changes nothing in "${current.name}".`);
+            const lines = [...changesSinceConfirmed(readHistory(paths(), current.id)), ...differs];
+            proposedUpdates.set(preview, {
+                current,
+                job,
+                lines: previewLines(job, policy, now),
+                changes: lines,
+            });
+            return {
+                preview,
+                changes: lines,
+                permissionsChange: permissionsChanged(current, job),
+            };
+        },
+        async confirmUpdate(request, signal) {
+            const entry = proposedUpdates.get(request.preview);
+            if (!entry)
+                return false;
+            ui.say(renderUpdateConfirmation(request, entry.lines));
+            const answer = await ui.ask({
+                questionId: `schedule-update:${entry.current.id}`,
+                question: visibleScheduleMessage(`Save the change the model proposed to the scheduled job "${entry.current.name}"? (details above)`),
+                header: 'Proposed by the model',
+                options: [
+                    { id: 'cancel', label: 'Cancel', description: 'Change nothing' },
+                    {
+                        id: 'save',
+                        label: 'Save',
+                        description: request.permissionsChange
+                            ? 'It keeps its history and runs under the new permissions above'
+                            : 'It keeps its history and runs as shown above',
+                    },
+                ],
+                multiSelect: false,
+                allowFreeText: false,
+            }, signal);
+            return answer.kind === 'answer' && answer.selectedOptionIds[0] === 'save';
+        },
+        async update(preview) {
+            const entry = proposedUpdates.get(preview);
+            if (!entry)
+                throw new Error('That proposal is no longer current; propose it again.');
+            const now = new Date();
+            let next;
+            try {
+                next = updateJob(paths(), entry.current.id, entry.current.revision, () => confirmJob(entry.job, 'tool-confirmed', now, {
+                    paused: entry.current.state === 'paused',
+                }));
+            }
+            catch (error) {
+                if (error instanceof ScheduleConflictError)
+                    throw new Error(`"${entry.current.name}" changed while the operator was being asked; propose the change again.`);
+                throw error;
+            }
+            proposedUpdates.delete(preview);
+            appendHistory(paths(), next.id, {
+                v: 1,
+                kind: 'job',
+                at: now.toISOString(),
+                action: 'edited',
+                by: 'tool',
+                changes: entry.changes,
+            });
+            const installed = readManifest(paths()) !== undefined;
+            ui.say(`⏲ Scheduled job ${next.name} changed (${next.state}); it keeps its history. /schedule shows it.${installed ? '' : ' The scheduler is not installed, so it does not run until you install it: namzu schedule install.'}`);
+            return {
+                name: next.name,
+                ...(installed ? {} : { note: NOT_INSTALLED_NOTE }),
+            };
+        },
+        // Every job, whatever `allFolders` says: a model that has just created
+        // a job in another folder, and does not pass `allFolders`, was told
+        // "No scheduled jobs." while `namzu schedule list` showed it. The
+        // session folder's are marked, and only theirs carry the prompt.
+        async list() {
+            const cwd = canonicalCwd(ui.cwd());
+            const { jobs, errors } = listJobs(paths());
+            if (errors.length > 0)
+                throw new Error(`${errors.length} job file${errors.length === 1 ? '' : 's'} could not be read; inspect or repair the files under NAMZU_HOME before listing scheduled jobs.`);
+            return jobs.map((job) => summary(job, job.folder.canonical === cwd, ui.home()));
         },
         async find(ref) {
             try {
                 const job = findJob(paths(), ref);
-                return summary(job, job.folder.canonical === ui.cwd(), ui.home());
+                return summary(job, job.folder.canonical === canonicalCwd(ui.cwd()), ui.home());
             }
             catch {
                 return undefined;
@@ -252,11 +548,15 @@ export function createScheduleToolHost(ui) {
         async confirmAction(job, action, signal) {
             const answer = await ui.ask({
                 questionId: `schedule-${action}:${job.name}`,
-                question: `${action === 'delete' ? 'Delete' : 'Resume'} the scheduled job "${job.name}" (${job.schedule}, in ${job.folder})? The model asked.`,
+                question: visibleScheduleMessage(`${action === 'delete' ? 'Delete' : 'Resume'} the scheduled job "${job.name}" (${job.schedule}, in ${job.folder})? The model asked.`),
                 header: 'Proposed by the model',
                 options: [
                     { id: 'no', label: 'No', description: 'Leave it as it is' },
-                    { id: 'yes', label: action === 'delete' ? 'Delete it' : 'Resume it', description: '' },
+                    {
+                        id: 'yes',
+                        label: action === 'delete' ? 'Delete it' : 'Resume it',
+                        description: '',
+                    },
                 ],
                 multiSelect: false,
                 allowFreeText: false,