@skrr-ai/cli 0.1.37 → 0.1.39

package/dist/lib/local-skills.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKILL_CONVENTION_DISCOVERY_SINCE = void 0;
+exports.chooseDaemon = chooseDaemon;
+exports.isUserInvocable = isUserInvocable;
+exports.resolveLocalSkillRefs = resolveLocalSkillRefs;
+exports.withSkillInvocations = withSkillInvocations;
+exports.looksLikeSkillPath = looksLikeSkillPath;
+exports.findLocalSkillsNamed = findLocalSkillsNamed;
+exports.describeStoreSkillMiss = describeStoreSkillMiss;
+exports.daemonPredates = daemonPredates;
+const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * Which machine to ask, or why there is no single answer.
+ *
+ * Resolves rather than guesses: picking one of several machines and reporting
+ * its skills as "the" answer is the same silent narrowing the listing exists
+ * to remove.
+ */
+function chooseDaemon(active) {
+    if (active.length === 1)
+        return { daemonId: active[0].daemonId };
+    if (active.length === 0) {
+        return {
+            problem: 'No connected machine. Start one with `skrr daemon start`, then try again.',
+            candidates: [],
+        };
+    }
+    return {
+        problem: `${active.length} machines are connected. Pick one with --daemon:`,
+        candidates: [...active],
+    };
+}
+/** A skill with no declared triggers is invocable both ways — the walker's default. */
+function isUserInvocable(skill) {
+    return !skill.triggers || skill.triggers.includes('user');
+}
+/**
+ * Turn requested names into the references the server resolves.
+ *
+ * A request is `name`, or `<root>/<name>` when the same name exists under more
+ * than one root (`.claude/skills/review` vs `.agents/skills/review`). Each
+ * problem is reported in words that say what to type instead; nothing is
+ * dropped, because the server's own rule is that a skill the user picked and
+ * the turn did not load must fail the turn rather than run without it.
+ */
+function resolveLocalSkillRefs(inventory, requested) {
+    const refs = [];
+    const problems = [];
+    const seen = new Set();
+    for (const raw of requested) {
+        const request = raw.trim().replace(/^\//, '');
+        const slash = request.lastIndexOf('/');
+        const root = slash > 0 ? request.slice(0, slash) : null;
+        const name = slash > 0 ? request.slice(slash + 1) : request;
+        const named = inventory.filter((skill) => skill.name === name);
+        const matches = root ? named.filter((skill) => skill.source === root) : named;
+        if (matches.length === 0) {
+            problems.push(named.length > 0
+                ? `No skill "${name}" under ${root}. It is under: ${named.map((s) => s.source ?? '?').join(', ')}.`
+                : `No skill named "${name}" on this machine. See \`skrr skills local\`.`);
+            continue;
+        }
+        if (matches.length > 1) {
+            problems.push(`"${name}" exists under ${matches.length} roots. Name one: ` +
+                matches.map((s) => `--local-skill ${s.source ?? '?'}/${name}`).join(' | '));
+            continue;
+        }
+        const [skill] = matches;
+        if (!isUserInvocable(skill)) {
+            problems.push(`"${name}" declares it is for the agent to reach for, not to invoke (triggers: model).`);
+            continue;
+        }
+        if (seen.has(skill.pathHash))
+            continue;
+        seen.add(skill.pathHash);
+        refs.push({ name: skill.name, pathHash: skill.pathHash });
+    }
+    return { refs, problems };
+}
+/**
+ * The prompt with a `/name` for every invoked skill it does not already name.
+ *
+ * The web composer sends the `/name` in the text beside the reference, and
+ * drops a reference whose `/name` is gone; a CLI turn carries the same pair so
+ * the agent reads the same invocation either way.
+ */
+function withSkillInvocations(prompt, refs) {
+    const missing = refs.filter((ref) => !new RegExp(`(^|\\s)/${ref.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=\\s|$)`).test(prompt));
+    if (missing.length === 0)
+        return prompt;
+    return `${missing.map((ref) => `/${ref.name}`).join(' ')} ${prompt}`;
+}
+/** Whether a skill argument names a place on disk rather than a store id. */
+function looksLikeSkillPath(arg) {
+    return /[\\/]/.test(arg) || arg.startsWith('.') || arg.startsWith('~');
+}
+/**
+ * Where a skill with this name exists on the caller's connected machines.
+ *
+ * Best-effort by design: it runs only to word an error that is already going
+ * to be reported, so a machine that cannot be asked contributes nothing rather
+ * than replacing the real error with a second one.
+ */
+async function findLocalSkillsNamed(name) {
+    const bare = name.replace(/^\//, '');
+    let active = [];
+    try {
+        active = (await data_provider_1.dataService.getDaemons()).active ?? [];
+    }
+    catch {
+        return [];
+    }
+    const sightings = await Promise.all(active.map(async (daemon) => {
+        try {
+            const { skills } = await data_provider_1.dataService.getDaemonSkills(daemon.daemonId);
+            return (skills ?? [])
+                .filter((skill) => skill.name === bare)
+                .map((skill) => ({
+                daemonId: daemon.daemonId,
+                deviceName: daemon.deviceName,
+                source: skill.source,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }));
+    return sightings.flat();
+}
+/**
+ * The error for a skill argument a STORE command could not use.
+ *
+ * `skills install <name>` and `skills details <name>` answered a local skill's
+ * name or path with "Skill not found / NOT_FOUND": true of the store, and no
+ * help to someone the product had just told it reads their `.claude/skills`
+ * (OSK-9412). The answer depends on what the argument was, so it says which:
+ * a path (never a store id), a name found on a connected machine (needs no
+ * install), or neither (look the id up in the store).
+ */
+function describeStoreSkillMiss(arg, sightings, command) {
+    const verb = command === 'install' ? 'installs' : 'shows';
+    if (looksLikeSkillPath(arg)) {
+        return [
+            `\`skills ${command}\` ${verb} a skill from the store by its id; "${arg}" is a path.`,
+            "A skill in one of your machine's skill roots needs no install.",
+            '→ See what your machine has: skrr skills local',
+            '→ Use one on a turn: skrr agents chat <agent-id> --local-skill <name>',
+        ].join('\n');
+    }
+    if (sightings.length > 0) {
+        const where = sightings
+            .map((s) => `${s.daemonId}${s.deviceName ? ` (${s.deviceName})` : ''}${s.source ? `, ${s.source}` : ''}`)
+            .join('; ');
+        return [
+            `No store skill has the id "${arg}", but a skill named "${arg}" is on your machine: ${where}.`,
+            'It needs no install.',
+            `→ Use it on a turn: skrr agents chat <agent-id> --local-skill ${arg.replace(/^\//, '')}`,
+        ].join('\n');
+    }
+    return [
+        `No store skill has the id "${arg}".`,
+        '→ Find a store id: skrr skills search <term>',
+        '→ Skills on your machine are not in the store: skrr skills local',
+    ].join('\n');
+}
+/**
+ * The first daemon release whose walker scans the skill conventions — the
+ * project's `.claude/skills`, `.agents/skills`, `.devin/skills`,
+ * `.windsurf/skills` and the global `~/.claude/skills`. It arrived in
+ * `e9dfa732cd` and first shipped in 0.8.44; an older daemon scans only
+ * `claudeSession.skillsDir`, which is empty unless someone set it by hand.
+ */
+exports.SKILL_CONVENTION_DISCOVERY_SINCE = '0.8.44';
+/**
+ * Whether a daemon's reported version is older than `floor`.
+ *
+ * Unknown or unparseable versions answer false: this decides only whether to
+ * add an explanation, and claiming an unknown daemon is old would be a guess.
+ */
+function daemonPredates(version, floor) {
+    const parse = (value) => {
+        const match = /^(\d+)\.(\d+)\.(\d+)/.exec(String(value ?? '').trim());
+        return match ? match.slice(1).map(Number) : null;
+    };
+    const have = parse(version);
+    const need = parse(floor);
+    if (!have || !need)
+        return false;
+    for (let i = 0; i < 3; i += 1) {
+        if (have[i] !== need[i])
+            return have[i] < need[i];
+    }
+    return false;
+}

package/dist/lib/machines.d.ts

@@ -59,6 +59,16 @@ export interface Machine {
     identityKind: MachineIdentityKind;
     name: string;
     status: 'online' | 'offline' | 'degraded';
+    /**
+     * One sentence naming what decided the status, or null when nothing needs
+     * explaining. Optional because the CLI ships separately from the server.
+     *
+     * `degraded` alone is unactionable, and on a laptop it is usually permanent —
+     * one offline row for a provider that was uninstalled holds the verdict
+     * forever, because supersession needs a NEWER row for the same provider and
+     * none will ever arrive.
+     */
+    statusReason?: string | null;
     machineUuid: string | null;
     stableDaemonId: string | null;
     daemonId: string | null;
@@ -135,14 +145,4 @@ export declare function listMachines(): Promise<Machine[]>;
 export declare function getMachine(machineId: string): Promise<Machine | null>;
 export declare function updateMachine(machineId: string, patch: MachinePreferencesPatch): Promise<Machine | null>;
 export declare function disconnectMachine(machineId: string): Promise<Record<string, unknown> | null>;
-/**
- * Resolve a user-supplied reference to exactly one machine.
- *
- * A machine is addressable by several ids (`id`, `machineUuid`,
- * `stableDaemonId`, `daemonId`) and `skrr harnesses list` prints a TRUNCATED
- * uuid, so the id a user has to hand is often a prefix of the one the API
- * wants. Resolving here keeps every command accepting the same references, and
- * makes an ambiguous prefix an error rather than a silent pick of the first
- * match.
- */
 export declare function resolveMachineRef(machines: Machine[], ref: string): Machine;

package/dist/lib/machines.js

@@ -93,13 +93,35 @@ async function disconnectMachine(machineId) {
  * makes an ambiguous prefix an error rather than a silent pick of the first
  * match.
  */
+/**
+ * The daemon ids a hosted machine's sandbox id can appear inside.
+ *
+ * `machines hosted list` prints `sbs_…`; the machine row carries
+ * `hosted-machine-sbs_…` as its daemon id. Composed rather than matched by
+ * substring so a longer id cannot be resolved by a shorter one's text.
+ */
+function hostedSandboxDaemonIds(ref) {
+    if (!ref.startsWith('sbs_'))
+        return [];
+    return [`hosted-machine-${ref}`, `hosted-job-machine-${ref}`];
+}
 function resolveMachineRef(machines, ref) {
     const needle = ref.trim();
     const lower = needle.toLowerCase();
     const exact = machines.filter((m) => m.id === needle ||
         m.machineUuid === needle ||
         m.stableDaemonId === needle ||
-        m.daemonId === needle);
+        m.daemonId === needle ||
+        // The sandbox id, which is the ONLY id `machines hosted list` prints.
+        // One hosted machine carries five identifiers and, before this, the one
+        // its own list showed you was the one `machines show` refused: the
+        // sandbox id appears here only INSIDE the daemon id, as
+        // `hosted-machine-<sbs_…>`, while `machines list --all` shows the same
+        // box as `lease:rtl_…` — a different random string entirely. Two lists,
+        // two unrelated-looking ids, no way on screen to tell they are one
+        // machine. Exact composition, not a substring search, so this cannot
+        // match a machine that merely contains the text.
+        hostedSandboxDaemonIds(needle).some((candidate) => m.daemonId === candidate));
     if (exact.length === 1)
         return exact[0];
     const byName = machines.filter((m) => m.name?.toLowerCase() === lower);

package/dist/lib/search-query.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The search term, from a positional or `--query`, resolved the same way by
+ * both spellings of the same search.
+ *
+ * `skills search` and `search skills` run the identical store search. Neither
+ * accepted the obvious invocation — `skrr skills search git` — so the single
+ * most natural way to call a search command failed on both, and `--query` was
+ * `required` on both, which is what made it fail rather than prompt.
+ *
+ * Shared rather than copied because the two spellings staying in step is the
+ * whole point: the reason a reader could not tell them apart was that they had
+ * drifted (different one-liners, short flags on one of them), and a second copy
+ * of this is how that starts again.
+ */
+export declare function resolveSearchQuery(cmd: {
+    error: (message: string, options?: {
+        exit?: number;
+    }) => never;
+}, positional: string | undefined, flag: string | undefined, command: string): string;

package/dist/lib/search-query.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSearchQuery = resolveSearchQuery;
+/**
+ * The search term, from a positional or `--query`, resolved the same way by
+ * both spellings of the same search.
+ *
+ * `skills search` and `search skills` run the identical store search. Neither
+ * accepted the obvious invocation — `skrr skills search git` — so the single
+ * most natural way to call a search command failed on both, and `--query` was
+ * `required` on both, which is what made it fail rather than prompt.
+ *
+ * Shared rather than copied because the two spellings staying in step is the
+ * whole point: the reason a reader could not tell them apart was that they had
+ * drifted (different one-liners, short flags on one of them), and a second copy
+ * of this is how that starts again.
+ */
+function resolveSearchQuery(cmd, positional, flag, command) {
+    const fromPositional = positional?.trim();
+    const fromFlag = flag?.trim();
+    // Both given and DIFFERENT is a real ambiguity — refuse rather than pick.
+    // Both given and identical is a script that passes belt and braces; that is
+    // not an error and silently accepting it costs nobody anything.
+    if (fromPositional && fromFlag && fromPositional !== fromFlag) {
+        cmd.error(`Two different search terms: "${fromPositional}" and --query "${fromFlag}". Pass one.`, { exit: 2 });
+    }
+    const query = fromPositional || fromFlag;
+    if (!query) {
+        // `--query` used to be `required`, so oclif refused with its own generic
+        // sentence. Naming the shape people actually type is the point of the
+        // change, so the error names it too.
+        cmd.error(`What should I search for? Try \`skrr ${command} <term>\`.`, { exit: 2 });
+    }
+    return query;
+}

package/dist/lib/space-custom-actions.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Shared shape for `skrr spaces actions add|update`.
+ *
+ * Both commands describe the same stored object, and they had drifted from the
+ * server that validates it (`spaceCustomActionSchema` in api/server/routes/spaces.js).
+ */
+import type { SpaceCustomAction, SpaceMemberActionsResponse } from '@skrr-ai/data-provider';
+/**
+ * The server's limit on `icon`, which is `z.string().max(4)`.
+ *
+ * The flag used to be documented as "Lucide icon name". It is not one: the web
+ * settings page renders `action.icon` as literal text, and almost no Lucide name
+ * fits in four characters, so following the help produced a 400 with a raw Zod
+ * message and no hint that an emoji was wanted (OSK-9631).
+ *
+ * Zod's `max` counts UTF-16 code units, not visible characters, so the check
+ * below uses `String.prototype.length` to agree with it exactly. Counting
+ * graphemes instead would accept a family emoji the server then refuses.
+ */
+export declare const SPACE_CUSTOM_ACTION_ICON_MAX = 4;
+export declare const spaceCustomActionIconFlag: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+export declare const spaceCustomActionLabelFlag: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+/** Refuse an icon the server would refuse, with a message that says what fits. */
+export declare function spaceCustomActionIconProblem(icon: unknown): string | null;
+type SpaceWithActions = {
+    id: string;
+    title?: string;
+    leadAgentId?: string | null;
+    customActions?: SpaceCustomAction[] | null;
+};
+/**
+ * Why a space's OWN actions cannot run, or null when they can.
+ *
+ * A space custom action runs as a task assigned to the Space Leader, so on a
+ * space with no Leader every one of them is dead on arrival. That fact used to
+ * live only in a tooltip on a disabled web button: `spaces actions add` reported
+ * success, `spaces actions list` listed the action happily, and nothing on the
+ * CLI said it could never run (OSK-9641).
+ */
+export declare function spaceActionsNotRunnableReason(space: Pick<SpaceWithActions, 'id' | 'leadAgentId'>, bin: string): string | null;
+/**
+ * Find a space custom action by the id `spaces actions list` prints, or by the
+ * `space-custom:<id>` form the projected quick-action surfaces use.
+ */
+export declare function findSpaceCustomAction(space: SpaceWithActions, ref: string): {
+    customAction: SpaceCustomAction;
+    index: number;
+} | {
+    problem: string;
+};
+export type SpaceQuickActionRow = {
+    source: 'space' | 'agent';
+    title: string;
+    owner: string;
+    type: string;
+    ref: string;
+    run: string;
+};
+/**
+ * Everything a space's action panel offers, in the order the web shows it: the
+ * space's own actions first, then the actions of member agents the caller can
+ * view, filtered by scope with the same predicate the web and server use.
+ *
+ * `spaces actions list` showed only the first half and `spaces actions
+ * available` a wider second half (every member agent, including ones the caller
+ * cannot run), so "what can I run here?" had no answer on the CLI (OSK-9641).
+ * Every row's `run` is a command `spaces actions run` accepts.
+ */
+export declare function spaceQuickActionRows(space: SpaceWithActions & {
+    labelIds?: string[] | null;
+}, members: SpaceMemberActionsResponse['agents'], bin: string): SpaceQuickActionRow[];
+export {};

package/dist/lib/space-custom-actions.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Shared shape for `skrr spaces actions add|update`.
+ *
+ * Both commands describe the same stored object, and they had drifted from the
+ * server that validates it (`spaceCustomActionSchema` in api/server/routes/spaces.js).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spaceCustomActionLabelFlag = exports.spaceCustomActionIconFlag = exports.SPACE_CUSTOM_ACTION_ICON_MAX = void 0;
+exports.spaceCustomActionIconProblem = spaceCustomActionIconProblem;
+exports.spaceActionsNotRunnableReason = spaceActionsNotRunnableReason;
+exports.findSpaceCustomAction = findSpaceCustomAction;
+exports.spaceQuickActionRows = spaceQuickActionRows;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * The server's limit on `icon`, which is `z.string().max(4)`.
+ *
+ * The flag used to be documented as "Lucide icon name". It is not one: the web
+ * settings page renders `action.icon` as literal text, and almost no Lucide name
+ * fits in four characters, so following the help produced a 400 with a raw Zod
+ * message and no hint that an emoji was wanted (OSK-9631).
+ *
+ * Zod's `max` counts UTF-16 code units, not visible characters, so the check
+ * below uses `String.prototype.length` to agree with it exactly. Counting
+ * graphemes instead would accept a family emoji the server then refuses.
+ */
+exports.SPACE_CUSTOM_ACTION_ICON_MAX = 4;
+exports.spaceCustomActionIconFlag = core_1.Flags.string({
+    description: `Emoji shown on the button, e.g. ✨ (at most ${exports.SPACE_CUSTOM_ACTION_ICON_MAX} UTF-16 units). Not an icon name.`,
+});
+exports.spaceCustomActionLabelFlag = core_1.Flags.string({
+    description: 'Button text shown in the space. Not a Label entity — to offer an agent action in every space carrying a Label, use `agents actions create --label`.',
+});
+/** Refuse an icon the server would refuse, with a message that says what fits. */
+function spaceCustomActionIconProblem(icon) {
+    if (icon === undefined || icon === null)
+        return null;
+    if (typeof icon !== 'string')
+        return '--icon must be text.';
+    if (icon.length > exports.SPACE_CUSTOM_ACTION_ICON_MAX) {
+        return (`--icon "${icon}" is too long: it is shown as text on the button and must be an emoji ` +
+            `(at most ${exports.SPACE_CUSTOM_ACTION_ICON_MAX} UTF-16 units), e.g. --icon ✨. ` +
+            'Icon names such as "Sparkles" are not accepted here.');
+    }
+    return null;
+}
+/**
+ * Why a space's OWN actions cannot run, or null when they can.
+ *
+ * A space custom action runs as a task assigned to the Space Leader, so on a
+ * space with no Leader every one of them is dead on arrival. That fact used to
+ * live only in a tooltip on a disabled web button: `spaces actions add` reported
+ * success, `spaces actions list` listed the action happily, and nothing on the
+ * CLI said it could never run (OSK-9641).
+ */
+function spaceActionsNotRunnableReason(space, bin) {
+    if (space.leadAgentId)
+        return null;
+    return (`This space has no Space Leader, so its own actions cannot run: each runs as a task ` +
+        `assigned to the Leader. Set one with \`${bin} spaces update ${space.id} --lead-agent <agent-id>\`.`);
+}
+/**
+ * Find a space custom action by the id `spaces actions list` prints, or by the
+ * `space-custom:<id>` form the projected quick-action surfaces use.
+ */
+function findSpaceCustomAction(space, ref) {
+    const actions = space.customActions ?? [];
+    const id = (0, data_provider_1.spaceCustomActionSourceId)(ref) ?? ref;
+    const index = actions.findIndex((action) => action.id === id);
+    if (index >= 0)
+        return { customAction: actions[index], index };
+    if (actions.length === 0) {
+        return { problem: `Space ${space.id} has no custom actions.` };
+    }
+    return {
+        problem: `No custom action ${ref} in space ${space.id}. It has: ` +
+            actions.map((action) => `${action.id} (${action.label})`).join(', ') +
+            '.',
+    };
+}
+/**
+ * Everything a space's action panel offers, in the order the web shows it: the
+ * space's own actions first, then the actions of member agents the caller can
+ * view, filtered by scope with the same predicate the web and server use.
+ *
+ * `spaces actions list` showed only the first half and `spaces actions
+ * available` a wider second half (every member agent, including ones the caller
+ * cannot run), so "what can I run here?" had no answer on the CLI (OSK-9641).
+ * Every row's `run` is a command `spaces actions run` accepts.
+ */
+function spaceQuickActionRows(space, members, bin) {
+    const subject = { spaceId: space.id, labelIds: space.labelIds ?? [] };
+    const leaderMissing = !space.leadAgentId;
+    return [
+        ...(space.customActions ?? []).map((action) => ({
+            source: 'space',
+            title: action.label,
+            owner: 'Space Leader',
+            type: 'prompt',
+            ref: action.id,
+            run: leaderMissing
+                ? '(needs a Space Leader)'
+                : `${bin} spaces actions run ${space.id} ${action.id}`,
+        })),
+        ...members.flatMap(({ agent }) => (agent.agentActions ?? [])
+            .filter((action) => (0, data_provider_1.isAgentActionAvailableInSpace)(action, subject))
+            .map((action) => ({
+            source: 'agent',
+            title: action.title,
+            owner: agent.name ?? agent.id,
+            type: (0, data_provider_1.isBuiltinAgentAction)(action) ? `builtin:${action.builtinType}` : 'prompt',
+            ref: `${agent.id}:${action.id}`,
+            run: `${bin} spaces actions run ${space.id} ${agent.id}:${action.id}`,
+        }))),
+    ];
+}

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

@@ -1,23 +1,3 @@
-/**
- * Space reference resolution — turn what a person typed into exactly one
- * space id, or an actionable failure.
- *
- * Every `--space` flag in the CLI (35 commands at last count) took a raw UUID
- * and nothing else. Passing a name did not error — it filtered on a UUID that
- * matches no space and returned an empty result:
- *
- *     skrr tasks list --space "Always on"     →     "No tasks."
- *
- * A person retries. An agent concludes the space is empty and proceeds on a
- * false premise, which is the failure mode this module exists to remove. The
- * contract is deliberately narrow: a value that already looks like an id is
- * forwarded untouched (no request, no behavior change for existing scripts);
- * anything else must resolve to exactly one space or the command fails.
- *
- * Modeled on `assignee-resolver.ts`, which already does this for people and
- * agents — `--assignee-user frank` has worked for a while. Spaces were the
- * outlier, not the exception.
- */
 export type SpaceRef = {
     /** The space UUID — what every `--space` flag ultimately wants. */
     id: string;
@@ -36,7 +16,7 @@ export type SpaceResolutionFailure = {
      *             hides. Distinct from NOT_FOUND because the fix is different:
      *             pass --include-archived (or the id), not a different name.
      */
-    code: 'NOT_FOUND' | 'AMBIGUOUS' | 'ARCHIVED';
+    code: 'NOT_FOUND' | 'AMBIGUOUS' | 'ARCHIVED' | 'NOT_A_REFERENCE';
     query: string;
     candidates: SpaceRef[];
 };

package/dist/lib/space-resolver.js

@@ -1,4 +1,15 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPACE_CLI_ERROR_CODE = void 0;
+exports.looksLikeSpaceId = looksLikeSpaceId;
+exports.looksLikeCanonicalSpaceId = looksLikeCanonicalSpaceId;
+exports.normalizeSpaceRef = normalizeSpaceRef;
+exports.spaceRefFrom = spaceRefFrom;
+exports.resolveSpaceRef = resolveSpaceRef;
+exports.describeSpace = describeSpace;
+exports.describeSpaceCandidates = describeSpaceCandidates;
+exports.formatSpaceResolutionFailure = formatSpaceResolutionFailure;
+const failed_lookup_1 = require("./failed-lookup");
 /**
  * Space reference resolution — turn what a person typed into exactly one
  * space id, or an actionable failure.
@@ -19,16 +30,6 @@
  * agents — `--assignee-user frank` has worked for a while. Spaces were the
  * outlier, not the exception.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SPACE_CLI_ERROR_CODE = void 0;
-exports.looksLikeSpaceId = looksLikeSpaceId;
-exports.looksLikeCanonicalSpaceId = looksLikeCanonicalSpaceId;
-exports.normalizeSpaceRef = normalizeSpaceRef;
-exports.spaceRefFrom = spaceRefFrom;
-exports.resolveSpaceRef = resolveSpaceRef;
-exports.describeSpace = describeSpace;
-exports.describeSpaceCandidates = describeSpaceCandidates;
-exports.formatSpaceResolutionFailure = formatSpaceResolutionFailure;
 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}$/;
 const OBJECT_ID_RE = /^[0-9a-fA-F]{24}$/;
 /**
@@ -106,6 +107,11 @@ function resolveSpaceRef(query, spaces) {
     if (!q) {
         return { ok: false, code: 'NOT_FOUND', query: raw, candidates: spaces };
     }
+    // A failed lookup's output is refused before the name tiers can match it.
+    // See `failed-lookup.ts`.
+    if ((0, failed_lookup_1.isFailedLookupValue)(raw)) {
+        return { ok: false, code: 'NOT_A_REFERENCE', query: raw, candidates: [] };
+    }
     // An exact id or ref wins over everything, archived or not: both are
     // explicit and unambiguous, so there is nothing to protect the caller from.
     // Names are matched against live spaces only — see the ARCHIVED branch.
@@ -159,6 +165,8 @@ function describeSpaceCandidates(candidates, limit = 10) {
 /** One human-readable block per failure, suitable for a CLI error body. */
 function formatSpaceResolutionFailure(failure, bin = 'skrr') {
     switch (failure.code) {
+        case 'NOT_A_REFERENCE':
+            return (0, failed_lookup_1.describeFailedLookupValue)(failure.query, 'Space');
         case 'AMBIGUOUS':
             return (`"${failure.query}" matches ${failure.candidates.length} spaces:\n` +
                 `${describeSpaceCandidates(failure.candidates)}\n` +
@@ -178,4 +186,5 @@ exports.SPACE_CLI_ERROR_CODE = {
     AMBIGUOUS: 'SPACE_AMBIGUOUS',
     ARCHIVED: 'SPACE_ARCHIVED',
     NOT_FOUND: 'SPACE_NOT_FOUND',
+    NOT_A_REFERENCE: 'SPACE_NOT_A_REFERENCE',
 };

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

@@ -28,5 +28,6 @@ export type ClosureLike = TaskClosureEvaluation | {
  * the whole point is to be able to act without a second lookup.
  */
 export declare function closureReport(closure: ClosureLike): string[];
-/** `met (agent)` vs `met (you)` — whose judgement settled it, never hidden. */
-export declare function describeAssessor(kind: string | null | undefined): 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';