@skrr-ai/cli 0.1.10 → 0.1.11

package/dist/commands/tasks/update.js

@@ -7,6 +7,7 @@ const web_url_1 = require("../../lib/web-url");
 const prompt_1 = require("../../lib/prompt");
 const task_resolver_1 = require("../../lib/task-resolver");
 const tasks_1 = require("../../lib/tasks");
+const create_1 = require("./create");
 class TasksUpdate extends base_command_1.BaseCommand {
     static description = 'Update an existing task (partial patch). Status and PROJECT changes go through ' +
         '`tasks move` — see `--goal` / `--space` below.';
@@ -51,7 +52,34 @@ class TasksUpdate extends base_command_1.BaseCommand {
         }),
         'start-date': core_1.Flags.string({ description: 'New planned start date (ISO string)' }),
         'due-date': core_1.Flags.string({ description: 'New due date (ISO string)' }),
-        estimate: core_1.Flags.integer({ description: 'New estimate value from the Space estimate scale' }),
+        estimate: core_1.Flags.integer({
+            description: 'New estimate value from the Space estimate scale. Requires a scale on the Space (or an ' +
+                'ancestor it inherits from); with none set, the server drops the value. Set the scale ' +
+                'in the web UI — no CLI command configures it.',
+        }),
+        /**
+         * Declared, hidden, and refused — on purpose. (S4 dogfood finding)
+         *
+         * `--status` is the single most likely flag a person types at `tasks
+         * update`, and undeclared it produced oclif's `Nonexistent flag: --status`
+         * followed by a ~160-line dump of this command's help. The answer is in
+         * that dump — this command's own description says status changes go through
+         * `tasks move` — buried under thirty other flags.
+         *
+         * Declaring it routes `--status` past the parser and into
+         * `taskUpdateMutationGuard`, which already refuses a `status` key arriving
+         * via `--from-json` with the exact sentence naming `tasks move`. So the two
+         * ways of asking for the same wrong thing now get the same right answer,
+         * the same `TASK_STATUS_REQUIRES_MOVE` code in `--json`, and no help dump —
+         * and the copy has ONE home rather than a second parallel string.
+         *
+         * `hidden` because it is not a capability: help must not advertise a flag
+         * whose only behaviour is to explain itself.
+         */
+        status: core_1.Flags.string({
+            hidden: true,
+            description: 'Not supported here — status changes go through `tasks move`.',
+        }),
         'duplicate-of': core_1.Flags.string({
             description: 'Mark this task as a duplicate of the canonical task (merges collaboration)',
         }),
@@ -178,6 +206,10 @@ class TasksUpdate extends base_command_1.BaseCommand {
             startDate: flags['start-date'],
             dueDate: flags['due-date'],
             estimate: flags.estimate,
+            // Never sent: `taskUpdateMutationGuard` refuses any payload carrying
+            // `status` before the request is built. It is merged in only so the guard
+            // sees it and answers with the sentence that names `tasks move`.
+            status: flags.status,
             duplicateOfId: flags['duplicate-of'],
             goalId: flags.goal,
             cycleId: flags.cycle,
@@ -258,6 +290,11 @@ class TasksUpdate extends base_command_1.BaseCommand {
         catch (err) {
             this.handleApiError(err);
         }
+        // Postcondition, not a prediction — see `droppedEstimateWarning`. On stderr
+        // so `--json` stdout stays a parseable task row.
+        const estimateWarning = (0, create_1.droppedEstimateWarning)(flags.estimate, updated, updated?.spaceId);
+        if (estimateWarning)
+            this.warn(estimateWarning);
         if (flags.json) {
             this.log(JSON.stringify((0, web_url_1.withTaskUrl)(this.cliConfig.baseURL, updated), null, 2));
             return;

package/dist/commands/whoami.d.ts

@@ -13,3 +13,43 @@ export default class Whoami extends BaseCommand {
     };
     run(): Promise<void>;
 }
+export type WhoamiWorkspace = {
+    id?: string;
+    name?: string;
+    source: 'api' | 'selection';
+} | null;
+/**
+ * What the `Workspace` row says — including when there isn't one. (OSK-322)
+ *
+ * `whoami` printed a bare `-` here, and a dash is read as "you have none".
+ * That is the wrong conclusion: an unset workspace does not mean requests go
+ * nowhere, it means they resolve to the account's default. `skrr context`
+ * already words the same field correctly, so the sentence below is deliberately
+ * ITS sentence, not a second one — the two commands answer the same question
+ * and must not answer it differently.
+ *
+ * (It is duplicated rather than shared because the wording lives inline in
+ * `commands/context.ts`; the right home for both is `lib/`, which is a wider
+ * change than this fix.)
+ */
+export declare function describeWhoamiWorkspace(workspace: WhoamiWorkspace): string;
+/**
+ * What the `Daemon ID` row says — including when there isn't one. (OSK-322)
+ *
+ * The field was ambiguous between two different questions, and the dogfood
+ * report shows the damage: `whoami` printed `Daemon ID: -` on a machine whose
+ * daemon `skrr daemon status` reported as bound, live and cloud-connected, so
+ * the reader concluded they had no daemon.
+ *
+ * The decision, stated here once: **`daemonId` is the daemon THIS CREDENTIAL
+ * represents, never the daemon running on this machine.** `whoami` is a
+ * credential report — every other row (token source, kind, expiry, refresh,
+ * at-rest encryption) describes the credential — so this row has to as well.
+ * A CLI credential authenticates a person, so the answer is always "none", and
+ * that is a fact rather than a missing lookup.
+ *
+ * The machine's daemon is a genuinely different subject with its own command,
+ * so the row names it instead of leaving the reader to guess which reading
+ * applies.
+ */
+export declare function describeWhoamiDaemon(daemonId: string | null): string;

package/dist/commands/whoami.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeWhoamiWorkspace = describeWhoamiWorkspace;
+exports.describeWhoamiDaemon = describeWhoamiDaemon;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const auth_core_1 = require("@skrr-ai/auth-core");
@@ -82,6 +84,9 @@ class Whoami extends base_command_1.BaseCommand {
             : selectedId
                 ? { id: selectedId, source: 'selection' }
                 : null;
+        // Always null here, and that is the ANSWER rather than a gap: see
+        // `describeWhoamiDaemon` for what this field means and why a CLI
+        // credential can never carry one.
         const daemonId = null;
         const payload = {
             account: {
@@ -121,15 +126,10 @@ class Whoami extends base_command_1.BaseCommand {
         this.log(`Role:           ${user.role || '-'}`);
         this.log(`Provider:       ${user.provider || '-'}`);
         this.log(`ID:             ${user.id}`);
-        // ADD-CLI2 — Phase L.1 contract fields. Dashes mean "not yet
-        // exposed by the backing API"; the JSON payload carries `null`.
-        const workspaceLabel = workspace
-            ? workspace.source === 'selection'
-                ? `${workspace.id} (this machine's selection)`
-                : `${workspace.name ?? '(unnamed)'}${workspace.id ? ` (${workspace.id})` : ''}`
-            : '-';
-        this.log(`Workspace:      ${workspaceLabel}`);
-        this.log(`Daemon ID:      ${daemonId ?? '-'}`);
+        // ADD-CLI2 — Phase L.1 contract fields. The JSON payload carries `null`;
+        // the text says what `null` MEANS rather than printing a bare `-`.
+        this.log(`Workspace:      ${describeWhoamiWorkspace(workspace)}`);
+        this.log(`Daemon ID:      ${describeWhoamiDaemon(daemonId)}`);
         // Named, not just spelled: `oversky.dev` and `skrr.ai` do not read as a
         // dev/prod pair to anyone who has not seen the constants, and `whoami` is
         // where the login message sends you to find out where you are (OSK-301).
@@ -175,6 +175,54 @@ class Whoami extends base_command_1.BaseCommand {
     }
 }
 exports.default = Whoami;
+/**
+ * What the `Workspace` row says — including when there isn't one. (OSK-322)
+ *
+ * `whoami` printed a bare `-` here, and a dash is read as "you have none".
+ * That is the wrong conclusion: an unset workspace does not mean requests go
+ * nowhere, it means they resolve to the account's default. `skrr context`
+ * already words the same field correctly, so the sentence below is deliberately
+ * ITS sentence, not a second one — the two commands answer the same question
+ * and must not answer it differently.
+ *
+ * (It is duplicated rather than shared because the wording lives inline in
+ * `commands/context.ts`; the right home for both is `lib/`, which is a wider
+ * change than this fix.)
+ */
+function describeWhoamiWorkspace(workspace) {
+    if (!workspace) {
+        return 'none — resolves to your default workspace (`skrr workspaces list` names it)';
+    }
+    if (workspace.source === 'selection') {
+        return `${workspace.id} (this machine's selection)`;
+    }
+    return `${workspace.name ?? '(unnamed)'}${workspace.id ? ` (${workspace.id})` : ''}`;
+}
+/**
+ * What the `Daemon ID` row says — including when there isn't one. (OSK-322)
+ *
+ * The field was ambiguous between two different questions, and the dogfood
+ * report shows the damage: `whoami` printed `Daemon ID: -` on a machine whose
+ * daemon `skrr daemon status` reported as bound, live and cloud-connected, so
+ * the reader concluded they had no daemon.
+ *
+ * The decision, stated here once: **`daemonId` is the daemon THIS CREDENTIAL
+ * represents, never the daemon running on this machine.** `whoami` is a
+ * credential report — every other row (token source, kind, expiry, refresh,
+ * at-rest encryption) describes the credential — so this row has to as well.
+ * A CLI credential authenticates a person, so the answer is always "none", and
+ * that is a fact rather than a missing lookup.
+ *
+ * The machine's daemon is a genuinely different subject with its own command,
+ * so the row names it instead of leaving the reader to guess which reading
+ * applies.
+ */
+function describeWhoamiDaemon(daemonId) {
+    if (daemonId)
+        return daemonId;
+    return ('none — this credential authenticates you, not a daemon ' +
+        "(for this machine's daemon run `skrr daemon status`)");
+}
 /**
  * Compact human duration. Shows the largest sensible unit — "5 min", "6
  * hours", "12 days". Negative input (already expired) returns "expired".

package/dist/commands/wiki/ls.d.ts

@@ -1,4 +1,27 @@
+import { dataService } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../base-command';
+import { type TableColumn } from '../../lib/format';
+export type WikiLsRow = {
+    kind: string;
+    name: string;
+    title: string;
+    updated: string;
+    id: string;
+};
+/**
+ * One row per entry, with the two fields `ls` used to throw away.
+ *
+ * Exported for `ls.spec.ts`.
+ */
+export declare function buildRows(listing: Awaited<ReturnType<typeof dataService.listSpaceWikiDirectory>>): WikiLsRow[];
+/**
+ * Both added columns are ELIDED when nothing fills them, so a wiki whose slugs
+ * already are its titles prints exactly what it printed before rather than
+ * gaining a column of dashes.
+ *
+ * Exported for `ls.spec.ts`.
+ */
+export declare function columnsFor(rows: WikiLsRow[]): Array<TableColumn<WikiLsRow>>;
 export default class WikiLs extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/wiki/ls.js

@@ -1,9 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRows = buildRows;
+exports.columnsFor = columnsFor;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const format_1 = require("../../lib/format");
+/**
+ * One row per entry, with the two fields `ls` used to throw away.
+ *
+ * Exported for `ls.spec.ts`.
+ */
+function buildRows(listing) {
+    return [
+        ...listing.folders.map((f) => ({
+            kind: 'dir',
+            name: `${f.name}/`,
+            // A folder's name IS its human name — it keeps its spaces — so a separate
+            // title would just repeat it. The listing carries no folder timestamp, so
+            // it has no date to show either.
+            title: '',
+            updated: '',
+            id: f.folder_id,
+        })),
+        ...listing.pages.map((p) => ({
+            kind: 'page',
+            name: p.slug,
+            // A page's path segment is SLUGIFIED, so on a wiki whose pages were
+            // titled in the web UI this column was a screen of nicknames —
+            // `2026-week-36` for "2026 week 36" — and nothing a human recognises.
+            // `tree` has always rendered `slug [title]`; `ls` simply had no column
+            // for it, though `--json` carried it all along.
+            title: p.title && p.title !== p.slug ? p.title : '',
+            updated: (0, format_1.localStamp)(p.lastEditedAt ?? p.updatedAt) || '',
+            id: p.pageId,
+        })),
+        ...listing.files.map((f) => ({
+            kind: 'file',
+            name: f.filename,
+            title: '',
+            updated: '',
+            id: f.file_id,
+        })),
+    ];
+}
+/**
+ * Both added columns are ELIDED when nothing fills them, so a wiki whose slugs
+ * already are its titles prints exactly what it printed before rather than
+ * gaining a column of dashes.
+ *
+ * Exported for `ls.spec.ts`.
+ */
+function columnsFor(rows) {
+    const columns = [
+        { key: 'kind', header: 'TYPE' },
+        { key: 'name', header: 'NAME', maxWidth: 48 },
+    ];
+    if (rows.some((r) => r.title))
+        columns.push({ key: 'title', header: 'TITLE', maxWidth: 48 });
+    // The thing most worth knowing from a listing is what moved recently, and
+    // `ls` gave a UUID nobody asked for and no date at all.
+    if (rows.some((r) => r.updated))
+        columns.push({ key: 'updated', header: 'UPDATED' });
+    columns.push({ key: 'id', header: 'ID' });
+    return columns;
+}
 class WikiLs extends base_command_1.BaseCommand {
     static description = "List a wiki directory's contents";
     static examples = [
@@ -42,20 +103,12 @@ class WikiLs extends base_command_1.BaseCommand {
             this.log(JSON.stringify(listing, null, 2));
             return;
         }
-        const rows = [
-            ...listing.folders.map((f) => ({ kind: 'dir', name: `${f.name}/`, id: f.folder_id })),
-            ...listing.pages.map((p) => ({ kind: 'page', name: p.slug, id: p.pageId })),
-            ...listing.files.map((f) => ({ kind: 'file', name: f.filename, id: f.file_id })),
-        ];
+        const rows = buildRows(listing);
         if (rows.length === 0) {
             this.log('(empty)');
             return;
         }
-        (0, format_1.renderTable)(rows, [
-            { key: 'kind', header: 'TYPE' },
-            { key: 'name', header: 'NAME', maxWidth: 48 },
-            { key: 'id', header: 'ID' },
-        ], (line) => this.log(line));
+        (0, format_1.renderTable)(rows, columnsFor(rows), (line) => this.log(line));
     }
 }
 exports.default = WikiLs;

package/dist/commands/wiki/mv.d.ts

@@ -1,4 +1,54 @@
 import { BaseCommand } from '../../base-command';
+/**
+ * What is sitting on the destination path already.
+ *
+ * `free` and `self` are both "go ahead" — moving a page onto its own path is a
+ * no-op rename, not a collision — but they are kept apart so the caller cannot
+ * accidentally treat "nothing there" as "the thing there is us".
+ */
+export type DestinationOccupant = {
+    kind: 'free';
+} | {
+    kind: 'self';
+} | {
+    kind: 'page';
+    pageId: string;
+    title: string;
+} | {
+    kind: 'folder';
+};
+/**
+ * Why this move must not proceed — or `null` when it may.
+ *
+ * Pure, so the decision is testable without a server: everything it needs is
+ * the occupant, the kinds involved, and whether the caller authorised a
+ * replacement. The messages say the word the old output never did — "already
+ * exists" — because a human watching the terminal could see the `-2` in the
+ * success line and still not read it as a collision.
+ */
+export declare function destinationConflict(opts: {
+    occupant: DestinationOccupant;
+    sourceKind: 'page' | 'folder';
+    source: string;
+    destination: string;
+    force: boolean;
+    binName: string;
+    spaceId: string;
+}): {
+    message: string;
+    code: string;
+} | null;
+/**
+ * Did the server disambiguate the slug anyway?
+ *
+ * The pre-flight check above closes the ordinary case, but it cannot close the
+ * race — a page can appear on the destination between the check and the move —
+ * and an older server has no notion of refusing. `allocateSlug` suffixes (`y` ->
+ * `y-2`), which is precisely the outcome that must never read as success, so the
+ * post-check reuses `write.ts`'s detector rather than a second copy of the
+ * server's slug rules.
+ */
+export declare function serverRenamedOnMove(requestedSlug: string, movedSlug?: string): boolean;
 /**
  * `skrr wiki mv <space> <source> <destination>` — move or rename a page OR a
  * folder.
@@ -13,6 +63,16 @@ import { BaseCommand } from '../../base-command';
  * through `PATCH /pages/:pageId/move` (which creates missing destination
  * folders); folders go through `PATCH /folders/:folder_id`, whose server-side
  * guard refuses to move a folder into its own descendant.
+ *
+ * OCCUPIED DESTINATIONS ARE REFUSED, not renamed around. The move endpoint runs
+ * the same `allocateSlug` de-duplication a CREATE does, so `mv X Y` onto an
+ * existing `Y` landed the source at `Y-2`, reported success, and left `Y`
+ * holding its OLD content — and `mv X Y; cat Y` then reads the stale page while
+ * believing it read the new one. Moving something onto a canonical path is the
+ * entire reason to run `mv`, so "I could not do that, so I did something
+ * adjacent" is the one outcome this command must not present as success.
+ * `--force` gives the filesystem's answer (replace the destination); the
+ * default gives the safe one (refuse and change nothing).
  */
 export default class WikiMv extends BaseCommand {
     static description: string;
@@ -24,8 +84,18 @@ export default class WikiMv extends BaseCommand {
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    /**
+     * What already occupies `destination` — a page, a folder, us, or nothing.
+     *
+     * A page and a folder cannot share a path, so this asks in the same order the
+     * source resolution does. Both lookups treat a 404 as an answer rather than a
+     * failure; anything else still surfaces, so an unreadable destination never
+     * degrades into "looks free, go ahead and clobber".
+     */
+    private resolveDestination;
     /**
      * Reparent and/or rename a folder.
      *