@skrr-ai/cli 0.1.41 → 0.1.42

package/dist/commands/code/install.js

@@ -4,7 +4,6 @@ const core_1 = require("@oclif/core");
 const auth_core_1 = require("@skrr-ai/auth-core");
 const base_command_1 = require("../../base-command");
 const api_fetch_1 = require("../../lib/api-fetch");
-const daemon_ref_1 = require("../../lib/daemon-ref");
 const daemon_target_1 = require("../../lib/daemon-target");
 const first_party_harness_1 = require("../../lib/first-party-harness");
 /**
@@ -84,11 +83,11 @@ class CodeInstall extends base_command_1.BaseCommand {
             // survive in mine.
             const reason = await this.installerNote(daemonId);
             if (reason) {
-                this.log(`Nothing to do on ${(0, daemon_ref_1.formatDaemonRef)(daemonId)} — ${reason}`);
+                this.log(`Nothing to do on ${daemonId} — ${reason}`);
                 return;
             }
             this.failWithCliError({
-                message: `The daemon on ${(0, daemon_ref_1.formatDaemonRef)(daemonId)} accepted the request and returned no ` +
+                message: `The daemon on ${daemonId} accepted the request and returned no ` +
                     'install job, and does not say why. Nothing has been shown to start. ' +
                     `Check what it offers with \`${this.config.bin} harnesses installers --daemon ${daemonId}\`, and ` +
                     `\`${this.config.bin} code doctor\` here once you expect it to have landed.`,
@@ -104,7 +103,7 @@ class CodeInstall extends base_command_1.BaseCommand {
                 this.log(JSON.stringify({ daemonId, ...started }, null, 2));
                 return;
             }
-            this.log(`Install started on ${(0, daemon_ref_1.formatDaemonRef)(daemonId)} — job ${jobId}.`);
+            this.log(`Install started on ${daemonId} — job ${jobId}.`);
             return;
         }
         const job = await this.followJob(daemonId, jobId, flags.json === true);

package/dist/commands/followups/remind.js

@@ -95,6 +95,10 @@ class FollowupsRemind extends base_command_1.BaseCommand {
             return;
         }
         const row = response.followup;
+        if (response.reused && response.rescheduled) {
+            this.log(`Moved: ${row?.id} now fires at ${row?.nextRunAt ?? at} — the same reminder already existed, so it was rescheduled rather than duplicated.`);
+            return;
+        }
         if (response.reused) {
             this.log(`Already armed: ${row?.id} — the same reminder exists and was not duplicated.`);
             return;

package/dist/commands/harnesses/install.d.ts

@@ -1,4 +1,5 @@
 import { BaseCommand } from '../../base-command';
+import { type ManagedCliProviderState } from '../../lib/cli-installers';
 /**
  * Install one managed coding-agent CLI on a machine.
  *
@@ -33,9 +34,26 @@ export default class HarnessesInstall extends BaseCommand {
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         daemon: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        update: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    /**
+     * Update an installed CLI in place (OSK-10096).
+     *
+     * Asks the inventory first rather than posting blind: a daemon older than
+     * managed updates has no handler for the request and would leave it to time
+     * out, and a CLI that updates some other way (the copy inside Devin.app) has a
+     * reason the daemon already words. Both are answered before anything runs.
+     */
+    private update;
+    /** Follow a job to its end, or report why it could not be followed (and return nothing). */
+    private follow;
     /** What the daemon says about this provider right now, best effort. */
     private installerNote;
     private daemonIdFor;
 }
+/**
+ * The next step after "Already installed.": how to update it, or where its
+ * update comes from — or nothing from a daemon that cannot say (OSK-10096).
+ */
+export declare function updateHint(provider: string, state: ManagedCliProviderState | undefined, bin: string): string | null;

package/dist/commands/harnesses/install.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateHint = updateHint;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const cli_installers_1 = require("../../lib/cli-installers");
-const daemon_ref_1 = require("../../lib/daemon-ref");
 const daemon_target_1 = require("../../lib/daemon-target");
 /**
  * Install one managed coding-agent CLI on a machine.
@@ -32,10 +32,11 @@ const daemon_target_1 = require("../../lib/daemon-target");
  * come back as an opaque refusal.
  */
 class HarnessesInstall extends base_command_1.BaseCommand {
-    static description = 'Install a managed coding-agent CLI (claude, codex, devin, …) on one of your machines';
+    static description = 'Install a managed coding-agent CLI (claude, codex, devin, …) on one of your machines, or update one already installed (--update)';
     static examples = [
         '<%= config.bin %> harnesses install devin',
         '<%= config.bin %> harnesses install codex --daemon daemon_07c086e3c249_cli_default',
+        '<%= config.bin %> harnesses install claude --update',
     ];
     static args = {
         provider: core_1.Args.string({
@@ -49,6 +50,9 @@ class HarnessesInstall extends base_command_1.BaseCommand {
         daemon: core_1.Flags.string({
             description: 'Which machine to install on. Defaults to your only connected daemon; required when several are connected.',
         }),
+        update: core_1.Flags.boolean({
+            description: "Update the CLI already installed, with that CLI's own updater. When a CLI updates some other way (e.g. inside its desktop app), the daemon says so instead.",
+        }),
     };
     async run() {
         this.requireAuth();
@@ -66,6 +70,10 @@ class HarnessesInstall extends base_command_1.BaseCommand {
             listActiveDaemons: () => (0, daemon_target_1.listConnectedDaemons)(this.resolvedCredential),
         });
         const daemonId = this.daemonIdFor(target);
+        if (flags.update) {
+            await this.update(daemonId, provider, Boolean(flags.json));
+            return;
+        }
         let start;
         try {
             start = await (0, cli_installers_1.startManagedCliInstall)(daemonId, provider, this.resolvedCredential);
@@ -83,27 +91,22 @@ class HarnessesInstall extends base_command_1.BaseCommand {
             const reason = start.provider?.installDisabledReason?.trim() ||
                 (await this.installerNote(daemonId, provider));
             this.log(reason ? `${provider}: ${reason}` : `${provider}: the daemon started no install job.`);
+            // "Already installed." used to be the end of the road: the product could
+            // install a CLI and then had no word about updating it (OSK-10096).
+            if (start.alreadyInstalled) {
+                const next = updateHint(provider, start.provider, this.config.bin);
+                if (next)
+                    this.log(next);
+            }
             return;
         }
+        // The raw id: it is what `--daemon` takes, and a formatDaemonRef prefix of a
+        // `daemon_<hash>_…` id reads `d_daemon_4...` for every local daemon (OSK-10182).
         if (!flags.json)
-            this.logToStderr(`Installing ${provider} on ${(0, daemon_ref_1.formatDaemonRef)(daemonId)}…`);
-        const outcome = await (0, cli_installers_1.followManagedCliInstallJob)({
-            daemonId,
-            jobId,
-            credential: this.resolvedCredential,
-            onLogLine: flags.json ? undefined : (line) => this.logToStderr(`  ${line}`),
-        });
-        if (outcome.kind === 'missing') {
-            this.error(`The daemon no longer has install job ${jobId}.`, { exit: 1 });
+            this.logToStderr(`Installing ${provider} on ${daemonId}…`);
+        const job = await this.follow(daemonId, jobId, 'install', Boolean(flags.json));
+        if (!job)
             return;
-        }
-        if (outcome.kind === 'timeout') {
-            // Not a failure: the daemon is still working, and calling this failed
-            // would send someone to debug a download that is going fine.
-            this.error(`Still installing after ${Math.round(cli_installers_1.INSTALL_MAX_WAIT_MS / 60000)} minutes — the daemon is still working on job ${jobId}. Check \`${this.config.bin} harnesses installers\` in a while.`, { exit: 1 });
-            return;
-        }
-        const job = outcome.job;
         if (flags.json) {
             this.log(JSON.stringify({ daemonId, provider, job }, null, 2));
             if (job.status !== 'succeeded')
@@ -123,6 +126,99 @@ class HarnessesInstall extends base_command_1.BaseCommand {
         const state = await this.installerNote(daemonId, provider, true);
         this.log(`${provider} installed.${state ? ` ${state}` : ''}`);
     }
+    /**
+     * Update an installed CLI in place (OSK-10096).
+     *
+     * Asks the inventory first rather than posting blind: a daemon older than
+     * managed updates has no handler for the request and would leave it to time
+     * out, and a CLI that updates some other way (the copy inside Devin.app) has a
+     * reason the daemon already words. Both are answered before anything runs.
+     */
+    async update(daemonId, provider, json) {
+        let inventory;
+        try {
+            inventory = await (0, cli_installers_1.listCliInstallers)(daemonId, this.resolvedCredential);
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        const row = (inventory.providers ?? []).find((p) => (0, data_provider_1.normalizeManagedCliProvider)(p.provider) === provider);
+        if (!row || row.updatable === undefined) {
+            this.failWithCliError({
+                message: `The daemon ${daemonId} (${inventory.daemonVersion ?? 'version not reported'}) cannot update ${provider}: it predates managed updates. ` +
+                    `Update the daemon, then run this again — \`${this.config.bin} daemon status\` says how.`,
+                code: 'DAEMON_UPDATE_UNSUPPORTED',
+                exit: 1,
+                retryable: false,
+            });
+            return;
+        }
+        if (!row.updatable) {
+            this.failWithCliError({
+                message: `${provider}: ${row.updateDisabledReason?.trim() || 'the daemon cannot update it here.'}`,
+                code: 'CLI_NOT_UPDATABLE',
+                exit: 1,
+                retryable: false,
+            });
+            return;
+        }
+        let start;
+        try {
+            start = await (0, cli_installers_1.startManagedCliUpdate)(daemonId, provider, this.resolvedCredential);
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        const jobId = start.job?.id;
+        if (!start.started || !jobId) {
+            this.log(start.alreadyRunning
+                ? `${provider}: an install or update is already running (job ${start.job?.id ?? 'unknown'}).`
+                : `${provider}: ${start.provider?.updateDisabledReason?.trim() || 'the daemon started no update job.'}`);
+            return;
+        }
+        if (!json) {
+            this.logToStderr(`Updating ${provider} ${row.version ? `${row.version} ` : ''}on ${daemonId}…`);
+        }
+        const job = await this.follow(daemonId, jobId, 'update', json);
+        if (!job)
+            return;
+        if (json) {
+            this.log(JSON.stringify({ daemonId, provider, job }, null, 2));
+            if (job.status !== 'succeeded')
+                process.exitCode = 1;
+            return;
+        }
+        if (job.status === 'failed') {
+            this.error(`Updating ${provider} failed: ${job.error || 'the daemon gave no reason.'}`, {
+                exit: 1,
+            });
+            return;
+        }
+        this.log((0, cli_installers_1.updateOutcomeLine)(job) ??
+            `${provider} updated${job.installedVersion ? ` to ${job.installedVersion}` : ''}.`);
+    }
+    /** Follow a job to its end, or report why it could not be followed (and return nothing). */
+    async follow(daemonId, jobId, verb, json) {
+        const outcome = await (0, cli_installers_1.followManagedCliInstallJob)({
+            daemonId,
+            jobId,
+            credential: this.resolvedCredential,
+            onLogLine: json ? undefined : (line) => this.logToStderr(`  ${line}`),
+        });
+        if (outcome.kind === 'missing') {
+            this.error(`The daemon no longer has ${verb} job ${jobId}.`, { exit: 1 });
+            return undefined;
+        }
+        if (outcome.kind === 'timeout') {
+            // Not a failure: the daemon is still working, and calling this failed
+            // would send someone to debug a download that is going fine.
+            this.error(`Still ${verb === 'install' ? 'installing' : 'updating'} after ${Math.round(cli_installers_1.INSTALL_MAX_WAIT_MS / 60000)} minutes — the daemon is still working on job ${jobId}. Check \`${this.config.bin} harnesses installers\` in a while.`, { exit: 1 });
+            return undefined;
+        }
+        return outcome.job;
+    }
     /** What the daemon says about this provider right now, best effort. */
     async installerNote(daemonId, provider, readiness = false) {
         try {
@@ -175,3 +271,16 @@ class HarnessesInstall extends base_command_1.BaseCommand {
     }
 }
 exports.default = HarnessesInstall;
+/**
+ * The next step after "Already installed.": how to update it, or where its
+ * update comes from — or nothing from a daemon that cannot say (OSK-10096).
+ */
+function updateHint(provider, state, bin) {
+    if (!state || state.updatable === undefined)
+        return null;
+    if (state.updatable) {
+        return `To update it: ${bin} harnesses install ${provider} --update`;
+    }
+    const reason = state.updateDisabledReason?.trim();
+    return reason ? `Updating: ${reason}` : null;
+}

package/dist/commands/skills/import-as-actions.js

@@ -140,35 +140,26 @@ class SkillsImportAsActions extends base_command_1.BaseCommand {
             this.handleApiError(err);
             return;
         }
-        const failed = result.results.filter((r) => r.status === 'failed');
+        const { rows, summary, failed } = (0, local_skills_1.summarizeSkillActionImport)(result);
         if (flags.json) {
             this.log(JSON.stringify(result, null, 2));
         }
         else {
-            (0, format_1.renderTable)(result.results.map((r) => ({
-                skill: r.name,
-                import: r.status,
-                action: r.actionCreated
-                    ? 'created'
-                    : (r.actionSkippedReason ??
-                        r.actionError ??
-                        (r.status === 'failed' ? '-' : 'not added')),
-                detail: r.error ?? '',
-            })), [
+            (0, format_1.renderTable)(rows, [
                 { key: 'skill', header: 'SKILL' },
                 { key: 'import', header: 'IMPORT' },
                 { key: 'action', header: 'ACTION' },
                 { key: 'detail', header: 'DETAIL' },
             ], (line) => this.log(line));
-            this.log(`${result.actionsCreated} action(s) created on ${result.targetAgentId}; ` +
-                `${failed.length} skill(s) failed.`);
+            this.log(summary);
             if (result.actionsError) {
                 this.log(`The skills imported, but their actions could not be added: ${result.actionsError.message}`);
             }
         }
         // Partial success is normal and reported above; exit non-zero only when
-        // something the caller asked for did not happen.
-        if (failed.length > 0 || result.actionsError)
+        // something the caller asked for did not happen — including an action the
+        // full library could not take.
+        if (failed)
             this.exit(1);
     }
 }

package/dist/commands/tasks/complete.js

@@ -255,6 +255,19 @@ class TasksComplete extends base_command_1.BaseCommand {
             });
         }
         catch (error) {
+            // Completing records a Result, so a closed Task refuses it the same way
+            // `tasks result submit` is refused, with the same way forward.
+            const refusal = (0, base_command_1.apiRefusal)(error);
+            if (refusal.code === 'TASK_REOPEN_REQUIRED') {
+                this.error([
+                    refusal.message ?? 'This Task is closed.',
+                    ...(0, task_closure_1.reopenRequiredLines)({
+                        bin: this.config.bin,
+                        task: identity.id,
+                        command: 'complete',
+                    }),
+                ].join('\n'), { exit: 1, code: 'TASK_REOPEN_REQUIRED' });
+            }
             this.handleApiError(error);
         }
         const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, { id: taskId });

package/dist/commands/tasks/result/submit.js

@@ -122,14 +122,19 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
                 : await data_provider_1.dataService.submitTaskResult({ taskId: task.id, data });
         }
         catch (error) {
-            // A closed Task refuses a Result. Name the two ways forward here, where
-            // the commands are known: the API's own message stays surface-neutral
+            // A closed Task refuses a Result. Name the way forward here, where the
+            // commands are known: the API's own message stays surface-neutral
             // (OSK-10031).
             const refusal = (0, base_command_1.apiRefusal)(error);
             if (refusal.code === 'TASK_REOPEN_REQUIRED') {
-                this.error(`${refusal.message ?? 'This Task is closed.'}\n` +
-                    `→ Reopen it and submit again: ${this.config.bin} tasks move ${task.id} --status in_progress\n` +
-                    `→ Or record the Result and close it in one step: ${this.config.bin} tasks complete ${task.id} --summary "…"`, { exit: 1, code: 'TASK_REOPEN_REQUIRED' });
+                this.error([
+                    refusal.message ?? 'This Task is closed.',
+                    ...(0, task_closure_1.reopenRequiredLines)({
+                        bin: this.config.bin,
+                        task: task.id,
+                        command: 'result submit',
+                    }),
+                ].join('\n'), { exit: 1, code: 'TASK_REOPEN_REQUIRED' });
             }
             this.handleApiError(error);
         }

package/dist/lib/cli-installers.d.ts

@@ -25,6 +25,13 @@ export interface ManagedCliProviderState {
     source?: string;
     installable?: boolean;
     installDisabledReason?: string | null;
+    /**
+     * Whether the daemon can update this installed CLI in place, and why not.
+     * ABSENT from a daemon older than managed updates (OSK-10096) — read that as
+     * "this daemon cannot say", never as `false`.
+     */
+    updatable?: boolean;
+    updateDisabledReason?: string | null;
     platformSupported?: boolean;
     authentication?: ManagedCliAuthentication | null;
     job?: {
@@ -143,18 +150,33 @@ export declare function readinessForRows(rows: readonly ReadinessRow[], credenti
 }>;
 export interface ManagedCliInstallJob {
     id: string;
+    provider?: string;
+    displayName?: string;
     status: 'queued' | 'running' | 'succeeded' | 'failed';
+    /** `update` for an in-place update; absent from an older daemon, meaning install. */
+    kind?: 'install' | 'update';
+    previousVersion?: string | null;
+    installedVersion?: string | null;
     error?: string;
     /**
      * The daemon's job log: the LAST lines only (a sliding window, 200 lines in
      * `daemon/src/cli-installers.ts`). This is the field the daemon sends.
      */
     logTail?: string[];
+    /**
+     * Lines the job has EVER logged (daemons with OSK-10179). With it, the lines
+     * new since the last poll are exactly the last `count − printed` of the tail,
+     * even when they repeat.
+     */
+    logLineCount?: number;
     /** Never sent by any daemon; kept so an older caller's shape still types. */
     log?: string[];
 }
 export interface StartInstallResponse {
     started?: boolean;
+    /** The daemon declined because the CLI is already there. */
+    alreadyInstalled?: boolean;
+    alreadyRunning?: boolean;
     provider?: ManagedCliProviderState;
     job?: {
         id?: string;
@@ -162,6 +184,14 @@ export interface StartInstallResponse {
     };
 }
 export declare function startManagedCliInstall(daemonId: string, provider: string, credential?: unknown): Promise<StartInstallResponse>;
+/** Ask the daemon to update an installed CLI in place (OSK-10096). */
+export declare function startManagedCliUpdate(daemonId: string, provider: string, credential?: unknown): Promise<StartInstallResponse>;
+/**
+ * How an update job ended, from the versions the daemon recorded on it:
+ * "Updated Claude Code 2.1.270 → 2.1.280." or "Claude Code is still 2.1.270:
+ * its updater found nothing newer." Null when the job does not carry both.
+ */
+export declare function updateOutcomeLine(job: ManagedCliInstallJob): string | null;
 export declare function readManagedCliInstallJob(daemonId: string, jobId: string, credential?: unknown): Promise<{
     job?: ManagedCliInstallJob;
 }>;
@@ -174,6 +204,16 @@ export declare function readManagedCliInstallJob(daemonId: string, jobId: string
  * the end of what was already printed, and print only what follows it.
  */
 export declare function unseenLogLines(printed: readonly string[], tail: readonly string[]): string[];
+/**
+ * The new lines of a job's tail when the daemon reports its running line count:
+ * exactly the last `total − printedCount`, and how many of those already fell
+ * out of the window (the daemon keeps the last 200). Unlike overlap matching,
+ * this cannot mistake a repeated line for one already printed.
+ */
+export declare function newLogLinesByCount(printedCount: number, tail: readonly string[], total: number): {
+    lines: string[];
+    skipped: number;
+};
 /** A 100 MB download over a hotel connection is the case this has to survive. */
 export declare const INSTALL_MAX_WAIT_MS: number;
 export declare const INSTALL_POLL_INTERVAL_MS = 2000;

package/dist/lib/cli-installers.js

@@ -9,8 +9,11 @@ exports.readinessByProvider = readinessByProvider;
 exports.readinessKey = readinessKey;
 exports.readinessForRows = readinessForRows;
 exports.startManagedCliInstall = startManagedCliInstall;
+exports.startManagedCliUpdate = startManagedCliUpdate;
+exports.updateOutcomeLine = updateOutcomeLine;
 exports.readManagedCliInstallJob = readManagedCliInstallJob;
 exports.unseenLogLines = unseenLogLines;
+exports.newLogLinesByCount = newLogLinesByCount;
 exports.followManagedCliInstallJob = followManagedCliInstallJob;
 /**
  * The daemon's managed-CLI installer inventory, as the CLI reads it.
@@ -211,6 +214,25 @@ async function readinessForRows(rows, credential, opts = {}) {
 async function startManagedCliInstall(daemonId, provider, credential) {
     return (0, api_fetch_1.apiFetch)(`/api/daemons/${encodeURIComponent(daemonId)}/cli-installers/${encodeURIComponent(provider)}/install`, { method: 'POST', body: {}, credential: credential });
 }
+/** Ask the daemon to update an installed CLI in place (OSK-10096). */
+async function startManagedCliUpdate(daemonId, provider, credential) {
+    return (0, api_fetch_1.apiFetch)(`/api/daemons/${encodeURIComponent(daemonId)}/cli-installers/${encodeURIComponent(provider)}/update`, { method: 'POST', body: {}, credential: credential });
+}
+/**
+ * How an update job ended, from the versions the daemon recorded on it:
+ * "Updated Claude Code 2.1.270 → 2.1.280." or "Claude Code is still 2.1.270:
+ * its updater found nothing newer." Null when the job does not carry both.
+ */
+function updateOutcomeLine(job) {
+    const before = job.previousVersion;
+    const after = job.installedVersion;
+    if (!before || !after)
+        return null;
+    const name = job.displayName || job.provider || 'The CLI';
+    return before === after
+        ? `${name} is still ${after}: its updater found nothing newer.`
+        : `Updated ${name} ${before} → ${after}.`;
+}
 async function readManagedCliInstallJob(daemonId, jobId, credential) {
     return (0, api_fetch_1.apiFetch)(`/api/daemons/${encodeURIComponent(daemonId)}/cli-installers/jobs/${encodeURIComponent(jobId)}`, { credential: credential });
 }
@@ -237,6 +259,20 @@ function unseenLogLines(printed, tail) {
     }
     return [...tail];
 }
+/**
+ * The new lines of a job's tail when the daemon reports its running line count:
+ * exactly the last `total − printedCount`, and how many of those already fell
+ * out of the window (the daemon keeps the last 200). Unlike overlap matching,
+ * this cannot mistake a repeated line for one already printed.
+ */
+function newLogLinesByCount(printedCount, tail, total) {
+    const unseen = Math.max(0, total - printedCount);
+    if (unseen === 0)
+        return { lines: [], skipped: 0 };
+    if (unseen > tail.length)
+        return { lines: [...tail], skipped: unseen - tail.length };
+    return { lines: tail.slice(tail.length - unseen), skipped: 0 };
+}
 /** A 100 MB download over a hotel connection is the case this has to survive. */
 exports.INSTALL_MAX_WAIT_MS = 10 * 60_000;
 exports.INSTALL_POLL_INTERVAL_MS = 2_000;
@@ -256,6 +292,7 @@ exports.INSTALL_POLL_INTERVAL_MS = 2_000;
 async function followManagedCliInstallJob(input) {
     const deadline = Date.now() + (input.maxWaitMs ?? exports.INSTALL_MAX_WAIT_MS);
     let printed = [];
+    let printedCount = 0;
     for (;;) {
         const res = await readManagedCliInstallJob(input.daemonId, input.jobId, input.credential);
         const job = res.job;
@@ -264,7 +301,20 @@ async function followManagedCliInstallJob(input) {
         if (input.onLogLine) {
             // `logTail`, the field the daemon sends — this read `log`, which no daemon
             // has ever sent, so every install printed nothing until it ended (OSK-10103).
-            const fresh = unseenLogLines(printed, job.logTail ?? job.log ?? []);
+            const tail = job.logTail ?? job.log ?? [];
+            let fresh;
+            if (typeof job.logLineCount === 'number') {
+                // Exact: the daemon says how many lines exist in total (OSK-10179).
+                const { lines, skipped } = newLogLinesByCount(printedCount, tail, job.logLineCount);
+                if (skipped > 0) {
+                    input.onLogLine(`(… ${skipped} log line${skipped === 1 ? '' : 's'} not shown)`);
+                }
+                fresh = lines;
+                printedCount = Math.max(printedCount, job.logLineCount);
+            }
+            else {
+                fresh = unseenLogLines(printed, tail);
+            }
             for (const line of fresh)
                 input.onLogLine(line);
             printed = [...printed, ...fresh].slice(-MAX_TRACKED_LOG_LINES);

package/dist/lib/followups.d.ts

@@ -56,6 +56,8 @@ export interface FollowUpRow {
 export interface FollowUpCreateResponse {
     followup: FollowUpRow | null;
     reused?: boolean;
+    /** A reused reminder asked for at a different time moved to that time. */
+    rescheduled?: boolean;
     dropped?: false | 'budget';
     proposal?: boolean;
     budget?: Json;

package/dist/lib/local-skills.d.ts

@@ -112,3 +112,30 @@ export declare const SKILL_CONVENTION_DISCOVERY_SINCE = "0.8.44";
  * add an explanation, and claiming an unknown daemon is old would be a guess.
  */
 export declare function daemonPredates(version: string | null | undefined, floor: string): boolean;
+/**
+ * The table, summary and exit decision for `skills import-as-actions`.
+ *
+ * A skill that imported without its action because the library was full used to
+ * show only `limit_reached`, an empty detail, "0 skill(s) failed" and exit 0, so
+ * a script or agent concluded every action it asked for was added (OSK-10185).
+ * `already_exists` stays a success: the action the caller wanted is there.
+ */
+export declare function summarizeSkillActionImport(result: {
+    targetAgentId: string;
+    actionsCreated: number;
+    results: Array<{
+        name: string;
+        status: string;
+        error?: string;
+        actionCreated?: boolean;
+        actionSkippedReason?: string;
+        actionError?: string;
+    }>;
+    actionsError?: {
+        message: string;
+    } | null;
+}): {
+    rows: Array<Record<string, string>>;
+    summary: string;
+    failed: boolean;
+};

package/dist/lib/local-skills.js

@@ -10,6 +10,7 @@ exports.looksLikeSkillPath = looksLikeSkillPath;
 exports.findLocalSkillsNamed = findLocalSkillsNamed;
 exports.describeStoreSkillMiss = describeStoreSkillMiss;
 exports.daemonPredates = daemonPredates;
+exports.summarizeSkillActionImport = summarizeSkillActionImport;
 const data_provider_1 = require("@skrr-ai/data-provider");
 const instruction_input_1 = require("./instruction-input");
 /**
@@ -211,3 +212,40 @@ function daemonPredates(version, floor) {
     }
     return false;
 }
+/** Why a skill imported but got no action, in words a person or an agent can act on. */
+const ACTION_SKIP_DETAIL = {
+    limit_reached: "this agent's action library is full; delete an action, then run the import again to add it",
+    already_exists: 'an action for this skill is already offered at this scope',
+};
+/**
+ * The table, summary and exit decision for `skills import-as-actions`.
+ *
+ * A skill that imported without its action because the library was full used to
+ * show only `limit_reached`, an empty detail, "0 skill(s) failed" and exit 0, so
+ * a script or agent concluded every action it asked for was added (OSK-10185).
+ * `already_exists` stays a success: the action the caller wanted is there.
+ */
+function summarizeSkillActionImport(result) {
+    const failed = result.results.filter((r) => r.status === 'failed');
+    const overCap = result.results.filter((r) => r.status !== 'failed' && r.actionSkippedReason === 'limit_reached');
+    const rows = result.results.map((r) => ({
+        skill: r.name,
+        import: r.status,
+        action: r.actionCreated
+            ? 'created'
+            : (r.actionSkippedReason ?? r.actionError ?? (r.status === 'failed' ? '-' : 'not added')),
+        detail: r.error ??
+            r.actionError ??
+            (r.actionSkippedReason ? (ACTION_SKIP_DETAIL[r.actionSkippedReason] ?? '') : ''),
+    }));
+    const summary = `${result.actionsCreated} action(s) created on ${result.targetAgentId}; ` +
+        `${failed.length} skill(s) failed` +
+        (overCap.length > 0
+            ? `; ${overCap.length} skill(s) imported without an action because the action library is full.`
+            : '.');
+    return {
+        rows,
+        summary,
+        failed: failed.length > 0 || overCap.length > 0 || Boolean(result.actionsError),
+    };
+}

package/dist/lib/task-closure.d.ts

@@ -28,6 +28,19 @@ export type ClosureLike = TaskClosureEvaluation | {
  * the whole point is to be able to act without a second lookup.
  */
 export declare function closureReport(closure: ClosureLike): string[];
+/**
+ * The ways forward when a closed Task refuses a Result (`TASK_REOPEN_REQUIRED`).
+ *
+ * Both writers reach this refusal, `tasks result submit` and `tasks complete`,
+ * so both print from here. The first version sat in `result submit` alone and
+ * offered `tasks complete` as a way around it, which the same refusal stops:
+ * every step named here has to work on a closed Task (OSK-10031).
+ */
+export declare function reopenRequiredLines({ bin, task, command, }: {
+    bin: string;
+    task: string;
+    command: 'result submit' | 'complete';
+}): string[];
 /** `met (agent)` vs `met (person)` — shared with the web through data-provider. */
 export { describeAssessorKind as describeAssessor } from '@skrr-ai/data-provider';
 export { describeClosure as closureSnapshotLines, type TaskClosureSnapshot as ClosureSnapshot, } from '@skrr-ai/data-provider';