@skrr-ai/cli 0.1.46 → 0.1.48

package/dist/commands/tasks/labels/suggest.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const task_extras_1 = require("../../../lib/task-extras");
+const format_1 = require("../../../lib/format");
+/**
+ * Ask the lightweight model which of the DECLARED labels fit this task —
+ * `POST /api/tasks/:taskId/labels/suggest`, the on-demand half of the
+ * create-time `_labelGuidance` hint. The server keeps the suggestion off the
+ * task-create path (the hottest write in the product); this command is how a
+ * caller pays for one suggestion when it actually wants it.
+ *
+ * Same contract as create: the model may only CHOOSE from the declared
+ * vocabulary, a label the task already wears is never suggested, and a
+ * suggestion is a proposal, not a write — attach is still the caller's
+ * decision (`tasks labels attach --label <id>`).
+ */
+class TasksLabelsSuggest extends base_command_1.BaseCommand {
+    static description = 'Suggest labels for a task from the declared vocabulary (advisory, never writes)';
+    static examples = [
+        '<%= config.bin %> tasks labels suggest <task-id>',
+        '<%= config.bin %> tasks labels suggest <task-id> --json',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Task ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output the raw suggestion response as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLabelsSuggest);
+        let response;
+        try {
+            // The URL lives in the lib — a command that builds its own `/api/...`
+            // string is invisible to the CLI↔API parity check.
+            response = await (0, task_extras_1.taskLabelSuggestion)(args.id);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response ?? {}, null, 2));
+            return;
+        }
+        const suggestions = (response?.suggestions ?? []).filter((s) => Boolean(s?.id && s?.name));
+        const ref = response?.identifier ? ` (${response.identifier})` : '';
+        if (suggestions.length === 0) {
+            this.log(`No label suggestions for task ${args.id}${ref} — ` +
+                // The server counts the vocabulary AFTER excluding the labels this
+                // task already wears, so 0 means nothing left to propose, not that
+                // the registry is empty.
+                (response?.vocabularySize === 0
+                    ? 'the declared vocabulary is empty, or every label in it is already attached.'
+                    : 'nothing in the declared vocabulary clearly applies.') +
+                ' "No label" is a correct answer.');
+            return;
+        }
+        this.log(`Suggested labels for task ${args.id}${ref}:`);
+        (0, format_1.renderTable)(suggestions.map((s) => ({ id: s.id, name: s.name })), [
+            { key: 'id', header: 'ID' },
+            { key: 'name', header: 'NAME' },
+        ], (line) => this.log(line));
+        this.log(`A suggestion is a proposal, not a write — attach with ` +
+            `\`skrr tasks labels attach ${args.id} --label <id>\` if one fits.`);
+    }
+}
+exports.default = TasksLabelsSuggest;

package/dist/commands/tasks/list.d.ts

@@ -12,6 +12,19 @@ type ListFlags = Record<string, unknown>;
  * Exported and pure so the wording is testable without an oclif runtime.
  */
 export declare function emptyTasksMessage(flags: ListFlags, bin?: string): string;
+/**
+ * The NEXT column's text, computed once for the table and the `--json`
+ * `nextAction` alias. `reason` is the sentence the server wrote for a person;
+ * `reasonCode` is the enum it wrote for a machine — printing the code rendered
+ * every stage of every lifecycle as `human:lifecycle_stage` while the sentence
+ * naming the stage sat unread in the same payload.
+ */
+export declare function nextActionText(t: Record<string, unknown>): string;
+/**
+ * The REF column's value, aliased to `ref` under `--json` because `identifier`
+ * is the one name an agent scanning 43 keys does not guess (OSK-10692).
+ */
+export declare function taskRef(t: Record<string, unknown>): string;
 /**
  * The task-list request bag is shared with import/export so every CLI list
  * surface serializes the same server-side filters. Keep user-id resolution in
@@ -28,8 +41,9 @@ export default class TasksList extends BaseCommand {
         project: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         cycle: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         parent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'status-type': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        status: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        open: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'status-type': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'execution-state': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'actionable-by': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'actionable-for-agent': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/tasks/list.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emptyTasksMessage = emptyTasksMessage;
+exports.nextActionText = nextActionText;
+exports.taskRef = taskRef;
 exports.buildListParams = buildListParams;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
@@ -22,6 +24,7 @@ const FILTER_FLAGS = new Set([
     'parent',
     'status',
     'status-type',
+    'open',
     'execution-state',
     'actionable-by',
     'actionable-for-agent',
@@ -77,7 +80,7 @@ function emptyTasksMessage(flags, bin = 'skrr') {
         lines.push(`  → Create your first one: \`${bin} tasks create --title "..." --space <space-id>\``);
         lines.push(`  → List spaces to find one: \`${bin} spaces list\``);
     }
-    else if (flags.status === 'in_progress' && !flags['execution-state']) {
+    else if (statusList(flags).includes('in_progress') && !flags['execution-state']) {
         // `--status in_progress` filters the board column only. A run that was
         // reaped/reset (e.g. a stuck-task timeout) is moved OFF `in_progress` but
         // keeps its execution markers, so it hides here. Point the operator at
@@ -87,9 +90,7 @@ function emptyTasksMessage(flags, bin = 'skrr') {
         lines.push('      no longer has that status. Try `--execution-state active` (running now) or');
         lines.push(`      \`--execution-state recovered\` (reaped, startable), or \`${bin} tasks active\`.`);
     }
-    else if (typeof flags.status === 'string' &&
-        flags.status.length > 0 &&
-        !flags['execution-state']) {
+    else if (statusList(flags).length > 0 && !flags['execution-state']) {
         // A filter that matches nothing and a board that IS empty print the same
         // thing, and the caller cannot tell which they are looking at. Observed:
         // `--status todo` on a board whose open column is `backlog` said `No tasks.`
@@ -106,16 +107,54 @@ function emptyTasksMessage(flags, bin = 'skrr') {
         // string the branch above deliberately produces for that combination. The
         // same ambiguity exists there, but overturning a pinned decision is not
         // this change's business.
+        const wanted = statusList(flags);
         lines.push('');
-        lines.push(`Note: nothing matched \`--status ${flags.status}\`. A status is a workflow-state id the`);
-        lines.push('      space owns, so a board need not use this one at all.');
+        lines.push(`Note: nothing matched \`--status ${wanted.join(' --status ')}\`. A status is a`);
+        lines.push('      workflow-state id the space owns, so a board need not use this one at all.');
         lines.push('  → See what this scope actually holds: the same command without `--status`.');
-        if (!data_provider_1.TASK_STATUSES.includes(flags.status)) {
+        if (wanted.some((s) => !data_provider_1.TASK_STATUSES.includes(s))) {
             lines.push(`      (built-in ids: ${data_provider_1.TASK_STATUSES.join(', ')})`);
         }
     }
     return lines.join('\n');
 }
+/**
+ * `--status` is repeatable, so the flag value is a list; callers that predate
+ * that and tests that pass a bare string both normalize through here.
+ */
+function statusList(flags) {
+    const value = flags.status;
+    if (Array.isArray(value))
+        return value.filter((s) => typeof s === 'string');
+    return typeof value === 'string' && value.length > 0 ? [value] : [];
+}
+/** Same normalization for the repeatable `--status-type`. */
+function statusTypeList(flags) {
+    const value = flags['status-type'];
+    if (Array.isArray(value))
+        return value.filter((s) => typeof s === 'string');
+    return typeof value === 'string' && value.length > 0 ? [value] : [];
+}
+/**
+ * The NEXT column's text, computed once for the table and the `--json`
+ * `nextAction` alias. `reason` is the sentence the server wrote for a person;
+ * `reasonCode` is the enum it wrote for a machine — printing the code rendered
+ * every stage of every lifecycle as `human:lifecycle_stage` while the sentence
+ * naming the stage sat unread in the same payload.
+ */
+function nextActionText(t) {
+    const actionability = t.actionability;
+    return actionability
+        ? `${String(actionability.nextActor ?? '-')}: ${String(actionability.reason || actionability.reasonCode || actionability.state || '-')}`
+        : String(t.executionMode ?? '-');
+}
+/**
+ * The REF column's value, aliased to `ref` under `--json` because `identifier`
+ * is the one name an agent scanning 43 keys does not guess (OSK-10692).
+ */
+function taskRef(t) {
+    return String(t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '-'));
+}
 /**
  * The task-list request bag is shared with import/export so every CLI list
  * surface serializes the same server-side filters. Keep user-id resolution in
@@ -129,8 +168,25 @@ function buildListParams(flags, assigneeUserId) {
         projectId: flag('project'),
         cycleId: flag('cycle'),
         parentId: flag('parent'),
-        ...(flag('status') ? { status: flag('status') } : {}),
-        ...(flag('status-type') ? { statusType: flag('status-type') } : {}),
+        // Scalar for a single value, `$in` array once the caller ORs — keeps the
+        // wire shape identical to the pre-multiple flag for the common case.
+        ...(statusList(flags).length === 1
+            ? { status: statusList(flags)[0] }
+            : statusList(flags).length > 1
+                ? { status: statusList(flags) }
+                : {}),
+        // `--open` sends the DECLARED band rather than a string the CLI invented:
+        // TASK_WORKFLOW_TYPE_BANDS.open is the same list `--overdue` already
+        // filters by server-side, so the two cannot drift apart. The endpoint
+        // types statusType as `string | string[]` and the model does `$in`, so
+        // nothing below the CLI had to change.
+        ...(flag('open')
+            ? { statusType: [...data_provider_1.TASK_WORKFLOW_TYPE_BANDS.open] }
+            : statusTypeList(flags).length === 1
+                ? { statusType: statusTypeList(flags)[0] }
+                : statusTypeList(flags).length > 1
+                    ? { statusType: statusTypeList(flags) }
+                    : {}),
         ...(flag('execution-state')
             ? { executionState: flag('execution-state') }
             : {}),
@@ -206,6 +262,8 @@ class TasksList extends base_command_1.BaseCommand {
         '<%= config.bin %> tasks list --include-snoozed',
         '<%= config.bin %> tasks list --actionable-by agent --actionable-for-agent <agent-id>',
         '<%= config.bin %> tasks list --needs-me',
+        '<%= config.bin %> tasks list --open',
+        '<%= config.bin %> tasks list --status-type blocked --status-type review',
         '<%= config.bin %> tasks list --dri me',
         '<%= config.bin %> tasks list --view <task-view-id>',
         '<%= config.bin %> tasks list --calendar 2026-08-01..2026-08-31 --json',
@@ -219,9 +277,17 @@ class TasksList extends base_command_1.BaseCommand {
             description: 'Filter by planning cycle ID, or "current" / "next" (requires --space)',
         }),
         parent: core_1.Flags.string({ description: 'Filter by parent task ID' }),
-        status: core_1.Flags.string({ description: 'Filter by task status' }),
+        // Repeatable: each occurrence ORs into one `$in` clause server-side, so
+        // "backlog or in review" is one call, not one call per band (OSK-10693).
+        status: core_1.Flags.string({ description: 'Filter by task status (repeatable, OR)', multiple: true }),
+        open: core_1.Flags.boolean({
+            description: 'Everything still open — the declared open band (backlog, unstarted, started, review, ' +
+                'triage, failed, blocked). One call instead of one per band, and it survives a Space ' +
+                'adding its own workflow state names.',
+            exclusive: ['status-type', 'status'],
+        }),
         'status-type': core_1.Flags.string({
-            description: 'Filter by fixed workflow TYPE (independent of Space state names)',
+            description: 'Filter by fixed workflow TYPE, independent of Space state names (repeatable, OR)',
             options: [
                 'backlog',
                 'unstarted',
@@ -234,6 +300,7 @@ class TasksList extends base_command_1.BaseCommand {
                 'blocked',
                 'hidden',
             ],
+            multiple: true,
         }),
         'execution-state': core_1.Flags.string({
             description: 'Filter by execution state, not board status: "active" (running now — in_progress OR checked out OR live session) or "recovered" (startable again after a reaped/failed run). Surfaces reaped runs that --status in_progress hides.',
@@ -257,7 +324,7 @@ class TasksList extends base_command_1.BaseCommand {
         'due-before': core_1.Flags.string({ description: 'Only tasks due before an ISO timestamp or "now"' }),
         'due-after': core_1.Flags.string({ description: 'Only tasks due after an ISO timestamp or "now"' }),
         overdue: core_1.Flags.boolean({
-            description: 'Alias for --due-before now --status-type open; uses the shared legacy open-status band until configurable workflow states land',
+            description: 'Alias for --due-before now --open; uses the shared legacy open-status band until configurable workflow states land',
         }),
         'blocked-by': core_1.Flags.string({ description: 'Only tasks blocked by this task ID' }),
         blocks: core_1.Flags.string({ description: 'Only tasks that block this task ID' }),
@@ -382,7 +449,9 @@ class TasksList extends base_command_1.BaseCommand {
                     ...calendarRange,
                     ...(flags.space ? { spaceId: flags.space } : {}),
                     ...(flags.project ? { projectId: flags.project } : {}),
-                    ...(flags.status ? { status: flags.status } : {}),
+                    ...(statusList(flags).length > 0
+                        ? { status: statusList(flags) }
+                        : {}),
                 })
                 : await data_provider_1.dataService.listTasks(buildListParams(flags, assigneeUserId));
         }
@@ -390,7 +459,22 @@ class TasksList extends base_command_1.BaseCommand {
             this.handleApiError(err);
         }
         if (flags.json) {
-            this.log(JSON.stringify((0, web_url_1.withDataUrls)(this.cliConfig.baseURL, response, web_url_1.taskUrlFrom), null, 2));
+            // The table renders REF and NEXT, but the raw payload names them
+            // `identifier` and `actionability` — under `--json` an agent scanning 43
+            // keys could not find either (OSK-10692). Alias them to the names the
+            // table prints so the machine view answers the same questions.
+            const list = response;
+            const enriched = list && Array.isArray(list.data)
+                ? {
+                    ...list,
+                    data: list.data.map((t) => ({
+                        ...t,
+                        ref: taskRef(t),
+                        nextAction: nextActionText(t),
+                    })),
+                }
+                : response;
+            this.log(JSON.stringify((0, web_url_1.withDataUrls)(this.cliConfig.baseURL, enriched, web_url_1.taskUrlFrom), null, 2));
             return;
         }
         if (calendarRange) {
@@ -427,23 +511,15 @@ class TasksList extends base_command_1.BaseCommand {
             const agents = Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds.length : 0;
             const users = Array.isArray(t.assigneeUserIds) ? t.assigneeUserIds.length : 0;
             const assignees = agents + users > 0 ? `${agents}a/${users}u` : '-';
-            const actionability = t.actionability;
             return {
                 id: String(t.id ?? t._id ?? '-'),
-                ident: String(t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '-')),
+                ident: taskRef(t),
                 title: String(t.title ?? '-'),
                 status: String(t.status ?? '-'),
                 priority: String(t.priority ?? '-'),
                 estimate: t.estimate === null || t.estimate === undefined ? '-' : String(t.estimate),
                 assignees,
-                // `reason` is the sentence the server wrote for a person; `reasonCode`
-                // is the enum it wrote for a machine. Printing the code rendered every
-                // stage of every lifecycle as `human:lifecycle_stage` — six different
-                // waits, one string — while the sentence naming the stage sat unread in
-                // the same payload.
-                next: actionability
-                    ? `${String(actionability.nextActor ?? '-')}: ${String(actionability.reason || actionability.reasonCode || actionability.state || '-')}`
-                    : String(t.executionMode ?? '-'),
+                next: nextActionText(t),
                 match: String(t._matchField ?? '-'),
             };
         });

package/dist/commands/tasks/show.d.ts

@@ -27,6 +27,29 @@ export declare function taskPointerLines(t: Record<string, unknown>, ref: string
  * newest `blocker` Update and hands its payload here.
  */
 export declare function blockerDetailLines(detail: Record<string, unknown> | undefined): string[];
+/**
+ * The answer this command leads with: is it done?
+ *
+ * Everything below it in `tasks show` is still there — Status, Resolution,
+ * Result, Review, the Expectation counts. This does not replace them; it
+ * answers, in one sentence, the question a reader had to assemble from eleven
+ * concepts before. The projection is computed on the SERVER
+ * (`deriveTaskCompletion`), so this function renders and never decides: if the
+ * CLI derived it here, the board and a phone would each derive their own and
+ * the three would disagree about one Task.
+ *
+ * A read that FAILED prints its own line rather than nothing, because silence
+ * here is indistinguishable from "we had no concerns" — which is the exact
+ * collapse this whole projection exists to undo.
+ *
+ * Pure and exported so the wording is testable without an oclif runtime.
+ */
+export declare function completionLines(projection: {
+    sentence?: unknown;
+    alsoOutstanding?: unknown;
+} | null | undefined, { read }?: {
+    read?: boolean;
+}): string[];
 export declare function labelsLine(labelIds?: string[], nameById?: Map<string, string>): string;
 /**
  * The `Executor:` value — who does this task, and whether anyone said so.

package/dist/commands/tasks/show.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.taskPointerLines = taskPointerLines;
 exports.blockerDetailLines = blockerDetailLines;
+exports.completionLines = completionLines;
 exports.labelsLine = labelsLine;
 exports.taskExecutorLabel = taskExecutorLabel;
 exports.taskFailureLines = taskFailureLines;
@@ -76,6 +77,35 @@ function blockerDetailLines(detail) {
     }
     return lines;
 }
+/**
+ * The answer this command leads with: is it done?
+ *
+ * Everything below it in `tasks show` is still there — Status, Resolution,
+ * Result, Review, the Expectation counts. This does not replace them; it
+ * answers, in one sentence, the question a reader had to assemble from eleven
+ * concepts before. The projection is computed on the SERVER
+ * (`deriveTaskCompletion`), so this function renders and never decides: if the
+ * CLI derived it here, the board and a phone would each derive their own and
+ * the three would disagree about one Task.
+ *
+ * A read that FAILED prints its own line rather than nothing, because silence
+ * here is indistinguishable from "we had no concerns" — which is the exact
+ * collapse this whole projection exists to undo.
+ *
+ * Pure and exported so the wording is testable without an oclif runtime.
+ */
+function completionLines(projection, { read = true } = {}) {
+    if (!read) {
+        return ['Done?        could not be worked out just now — that check did not answer.'];
+    }
+    const sentence = typeof projection?.sentence === 'string' ? projection.sentence.trim() : '';
+    if (!sentence)
+        return [];
+    const also = Array.isArray(projection?.alsoOutstanding)
+        ? projection.alsoOutstanding.filter((row) => typeof row === 'string' && row.trim().length > 0)
+        : [];
+    return [`Done?        ${sentence}`, ...also.map((row) => `             also: ${row.trim()}`)];
+}
 function labelsLine(labelIds, nameById) {
     const ids = (labelIds ?? []).filter((id) => typeof id === 'string' && id.length > 0);
     if (ids.length === 0)
@@ -254,10 +284,30 @@ class TasksShow extends base_command_1.BaseCommand {
         }
         const t = task;
         const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, t);
+        /*
+         * The three-state answer, read from the server rather than worked out here.
+         *
+         * One extra request on a DETAIL view, for the line the whole command is
+         * read for. A failure is reported as a failure: `completionLines` prints
+         * that it could not be worked out, because a missing headline reads exactly
+         * like a clean one.
+         */
+        let completion = null;
+        let completionRead = true;
+        try {
+            const response = await data_provider_1.dataService.getTaskCompletion(String(t.id ?? taskId));
+            completion = (response?.completion ?? null);
+            completionRead = Boolean(completion);
+        }
+        catch {
+            completionRead = false;
+        }
         if (flags.json) {
-            this.log(JSON.stringify({ ...t, url }, null, 2));
+            this.log(JSON.stringify({ ...t, url, completion }, null, 2));
             return;
         }
+        for (const line of completionLines(completion, { read: completionRead }))
+            this.log(line);
         const agents = Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds : [];
         const users = Array.isArray(t.assigneeUserIds) ? t.assigneeUserIds : [];
         this.log(`ID:          ${t.id ?? t._id ?? '-'}`);

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

@@ -1,13 +1,34 @@
 import { BaseCommand } from '../../base-command';
+/**
+ * What to say when a page path does not resolve.
+ *
+ * A path is a SLUG, and renaming a page deliberately does not move it — that
+ * is what keeps a stored `skrr wiki` address working. The consequence is that
+ * a caller who types the page's TITLE is always wrong, and every page created
+ * in the web UI is `untitled`, `untitled-2`, … The old message named the
+ * failure and stopped, which leaves the one question the caller now has
+ * unanswered: where are the real paths? (OSK-10694)
+ *
+ * Exported so the wording is testable without driving the command.
+ */
+export declare function missingPagePathError({ path, spaceId, binName, }: {
+    path: string;
+    spaceId: string;
+    binName: string;
+}): {
+    message: string;
+    code: string;
+};
 export default class WikiRm extends BaseCommand {
     static description: string;
     static examples: string[];
     static args: {
         space: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
-        path: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        path: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'page-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         purge: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/wiki/rm.js

@@ -1,11 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.missingPagePathError = missingPagePathError;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const http_error_1 = require("../../lib/http-error");
 const prompt_1 = require("../../lib/prompt");
 const wiki_1 = require("../../lib/wiki");
+/**
+ * What to say when a page path does not resolve.
+ *
+ * A path is a SLUG, and renaming a page deliberately does not move it — that
+ * is what keeps a stored `skrr wiki` address working. The consequence is that
+ * a caller who types the page's TITLE is always wrong, and every page created
+ * in the web UI is `untitled`, `untitled-2`, … The old message named the
+ * failure and stopped, which leaves the one question the caller now has
+ * unanswered: where are the real paths? (OSK-10694)
+ *
+ * Exported so the wording is testable without driving the command.
+ */
+function missingPagePathError({ path, spaceId, binName, }) {
+    return {
+        message: `No page at path '${path}'. Paths are slugs and do not follow a page's title, ` +
+            `so list them with \`${binName} wiki ls ${spaceId}\` (or \`wiki tree\`), ` +
+            `or address the page directly with --page-id.`,
+        code: 'NOT_FOUND',
+    };
+}
 class WikiRm extends base_command_1.BaseCommand {
     // "recoverable" promised something no command can deliver: the row is
     // archived rather than destroyed, but nothing in `skrr wiki` — or in the model
@@ -19,10 +40,17 @@ class WikiRm extends base_command_1.BaseCommand {
     ];
     static args = {
         space: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
-        path: core_1.Args.string({ description: 'Page path', required: true, ignoreStdin: true }),
+        path: core_1.Args.string({ description: 'Page path', required: false, ignoreStdin: true }),
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        // `wiki cat` has had this since it shipped; the two commands that MUTATE a
+        // page did not, which is backwards. Every create and every rm hands the
+        // caller a page id — rm's own success line tells you to read the archived
+        // page back with `wiki cat --page-id` — so an agent holding an id could
+        // read the page and not remove it without first translating the id into a
+        // slug through `wiki tree` (OSK-10694).
+        'page-id': core_1.Flags.string({ description: 'Address the page by id instead of path' }),
         // `--yes` is the CLI-wide name for this (62 of 64 destructive commands use
         // it) and is what the non-TTY guard tells a script to pass. `--force`/`-f`
         // predates that convention here and stays for back-compat.
@@ -47,16 +75,37 @@ class WikiRm extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(WikiRm);
+        if (!args.path && !flags['page-id']) {
+            this.failWithCliError({
+                message: 'Provide a page path or --page-id.',
+                code: 'WIKI_PATH_REQUIRED',
+                exit: 1,
+                retryable: false,
+            });
+        }
         let page;
         try {
-            page = await data_provider_1.dataService.getSpaceWikiPageByPath(args.space, args.path);
+            page = flags['page-id']
+                ? await data_provider_1.dataService.getSpaceWikiPage(args.space, flags['page-id'])
+                : await data_provider_1.dataService.getSpaceWikiPageByPath(args.space, args.path);
         }
         catch (err) {
             // `rm` addresses pages. Pointing a folder path at it used to report the
             // bare "No page at path 'X'", which reads as "nothing is there" when in
             // fact a folder is — send the caller to the verb that removes one.
-            if ((0, http_error_1.isHttpNotFound)(err)) {
+            if ((0, http_error_1.isHttpNotFound)(err) && args.path) {
                 const folderId = await (0, wiki_1.resolveWikiFolderId)(args.space, args.path, data_provider_1.dataService.listSpaceWikiDirectory, http_error_1.isHttpNotFound).catch(() => null);
+                if (!folderId) {
+                    this.failWithCliError({
+                        ...missingPagePathError({
+                            path: args.path,
+                            spaceId: args.space,
+                            binName: this.config.bin,
+                        }),
+                        exit: 1,
+                        retryable: false,
+                    });
+                }
                 if (folderId) {
                     this.failWithCliError({
                         message: `'${args.path}' is a folder, not a page. Remove it with \`${this.config.bin} wiki rmdir ${args.space} ${args.path}\`.`,

package/dist/lib/agentic-stream.js

@@ -662,8 +662,16 @@ class AgenticStreamClient {
                 this.finish('failed', event);
         });
         socket.on('permission:request', (event) => {
-            if (match(event))
-                void this.handlePermission(event);
+            if (!match(event))
+                return;
+            // One ask, one answer (OSK-11796). The same `permission:request` can
+            // arrive twice — a `session:join` replay overlapping the live emit, or
+            // fan-out through a second room — and each copy used to emit its own
+            // `permission.requested` AND send its own approve/deny, so a duplicate
+            // delivery produced a duplicate prompt and a racing second decision.
+            if (!this.firstTimeSeen('permission', event.toolUseId))
+                return;
+            void this.handlePermission(event);
         });
         socket.on('question:ask', (event) => {
             if (match(event))

package/dist/lib/assignee-resolver.d.ts

@@ -25,6 +25,28 @@ export type SpaceMember = {
     name?: string;
     email?: string;
 };
+export type ExpertiseSuggestion = {
+    member: SpaceMember;
+    /** Expertise entries that exactly match a task tag (strong match). */
+    matchedTags: string[];
+    /** Expertise entries that appear in the task title/description (weak match). */
+    matchedText: string[];
+};
+/**
+ * Deterministic advisory lookup: which space members' declared `expertise`
+ * intersects this task's tags (strong) or appears in its title/description
+ * (weak). Not a routing decision — the caller still picks the assignee; this
+ * just surfaces the declared contract. Ranked: more tag matches first, then
+ * more text matches.
+ */
+export declare function suggestMembersByExpertise({ members, expertiseByMemberId, taskTags, taskText, }: {
+    members: SpaceMember[];
+    /** member.id → declared expertise labels */
+    expertiseByMemberId: Map<string, string[]>;
+    taskTags: string[];
+    /** Task title + description, any case — normalized internally. */
+    taskText: string;
+}): ExpertiseSuggestion[];
 export type ResolutionFailure = {
     ok: false;
     /**

package/dist/lib/assignee-resolver.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestMembersByExpertise = suggestMembersByExpertise;
 exports.looksLikeRawId = looksLikeRawId;
 exports.membersFromPrincipals = membersFromPrincipals;
 exports.resolveMember = resolveMember;
@@ -9,6 +10,31 @@ exports.resolveAssigneeReferences = resolveAssigneeReferences;
 exports.formatResolutionFailure = formatResolutionFailure;
 const failed_lookup_1 = require("./failed-lookup");
 const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * Deterministic advisory lookup: which space members' declared `expertise`
+ * intersects this task's tags (strong) or appears in its title/description
+ * (weak). Not a routing decision — the caller still picks the assignee; this
+ * just surfaces the declared contract. Ranked: more tag matches first, then
+ * more text matches.
+ */
+function suggestMembersByExpertise({ members, expertiseByMemberId, taskTags, taskText, }) {
+    const normTag = (v) => v.trim().toLowerCase();
+    const tags = new Set(taskTags.map(normTag));
+    const text = taskText.toLowerCase();
+    const out = [];
+    for (const member of members) {
+        const expertise = expertiseByMemberId.get(member.id);
+        if (!expertise || expertise.length === 0)
+            continue;
+        const matchedTags = expertise.filter((e) => tags.has(normTag(e)));
+        const matchedText = expertise.filter((e) => !matchedTags.includes(e) && normTag(e).length > 0 && text.includes(normTag(e)));
+        if (matchedTags.length > 0 || matchedText.length > 0) {
+            out.push({ member, matchedTags, matchedText });
+        }
+    }
+    out.sort((a, b) => b.matchedTags.length - a.matchedTags.length || b.matchedText.length - a.matchedText.length);
+    return out;
+}
 const OBJECT_ID_RE = /^[0-9a-fA-F]{24}$/;
 const UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 // Agent ids are transitioning from public UUIDs to opaque `agent_…` ids.