@skrr-ai/cli 0.1.104 → 0.1.106

package/dist/commands/daemon/logs.d.ts

@@ -19,6 +19,7 @@ export interface DaemonLogsFlags {
     stderr?: boolean;
     path?: boolean;
     profile?: string;
+    rotated?: boolean;
 }
 /**
  * Older daemons already kept logs in this profile-scoped location, even
@@ -116,6 +117,69 @@ export declare function resolveForwardedLogPath(flags: Pick<DaemonLogsFlags, 'st
  * forwarding to the bug, so the CLI forwards only at or above this version.
  */
 export declare const LIVE_LOG_RESOLUTION_RUNTIME_VERSION = "0.8.119";
+/**
+ * The first runtime whose `logs` knows `--rotated` (OSK-16214). An older one
+ * rejects it as an unknown option, so the CLI never forwards the flag below
+ * this version: it asks the runtime which file it reads (`--path`) and reads
+ * that file and its rotated siblings itself.
+ */
+export declare const ROTATED_LOGS_RUNTIME_VERSION = "0.8.120";
+/**
+ * The first runtime whose `logs --rotated --lines N` says where a window that
+ * cut older lines starts, and whose `logs --path` names the rotated siblings
+ * on stderr (OSK-16228). 0.8.120 knows `--rotated` but says neither, so for it
+ * the CLI reads the files itself, exactly as it does for an older runtime.
+ */
+export declare const ROTATED_WINDOW_NOTE_RUNTIME_VERSION = "0.8.121";
+/**
+ * Rotated siblings of a log, OLDEST FIRST (OSK-16214). The daemon's logger
+ * renames `daemon.app.log` to `daemon.app.1.log`, `.1` to `.2` and so on at
+ * 10 MB (`daemon/src/logger.ts` `maybeRotate`), and `logs` never reached them —
+ * `--lines 5000 | grep <run id>` found nothing while `daemon.app.1.log` held the
+ * run. A copy of `daemon/src/rotated-log-files.ts`, for runtimes that predate
+ * `--rotated`. Never throws.
+ */
+export declare function rotatedLogSiblings(filePath: string, readdir?: (dir: string) => string[]): string[];
+/** The sentence shown when rotated siblings hold older lines the view leaves out. */
+export declare function describeRotatedSiblings(filePath: string, siblings: readonly string[]): string | null;
+/**
+ * The last `maxLines` lines of one file, read backwards in chunks so the cost
+ * follows the lines asked for, not the file's size. Bytes are decoded once, so
+ * a multi-byte character split across a chunk boundary survives.
+ */
+export declare function readLastLines(filePath: string, maxLines: number): string[];
+/**
+ * The last `maxLines` lines across `files` (OLDEST FIRST) as if they were one
+ * file. A file renamed away between the listing and the read is skipped.
+ */
+export declare function readLastLinesAcross(files: readonly string[], maxLines: number): string[];
+/**
+ * Where a `--rotated --lines N` window began when it left older lines out
+ * (OSK-16228). `startLine` is 1-based within `file`; `totalLines` counts the
+ * whole set. A copy of `daemon/src/rotated-log-files.ts`, like the helpers above.
+ */
+export interface LogWindowCut {
+    file: string;
+    startLine: number;
+    totalLines: number;
+}
+/** Lines in a file, split as `readLastLines` splits them; read in chunks. */
+export declare function countLines(filePath: string): number;
+/**
+ * `readLastLinesAcross`, plus where the window began when it cut older lines.
+ * Without it, `--rotated --lines 20000 | grep <id>` for an id 90k lines back
+ * printed nothing and said nothing, which reads as "never logged". Lines are
+ * counted only once the window is full, and only from the file it stopped in
+ * back.
+ */
+export declare function readLogWindow(files: readonly string[], maxLines: number): {
+    lines: string[];
+    cut: LogWindowCut | null;
+};
+/** The stderr sentence for a window that left older lines out. */
+export declare function describeLogWindowCut(cut: LogWindowCut, shown: number): string;
+/** Every byte of `files`, in order, to `out` — streamed, honouring back-pressure. */
+export declare function streamLogFiles(files: readonly string[], out: NodeJS.WritableStream): Promise<void>;
 /** `x.y.z` from a version string, or null. A prerelease suffix is ignored. */
 export declare function parseRuntimeVersion(text: string): [number, number, number] | null;
 /** Whether `version` is at least `floor`; null when either is not a version. */
@@ -130,8 +194,11 @@ export declare function probeRuntimeVersion(capture?: typeof execRuntimeBinaryCa
  */
 export declare function probeStatusLogPath(flags: Pick<DaemonLogsFlags, 'profile'>, capture?: typeof execRuntimeBinaryCapture): Promise<string | null>;
 /** What `skrr daemon logs` does: forward to the runtime, or read a file itself. */
-export type DaemonLogsPlan = {
+export type DaemonLogsPlan = 
+/** `runtimeVersion` decides whether a flag newer than 0.8.119 may be forwarded. */
+{
     kind: 'forward';
+    runtimeVersion: string | null;
 }
 /** `note` goes to stderr before any log content; never printed for `--path`. */
  | {
@@ -171,13 +238,15 @@ export declare function readDaemonLogTail(filePath: string, maxLines: number): s
  * or it parses successfully and is then silently dropped.
  */
 export declare function buildDaemonLogsArgs(flags: DaemonLogsFlags): string[];
+/** `--stderr` help, word for word the runtime's own (`daemon/src/index.ts`). */
+export declare const STDERR_FLAG_DESCRIPTION = "Read the daemon's raw stderr instead of its log: the file its installed service redirects stderr to, or the profile's daemon.err.log. A daemon started with --log-file by anything else has no known stderr file, so its live log (which carries every WARN and ERROR) is shown instead, with a note";
 export default class DaemonLogs extends Command {
     static aliases: string[];
     static description: string;
     /**
-     * Mirrors the four options `oversky logs` actually implements
+     * Mirrors the options `oversky logs` actually implements
      * (`daemon/src/index.ts` — `-n/--lines`, `-f/--follow`, `--stderr`,
-     * `--path`). Typed flags are deliberate — they give `skrr daemon logs --help`
+     * `--path`, and since 0.8.120 `--rotated`). Typed flags are deliberate — they give `skrr daemon logs --help`
      * something real to print, which raw `strict = false` passthrough never did.
      * The trade is that anything NOT declared here becomes unreachable, so this
      * list has to stay in step with the daemon command.
@@ -187,6 +256,7 @@ export default class DaemonLogs extends Command {
         lines: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         stderr: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         path: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        rotated: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         profile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     static examples: string[];

package/dist/commands/daemon/logs.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION = void 0;
+exports.STDERR_FLAG_DESCRIPTION = exports.ROTATED_WINDOW_NOTE_RUNTIME_VERSION = exports.ROTATED_LOGS_RUNTIME_VERSION = exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION = void 0;
 exports.describeLogAge = describeLogAge;
 exports.resolveLegacyDaemonLogPath = resolveLegacyDaemonLogPath;
 exports.resolveDaemonLogsProfile = resolveDaemonLogsProfile;
@@ -11,6 +11,14 @@ exports.installedServiceLogDestinations = installedServiceLogDestinations;
 exports.installedServiceLogCandidates = installedServiceLogCandidates;
 exports.chooseLegacyFallbackLog = chooseLegacyFallbackLog;
 exports.resolveForwardedLogPath = resolveForwardedLogPath;
+exports.rotatedLogSiblings = rotatedLogSiblings;
+exports.describeRotatedSiblings = describeRotatedSiblings;
+exports.readLastLines = readLastLines;
+exports.readLastLinesAcross = readLastLinesAcross;
+exports.countLines = countLines;
+exports.readLogWindow = readLogWindow;
+exports.describeLogWindowCut = describeLogWindowCut;
+exports.streamLogFiles = streamLogFiles;
 exports.parseRuntimeVersion = parseRuntimeVersion;
 exports.runtimeVersionAtLeast = runtimeVersionAtLeast;
 exports.probeRuntimeVersion = probeRuntimeVersion;
@@ -22,6 +30,7 @@ const core_1 = require("@oclif/core");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
+const node_events_1 = require("node:events");
 const exec_runtime_binary_1 = require("../../lib/exec-runtime-binary");
 const MAX_FALLBACK_LOG_BYTES = 1024 * 1024;
 const PROFILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
@@ -188,7 +197,9 @@ function chooseLegacyFallbackLog(args) {
  */
 async function resolveForwardedLogPath(flags, capture = exec_runtime_binary_1.execRuntimeBinaryCapture) {
     try {
-        const out = await capture(buildDaemonLogsArgs({ ...flags, path: true }), {
+        // Only what decides the file: --rotated would list siblings first, and the
+        // last line is still the current file, but there is no reason to ask.
+        const out = await capture(buildDaemonLogsArgs({ stderr: flags.stderr, profile: flags.profile, path: true }), {
             timeoutMs: 5_000,
         });
         if (out.code !== 0)
@@ -213,6 +224,197 @@ async function resolveForwardedLogPath(flags, capture = exec_runtime_binary_1.ex
  * forwarding to the bug, so the CLI forwards only at or above this version.
  */
 exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION = '0.8.119';
+/**
+ * The first runtime whose `logs` knows `--rotated` (OSK-16214). An older one
+ * rejects it as an unknown option, so the CLI never forwards the flag below
+ * this version: it asks the runtime which file it reads (`--path`) and reads
+ * that file and its rotated siblings itself.
+ */
+exports.ROTATED_LOGS_RUNTIME_VERSION = '0.8.120';
+/**
+ * The first runtime whose `logs --rotated --lines N` says where a window that
+ * cut older lines starts, and whose `logs --path` names the rotated siblings
+ * on stderr (OSK-16228). 0.8.120 knows `--rotated` but says neither, so for it
+ * the CLI reads the files itself, exactly as it does for an older runtime.
+ */
+exports.ROTATED_WINDOW_NOTE_RUNTIME_VERSION = '0.8.121';
+/**
+ * Rotated siblings of a log, OLDEST FIRST (OSK-16214). The daemon's logger
+ * renames `daemon.app.log` to `daemon.app.1.log`, `.1` to `.2` and so on at
+ * 10 MB (`daemon/src/logger.ts` `maybeRotate`), and `logs` never reached them —
+ * `--lines 5000 | grep <run id>` found nothing while `daemon.app.1.log` held the
+ * run. A copy of `daemon/src/rotated-log-files.ts`, for runtimes that predate
+ * `--rotated`. Never throws.
+ */
+function rotatedLogSiblings(filePath, readdir = (dir) => (0, node_fs_1.readdirSync)(dir)) {
+    const dir = node_path_1.default.dirname(filePath);
+    const ext = node_path_1.default.extname(filePath);
+    const base = node_path_1.default.basename(filePath, ext);
+    const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`^${escape(base)}\\.(\\d+)${escape(ext)}$`);
+    let names;
+    try {
+        names = readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    return names
+        .map((name) => ({ name, index: Number(pattern.exec(name)?.[1] ?? NaN) }))
+        .filter(({ index }) => Number.isSafeInteger(index) && index >= 1)
+        .sort((a, b) => b.index - a.index)
+        .map(({ name }) => node_path_1.default.join(dir, name));
+}
+/** The sentence shown when rotated siblings hold older lines the view leaves out. */
+function describeRotatedSiblings(filePath, siblings) {
+    if (siblings.length === 0)
+        return null;
+    const names = siblings.map((s) => node_path_1.default.basename(s));
+    const listed = names.length === 1 ? names[0] : `${names.at(-1)} … ${names[0]}`;
+    return (`Older lines are in ${siblings.length} rotated file${siblings.length === 1 ? '' : 's'} ` +
+        `beside ${filePath} (${listed}). Add --rotated to read them too, oldest first.`);
+}
+/**
+ * The last `maxLines` lines of one file, read backwards in chunks so the cost
+ * follows the lines asked for, not the file's size. Bytes are decoded once, so
+ * a multi-byte character split across a chunk boundary survives.
+ */
+function readLastLines(filePath, maxLines) {
+    if (maxLines <= 0)
+        return [];
+    const { size } = (0, node_fs_1.statSync)(filePath);
+    const descriptor = (0, node_fs_1.openSync)(filePath, 'r');
+    try {
+        let start = size;
+        const chunks = [];
+        let newlines = 0;
+        while (start > 0 && newlines <= maxLines) {
+            const length = Math.min(64 * 1024, start);
+            start -= length;
+            const buffer = Buffer.alloc(length);
+            (0, node_fs_1.readSync)(descriptor, buffer, 0, length, start);
+            chunks.unshift(buffer);
+            for (const byte of buffer)
+                if (byte === 0x0a)
+                    newlines += 1;
+        }
+        const lines = Buffer.concat(chunks).toString('utf8').split('\n');
+        if (lines.at(-1) === '')
+            lines.pop();
+        if (start > 0)
+            lines.shift();
+        return lines.slice(-maxLines);
+    }
+    finally {
+        (0, node_fs_1.closeSync)(descriptor);
+    }
+}
+/**
+ * The last `maxLines` lines across `files` (OLDEST FIRST) as if they were one
+ * file. A file renamed away between the listing and the read is skipped.
+ */
+function readLastLinesAcross(files, maxLines) {
+    return readLogWindow(files, maxLines).lines;
+}
+/** Lines in a file, split as `readLastLines` splits them; read in chunks. */
+function countLines(filePath) {
+    const descriptor = (0, node_fs_1.openSync)(filePath, 'r');
+    try {
+        const buffer = Buffer.alloc(64 * 1024);
+        let count = 0;
+        let last = -1;
+        let position = 0;
+        for (;;) {
+            const read = (0, node_fs_1.readSync)(descriptor, buffer, 0, buffer.length, position);
+            if (read === 0)
+                break;
+            position += read;
+            for (let i = 0; i < read; i += 1)
+                if (buffer[i] === 0x0a)
+                    count += 1;
+            last = buffer[read - 1];
+        }
+        return last === -1 || last === 0x0a ? count : count + 1;
+    }
+    finally {
+        (0, node_fs_1.closeSync)(descriptor);
+    }
+}
+/**
+ * `readLastLinesAcross`, plus where the window began when it cut older lines.
+ * Without it, `--rotated --lines 20000 | grep <id>` for an id 90k lines back
+ * printed nothing and said nothing, which reads as "never logged". Lines are
+ * counted only once the window is full, and only from the file it stopped in
+ * back.
+ */
+function readLogWindow(files, maxLines) {
+    const collected = [];
+    let remaining = maxLines;
+    let boundary = null;
+    for (let i = files.length - 1; i >= 0 && remaining > 0; i -= 1) {
+        try {
+            const lines = readLastLines(files[i], remaining);
+            collected.unshift(lines);
+            remaining -= lines.length;
+            if (remaining <= 0)
+                boundary = { index: i, taken: lines.length };
+        }
+        catch {
+            // Rotated away mid-read; the rest are still worth showing.
+        }
+    }
+    const lines = collected.flat();
+    if (boundary === null)
+        return { lines, cut: null };
+    let boundaryLines;
+    try {
+        boundaryLines = countLines(files[boundary.index]);
+    }
+    catch {
+        return { lines, cut: null };
+    }
+    let olderLines = 0;
+    for (const file of files.slice(0, boundary.index)) {
+        try {
+            olderLines += countLines(file);
+        }
+        catch {
+            // Rotated away since the read; it is not in the window either way.
+        }
+    }
+    const startLine = Math.max(1, boundaryLines - boundary.taken + 1);
+    if (startLine === 1 && olderLines === 0)
+        return { lines, cut: null };
+    return {
+        lines,
+        cut: {
+            file: files[boundary.index],
+            startLine,
+            totalLines: olderLines + (startLine - 1) + lines.length,
+        },
+    };
+}
+/** The stderr sentence for a window that left older lines out. */
+function describeLogWindowCut(cut, shown) {
+    return (`Showing the last ${shown} of ${cut.totalLines} lines; the window starts at line ` +
+        `${cut.startLine} of ${node_path_1.default.basename(cut.file)}. Drop --lines to read the full history.`);
+}
+/** Every byte of `files`, in order, to `out` — streamed, honouring back-pressure. */
+async function streamLogFiles(files, out) {
+    for (const file of files) {
+        try {
+            for await (const chunk of (0, node_fs_1.createReadStream)(file)) {
+                if (!out.write(chunk))
+                    await (0, node_events_1.once)(out, 'drain');
+            }
+        }
+        catch (err) {
+            if (err?.code === 'ENOENT')
+                continue;
+            throw err;
+        }
+    }
+}
 /** `x.y.z` from a version string, or null. A prerelease suffix is ignored. */
 function parseRuntimeVersion(text) {
     const m = /(\d+)\.(\d+)\.(\d+)/.exec(text);
@@ -300,13 +502,13 @@ async function planDaemonLogs(flags, deps) {
     }
     // Help could not be read: nothing to go on, keep the old behaviour.
     if (supports === null)
-        return { kind: 'forward' };
+        return { kind: 'forward', runtimeVersion: null };
     const version = await deps.runtimeVersion();
     const current = version
         ? runtimeVersionAtLeast(version, exports.LIVE_LOG_RESOLUTION_RUNTIME_VERSION)
         : null;
     if (current === true)
-        return { kind: 'forward' };
+        return { kind: 'forward', runtimeVersion: version };
     const live = await deps.statusLogPath();
     const predates = version !== null
         ? `The installed runtime (${version}) predates \`logs\` following the live daemon's ` +
@@ -315,12 +517,12 @@ async function planDaemonLogs(flags, deps) {
             `${deps.profilePath} instead of the live log.`;
     if (!live) {
         if (current === null)
-            return { kind: 'forward' };
+            return { kind: 'forward', runtimeVersion: version };
         return legacy(`${predates} Its \`status\` did not name the live log either.`);
     }
     // The live daemon writes the profile log itself: the runtime's answer is right.
     if (sameLogFile(live, node_path_1.default.join(node_path_1.default.dirname(deps.profilePath), 'daemon.log'))) {
-        return { kind: 'forward' };
+        return { kind: 'forward', runtimeVersion: version };
     }
     const missingHint = 'The live daemon has not written it yet; `skrr daemon status` shows whether one is running.';
     if (!flags.stderr) {
@@ -391,8 +593,13 @@ function buildDaemonLogsArgs(flags) {
         ...(flags.lines !== undefined ? ['--lines', String(flags.lines)] : []),
         ...(flags.stderr ? ['--stderr'] : []),
         ...(flags.path ? ['--path'] : []),
+        // Only ever reached for a runtime at ROTATED_LOGS_RUNTIME_VERSION or later;
+        // `run` reads the files itself for an older one.
+        ...(flags.rotated ? ['--rotated'] : []),
     ];
 }
+/** `--stderr` help, word for word the runtime's own (`daemon/src/index.ts`). */
+exports.STDERR_FLAG_DESCRIPTION = "Read the daemon's raw stderr instead of its log: the file its installed service redirects stderr to, or the profile's daemon.err.log. A daemon started with --log-file by anything else has no known stderr file, so its live log (which carries every WARN and ERROR) is shown instead, with a note";
 class DaemonLogs extends core_1.Command {
     // `skrr daemons <sub>` — the plural is advertised as an alias for the
     // whole topic, and without a per-command alias only the bare topic
@@ -400,9 +607,9 @@ class DaemonLogs extends core_1.Command {
     static aliases = ['daemons:logs'];
     static description = 'Tail or print recent skrr daemon logs';
     /**
-     * Mirrors the four options `oversky logs` actually implements
+     * Mirrors the options `oversky logs` actually implements
      * (`daemon/src/index.ts` — `-n/--lines`, `-f/--follow`, `--stderr`,
-     * `--path`). Typed flags are deliberate — they give `skrr daemon logs --help`
+     * `--path`, and since 0.8.120 `--rotated`). Typed flags are deliberate — they give `skrr daemon logs --help`
      * something real to print, which raw `strict = false` passthrough never did.
      * The trade is that anything NOT declared here becomes unreachable, so this
      * list has to stay in step with the daemon command.
@@ -414,17 +621,26 @@ class DaemonLogs extends core_1.Command {
         }),
         lines: core_1.Flags.integer({
             char: 'n',
-            description: 'Number of recent log lines to print',
+            description: 'Number of recent log lines to print (default 200; every line with --rotated)',
             // `oversky logs` validates `>= 0`; keep the two in step so `-n 0` is not
             // rejected here only to be accepted there.
             min: 0,
         }),
+        // OSK-16213: this said "daemon.err.log — every WARN and ERROR". Since
+        // OSK-15993 it is the process's raw stderr as the service redirects it
+        // (`planDaemonLogs` here, `resolveDaemonLogTarget` in the runtime), and a
+        // structured --log-file is what carries WARN and ERROR. The runtime's own
+        // `--stderr` help says the same words; logs.spec.ts compares the two.
         stderr: core_1.Flags.boolean({
-            description: 'Read daemon.err.log — every WARN and ERROR — instead of daemon.log',
+            description: exports.STDERR_FLAG_DESCRIPTION,
         }),
         path: core_1.Flags.boolean({
             description: 'Print the resolved log file path and exit',
         }),
+        // OSK-16214: the rotated files (`daemon.app.1.log` …) were unreachable.
+        rotated: core_1.Flags.boolean({
+            description: 'Include the rotated files (daemon.app.1.log …) before the current one, oldest first; with --path, list them all',
+        }),
         // Every other daemon verb reaches a non-default profile with --profile; this
         // one could only be steered by OVERSKY_PROFILE (OSK-10001).
         profile: core_1.Flags.string({
@@ -438,6 +654,7 @@ class DaemonLogs extends core_1.Command {
         '<%= config.bin %> daemon logs --lines 500',
         '<%= config.bin %> daemon logs --stderr',
         '<%= config.bin %> daemon logs --path',
+        '<%= config.bin %> daemon logs --rotated | grep arun_',
         '<%= config.bin %> daemon logs --profile dogfood-laptop --lines 50',
     ];
     async run() {
@@ -466,7 +683,7 @@ class DaemonLogs extends core_1.Command {
             // with it — 0.8.112–0.8.118 read the profile log even when the live
             // daemon writes elsewhere. `planDaemonLogs` forwards only to a runtime
             // that resolves the live log itself.
-            const plan = await planDaemonLogs(flags, {
+            let plan = await planDaemonLogs(flags, {
                 supportsLogs: () => (0, exec_runtime_binary_1.runtimeBinarySupportsSubcommand)('logs'),
                 runtimeVersion: () => probeRuntimeVersion(),
                 statusLogPath: () => probeStatusLogPath(flags),
@@ -481,22 +698,84 @@ class DaemonLogs extends core_1.Command {
                     }
                 },
             });
+            // OSK-16214: `--rotated` is new in ROTATED_LOGS_RUNTIME_VERSION, and an
+            // older runtime rejects it as an unknown option. Its `--path` is still
+            // the live-aware answer, so read that file and its siblings here.
+            const runtimeKnowsRotated = plan.kind === 'forward' &&
+                plan.runtimeVersion !== null &&
+                runtimeVersionAtLeast(plan.runtimeVersion, exports.ROTATED_LOGS_RUNTIME_VERSION) === true;
+            // OSK-16228: a `--rotated --lines N` window that cuts older lines, and
+            // `--path` with rotated siblings beside it, are said on stderr only from
+            // ROTATED_WINDOW_NOTE_RUNTIME_VERSION. Below it, read the files here.
+            const runtimeSaysWindow = plan.kind === 'forward' &&
+                plan.runtimeVersion !== null &&
+                runtimeVersionAtLeast(plan.runtimeVersion, exports.ROTATED_WINDOW_NOTE_RUNTIME_VERSION) === true;
+            if (plan.kind === 'forward' && !runtimeSaysWindow && (flags.rotated || flags.path)) {
+                const resolved = await resolveForwardedLogPath(flags);
+                if (resolved) {
+                    plan = {
+                        kind: 'read',
+                        path: resolved,
+                        note: null,
+                        missingHint: 'The live daemon has not written it yet; `skrr daemon status` shows whether one is running.',
+                    };
+                }
+                else if (flags.rotated && !runtimeKnowsRotated) {
+                    this.error(`The installed runtime${plan.runtimeVersion ? ` (${plan.runtimeVersion})` : ''} predates ` +
+                        `--rotated (${exports.ROTATED_LOGS_RUNTIME_VERSION}) and did not name its log file, so its ` +
+                        'rotated files cannot be found. Upgrade it (`skrr daemon update`), or list the ' +
+                        'directory `skrr daemon logs --path` prints.', { exit: 1 });
+                }
+                // Otherwise forward: the runtime still answers, just without the note.
+            }
             if (plan.kind === 'read') {
                 const logPath = plan.path;
-                // `--path` prints the one path and nothing else, on either stream.
+                const siblings = rotatedLogSiblings(logPath);
+                // `--path` prints the one path and nothing else on stdout — under
+                // --rotated, every file oldest first, the current one last. Without
+                // --rotated, stderr names the siblings a grep of that path would miss
+                // (OSK-16228).
                 if (flags.path) {
+                    for (const file of flags.rotated ? siblings : [])
+                        this.log(file);
                     this.log(logPath);
+                    if (!flags.rotated) {
+                        const hint = describeRotatedSiblings(logPath, siblings);
+                        if (hint)
+                            this.logToStderr(hint);
+                    }
                     return;
                 }
                 if (plan.note)
                     this.logToStderr(plan.note);
+                if (flags.rotated && siblings.length === 0) {
+                    this.logToStderr(`No rotated files beside ${logPath}.`);
+                }
+                else if (!flags.rotated) {
+                    const hint = describeRotatedSiblings(logPath, siblings);
+                    if (hint)
+                        this.logToStderr(hint);
+                }
                 showAge(logPath);
                 if (!(0, node_fs_1.existsSync)(logPath)) {
                     this.error(`No daemon log at ${logPath}. ${plan.missingHint}`, { exit: 1 });
                 }
-                const lines = readDaemonLogTail(logPath, flags.lines ?? 200);
-                if (lines.length > 0)
-                    this.log(lines.join('\n'));
+                if (flags.rotated && flags.lines === undefined) {
+                    // Every line of every file, streamed rather than held whole.
+                    await streamLogFiles([...siblings, logPath], process.stdout);
+                }
+                else {
+                    const window = flags.rotated
+                        ? readLogWindow([...siblings, logPath], flags.lines ?? 200)
+                        : null;
+                    const lines = window ? window.lines : readDaemonLogTail(logPath, flags.lines ?? 200);
+                    if (lines.length > 0)
+                        this.log(lines.join('\n'));
+                    // OSK-16228: after the content, so it is the last thing a terminal
+                    // shows, and on stderr, so a grep over stdout is unchanged.
+                    if (window?.cut)
+                        this.logToStderr(describeLogWindowCut(window.cut, lines.length));
+                }
                 if (flags.follow) {
                     let position = (0, node_fs_1.statSync)(logPath).size;
                     (0, node_fs_1.watchFile)(logPath, { interval: 500 }, () => {
@@ -528,8 +807,16 @@ class DaemonLogs extends core_1.Command {
             }
             // The banner must describe the file the runtime will actually print —
             // the live daemon's log (OSK-15993) — not the profile default.
-            if (!flags.path)
-                showAge(await resolveForwardedLogPath(flags));
+            if (!flags.path) {
+                const forwardedPath = await resolveForwardedLogPath(flags);
+                // A runtime that knows --rotated says this itself; an older one cannot.
+                if (!runtimeKnowsRotated && forwardedPath) {
+                    const hint = describeRotatedSiblings(forwardedPath, rotatedLogSiblings(forwardedPath));
+                    if (hint)
+                        this.logToStderr(hint);
+                }
+                showAge(forwardedPath);
+            }
             const code = await (0, exec_runtime_binary_1.execRuntimeBinary)(args);
             this.exit(code);
         }

package/dist/commands/followups/act.js

@@ -23,7 +23,10 @@ class FollowupsAct extends base_command_1.BaseCommand {
             required: true,
         }),
         at: core_1.Flags.string({ description: 'ISO-8601 instant to act at', exclusive: ['in'] }),
-        in: core_1.Flags.string({ description: 'Duration from now (2h, 3d)', exclusive: ['at'] }),
+        in: core_1.Flags.string({
+            description: 'Duration from now (2h, 3d), between 1m and 30d',
+            exclusive: ['at'],
+        }),
         agent: core_1.Flags.string({ description: 'Agent ID (default: bound session agent)' }),
         endpoint: core_1.Flags.string({ description: 'Delivery endpoint id (EndpointRegistry)' }),
         'endpoint-target': core_1.Flags.string({ description: 'Channel target for channel endpoints' }),
@@ -42,6 +45,15 @@ class FollowupsAct extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
+        const problem = (0, followups_1.whenFlagProblem)(flags.at ? 'at' : 'in', at);
+        if (problem) {
+            this.failWithCliError({
+                message: problem,
+                code: 'FOLLOWUP_INVALID_FIELD',
+                exit: 2,
+                retryable: false,
+            });
+        }
         const action = (0, triggers_1.parseJsonObject)(flags.action, '--action');
         if (typeof action?.builtinType !== 'string' || !action.builtinType) {
             this.failWithCliError({

package/dist/commands/followups/checkin.js

@@ -23,7 +23,7 @@ class FollowupsCheckin extends base_command_1.BaseCommand {
         subject: core_1.Flags.string({ description: followups_1.FOLLOWUP_SUBJECT_FLAG_HELP, required: true }),
         why: core_1.Flags.string({ description: 'Why this wake exists, in one line', required: true }),
         in: core_1.Flags.string({
-            description: 'Duration from now (90m, 2h) — the once form',
+            description: 'Duration from now (90m, 2h), between 1m and 30d — the once form',
             exclusive: ['frequency'],
         }),
         frequency: core_1.Flags.string({
@@ -64,6 +64,15 @@ class FollowupsCheckin extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
+        const problem = (0, followups_1.whenFlagProblem)('in', flags.in);
+        if (problem) {
+            this.failWithCliError({
+                message: problem,
+                code: 'FOLLOWUP_INVALID_FIELD',
+                exit: 2,
+                retryable: false,
+            });
+        }
         let agent;
         try {
             agent = (0, followups_1.resolveFollowUpAgent)(flags.agent);
@@ -106,7 +115,7 @@ class FollowupsCheckin extends base_command_1.BaseCommand {
         if (response.dropped && producer === 'user_explicit') {
             this.failWithCliError({
                 message: budgetRefusalMessage(agent.id, response.budget),
-                code: 'FOLLOWUP_BUDGET_EXHAUSTED',
+                code: 'FOLLOWUP_BUDGET_EXCEEDED',
                 exit: 1,
                 retryable: false,
                 details: { budget: response.budget ?? null, response },

package/dist/commands/followups/reschedule.js

@@ -15,7 +15,10 @@ class FollowupsReschedule extends base_command_1.BaseCommand {
     };
     static flags = {
         at: core_1.Flags.string({ description: 'New instant (ISO-8601)', exclusive: ['in'] }),
-        in: core_1.Flags.string({ description: 'New offset from now (90m, 2h)', exclusive: ['at'] }),
+        in: core_1.Flags.string({
+            description: 'New offset from now (90m, 2h); between 1m and 30d',
+            exclusive: ['at'],
+        }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
     };
     async run() {
@@ -30,6 +33,15 @@ class FollowupsReschedule extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
+        const problem = (0, followups_1.whenFlagProblem)(flags.at ? 'at' : 'in', at);
+        if (problem) {
+            this.failWithCliError({
+                message: problem,
+                code: 'FOLLOWUP_INVALID_FIELD',
+                exit: 2,
+                retryable: false,
+            });
+        }
         let result;
         try {
             result = (await followups_1.followupsApi.reschedule(args.id, { at }));

package/dist/commands/proposals/discard.d.ts

@@ -3,7 +3,7 @@ export default class ProposalsDiscard extends ProposalDecisionCommand {
     static description: string;
     static args: {
         kind: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
-        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        id: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static decision: "discard";
 }