@skrr-ai/cli 0.1.37 → 0.1.38

package/dist/lib/agent-actions.js

@@ -5,6 +5,8 @@ exports.parseJsonObjectFlag = parseJsonObjectFlag;
 exports.fetchAgentForActionEdit = fetchAgentForActionEdit;
 exports.getAgentActions = getAgentActions;
 exports.findAgentAction = findAgentAction;
+exports.storedActionOrLocal = storedActionOrLocal;
+exports.appendAgentAction = appendAgentAction;
 exports.updateAgentActions = updateAgentActions;
 exports.makePromptAction = makePromptAction;
 exports.makeBuiltinAction = makeBuiltinAction;
@@ -17,22 +19,13 @@ exports.renderAction = renderAction;
 const node_crypto_1 = require("node:crypto");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const format_1 = require("./format");
-exports.BUILTIN_ACTION_TYPES = [
-    'slack_send_message',
-    'slack_tool',
-    'group_chat_message',
-    'space_create_task',
-    'space_post_update',
-    'task_create',
-    'task_mark_done',
-    'task_assign',
-    'goal_create',
-    'goal_mark_done',
-    'smart_schedule_plan',
-    'smart_schedule_delta_watch',
-];
-const _builtinActionTypesAreExhaustive = true;
-void _builtinActionTypesAreExhaustive;
+const label_ref_1 = require("./label-ref");
+const api_fetch_1 = require("./api-fetch");
+// The vocabulary is owned by `@skrr-ai/data-provider`, which also proves it
+// complete against `BuiltinActionType`. This file used to hold a second copy
+// with its own guard (OSK-9668).
+var data_provider_2 = require("@skrr-ai/data-provider");
+Object.defineProperty(exports, "BUILTIN_ACTION_TYPES", { enumerable: true, get: function () { return data_provider_2.BUILTIN_ACTION_TYPES; } });
 exports.ACTION_TARGET_TYPES = [
     'group-chats',
     'spaces',
@@ -66,6 +59,88 @@ function getAgentActions(agent) {
 function findAgentAction(agent, actionId) {
     return getAgentActions(agent).find((action) => action.id === actionId);
 }
+/**
+ * The row as the SERVER stored it, not as we sent it.
+ *
+ * `updateAgentActions` returns the updated Agent, and both editors used to
+ * discard it and print the object they had just built — so the output was the
+ * input, restated. That is not a cosmetic difference: the server normalizes
+ * `agentActions` through an allowlist before persisting, so a field it drops is
+ * echoed back by the CLI as though it had been saved. A `label` scope and
+ * `outcome: durable` were both silently discarded that way and the CLI reported
+ * success with the values the caller had typed (OSK-9628).
+ *
+ * Falling back to the local object keeps the command working if the write
+ * succeeds but the response is unexpectedly shaped; it cannot make the output
+ * wrong in a way it was not already.
+ */
+function storedActionOrLocal(agent, local) {
+    if (!agent)
+        return local;
+    return findAgentAction(agent, local.id) ?? local;
+}
+/**
+ * Append ONE action atomically.
+ *
+ * `agents actions create` used to read the agent, append in memory and write
+ * the whole library back through `updateAgentActions`. Two concurrent creates
+ * therefore each read the same library and the later write erased the earlier
+ * action — six parallel creates all printed success and left one (OSK-9673).
+ * This endpoint appends with a single conditional `$push` on the server, so
+ * concurrent creates all land, the cap is enforced at the instant of the write,
+ * and a retried request whose id already landed returns `created: false`
+ * instead of adding a second copy. The client-generated id is what makes that
+ * retry safe, so it is sent rather than left for the server to assign.
+ *
+ * Update and delete still use `updateAgentActions` and still read-modify-write.
+ */
+async function appendAgentAction(agentId, action) {
+    try {
+        return await (0, api_fetch_1.apiFetch)(`/api/agents/${encodeURIComponent(agentId)}/agent-actions`, { method: 'POST', body: { action } });
+    }
+    catch (err) {
+        if (!isMissingRoute(err))
+            throw err;
+        return appendAgentActionByRewrite(agentId, action);
+    }
+}
+/**
+ * The server predates the append route.
+ *
+ * A released CLI is not guaranteed a server that has every route it knows —
+ * a self-hosted instance, or production mid-rollout — and without this,
+ * `agents actions create` against such a server simply failed. A missing ROUTE
+ * answers 404 with no `code` and a "No API route matches" message; a missing
+ * AGENT answers 404 with `code: 'agent_not_found'`, which must NOT fall back.
+ */
+function isMissingRoute(err) {
+    return (err instanceof api_fetch_1.ApiFetchError &&
+        err.status === 404 &&
+        !err.code &&
+        typeof err.body === 'string' &&
+        err.body.includes('No API route matches'));
+}
+/**
+ * The pre-append behaviour, kept only for servers without the route: read the
+ * library, append in memory, write it back. It is NOT safe under concurrency —
+ * that is the defect the route exists to fix — but it is correct for a single
+ * writer, which beats refusing to create anything.
+ */
+async function appendAgentActionByRewrite(agentId, action) {
+    const agent = await fetchAgentForActionEdit(agentId);
+    const actions = getAgentActions(agent);
+    const earlier = actions.find((candidate) => candidate.id === action.id);
+    if (earlier) {
+        return { action: earlier, created: false, total: actions.length };
+    }
+    const placed = typeof action.order === 'number' ? action : { ...action, order: nextActionOrder(actions) };
+    const saved = await updateAgentActions(agentId, [...actions, placed]);
+    return {
+        action: storedActionOrLocal(saved, placed),
+        created: true,
+        total: getAgentActions(saved).length || actions.length + 1,
+    };
+}
 async function updateAgentActions(agentId, actions) {
     return data_provider_1.dataService.updateAgent({
         agent_id: agentId,
@@ -113,11 +188,27 @@ exports.AGENT_ACTION_OUTCOME_CHOICES = ['ephemeral', 'durable'];
  * `--scope space --space s1` twice is the kind of ceremony people skip and then
  * wonder why the action is everywhere. An explicit `--scope general` clears it.
  */
-function resolveAgentActionScopeFlags(flags) {
-    const labelIds = (flags.label ?? []).map((value) => value.trim()).filter(Boolean);
+/**
+ * `--label` accepts an id OR a name, like every other `--label` in the CLI.
+ *
+ * It used to take the value verbatim as a `labelId`. A name was therefore
+ * stored as though it were an id, matched no space's `labelIds`, and produced
+ * an action offered NOWHERE — silently, with the create reporting success. That
+ * is exactly the "an action that disappears reads as deletion" hazard the label
+ * tier was designed around, arriving through the CLI instead of through a card
+ * that forgot to pass its labels. An unknown name was accepted too, so a typo
+ * was indistinguishable from a working scope.
+ *
+ * `resolveLabelRefs` is the same resolver `spaces create --label` uses: it
+ * short-circuits when every value already looks like an id (so a scripted
+ * caller pays no request), refuses an unknown name with the near misses named,
+ * and refuses an ambiguous one rather than guessing.
+ */
+async function resolveAgentActionScopeFlags(flags) {
+    const labelRefs = (flags.label ?? []).map((value) => value.trim()).filter(Boolean);
     const spaceId = flags.space?.trim();
     const declared = flags.scope?.trim();
-    const kind = declared ?? (spaceId ? 'space' : labelIds.length ? 'label' : undefined);
+    const kind = declared ?? (spaceId ? 'space' : labelRefs.length ? 'label' : undefined);
     if (!kind)
         return undefined;
     if (kind === 'general')
@@ -129,8 +220,9 @@ function resolveAgentActionScopeFlags(flags) {
         return { kind: 'space', spaceId, ...(spaceTitle ? { spaceTitle } : {}) };
     }
     if (kind === 'label') {
-        if (!labelIds.length)
-            throw new Error('--scope label requires at least one --label <label-id>.');
+        if (!labelRefs.length)
+            throw new Error('--scope label requires at least one --label <label-id-or-name>.');
+        const labelIds = await (0, label_ref_1.resolveLabelRefs)(labelRefs, { applicableTo: 'space' });
         return { kind: 'label', labelIds };
     }
     throw new Error(`--scope must be one of ${exports.AGENT_ACTION_SCOPE_CHOICES.join(', ')}.`);

package/dist/lib/agent-pin-mute.d.ts

@@ -8,11 +8,16 @@
  * a command in a script, where the outcome would depend on state the script
  * never read.
  *
- * So the desired state is read first and the toggle is sent only when it
- * differs. That makes each command idempotent and its name true. The read is not
- * a lock: two concurrent invocations can still race, which is a real limit of a
- * toggle endpoint and not something the CLI can fix from out here — the
- * returned state is always what the server says, never what was asked for.
+ * So the desired state is sent, and the endpoint now takes one. It used to be
+ * read-then-flip-if-different, which made each command idempotent when run
+ * alone and inverted under concurrency: six `skrr agents pin` calls that each
+ * read "unpinned" sent six flips, and six flips from false is false — pinning an
+ * agent six times left it unpinned. That was never fixable from out here, as the
+ * previous version of this comment said; it needed the endpoint to accept a
+ * desired state, which is what `pinned`/`muted` in the body now is.
+ *
+ * `changed` comes from the server, which is the only place that can compare the
+ * old value with the new one without a second race.
  */
 export type AgentFlag = 'pin' | 'mute';
 export interface FlagChange {

package/dist/lib/agent-pin-mute.js

@@ -5,13 +5,26 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 async function setAgentFlag(agentId, flag, desired) {
     const current = await data_provider_1.dataService.getAgentPreferences(agentId);
     const held = flag === 'pin' ? current.preferences?.isPinned : current.preferences?.isMuted;
+    // Nothing to send. True on every server version, and the one case where a
+    // write would be pure risk.
     if (Boolean(held) === desired) {
         return { value: desired, changed: false };
     }
+    // The read stays, and it is NOT what the race was. The race was read-then-
+    // FLIP: the write depended on what was read, so two readers of the same value
+    // sent two flips. The write now carries the desired state, so any number of
+    // them land on it — the read only decides whether to speak at all.
+    //
+    // It also keeps this honest against a server that has not been deployed yet.
+    // A build without the desired-state branch ignores the body and flips; from a
+    // state we have just confirmed differs, one flip still reaches `desired`, so
+    // the reported outcome is true either way. Reporting the server's `changed`
+    // alone was not: an old server omits it, `?? false` read that as "nothing to
+    // do", and `skrr agents pin` said so while flipping the bit.
     if (flag === 'pin') {
-        const result = await data_provider_1.dataService.toggleAgentPin(agentId);
-        return { value: result.isPinned, changed: true };
+        const result = await data_provider_1.dataService.toggleAgentPin(agentId, desired);
+        return { value: result.isPinned, changed: result.changed ?? true };
     }
-    const result = await data_provider_1.dataService.toggleAgentMute(agentId);
-    return { value: result.isMuted, changed: true };
+    const result = await data_provider_1.dataService.toggleAgentMute(agentId, desired);
+    return { value: result.isMuted, changed: result.changed ?? true };
 }

package/dist/lib/agent-visual-refs.d.ts

@@ -1,6 +1,33 @@
 import type { AgentAvatarRef, AgentSceneBackground } from '@skrr-ai/data-provider';
+/**
+ * The `--scene-background` help, shared by `agents create` and `agents update`.
+ *
+ * It named three forms and no preset ids, while the refusal it led to named a
+ * fourth form (JSON) and listed all the ids — so the only way to learn the valid
+ * values was to type a wrong one on purpose. `--avatar`, one flag away, already
+ * did this right. Built from the shipped catalog so it cannot fall behind it.
+ */
+export declare const SCENE_BACKGROUND_FLAG_HELP: string;
+export declare function imageUploadMimeType(filePath: string): string | undefined;
 /** Preset ids this build ships, for an error message that can be acted on. */
 export declare function avatarPresetIds(): string[];
 export declare function sceneBackgroundPresetIds(): string[];
 export declare function parseAvatarRefFlag(value: string): AgentAvatarRef;
 export declare function parseSceneBackgroundFlag(value: string): AgentSceneBackground;
+/**
+ * The avatar line for `agents show` text output.
+ *
+ * `agents show` printed no avatar at all, so its output was byte-identical before
+ * and after `agents update --avatar preset:studio-halo`: "has the Halo preset"
+ * and "has no face whatsoever" could not be told apart without `--json` and
+ * knowing which raw field to decode. The coercion `--avatar` performs is the one
+ * thing a reader would want confirmed, and it was the one thing hidden.
+ *
+ * Rendered in the same shorthand `--avatar` accepts, so what is printed is what
+ * can be typed back. An ABSENT avatar is kept apart from an explicit
+ * `{type:'default'}`: both show the platform logo, but only the absent one was
+ * never chosen, and that is exactly what `agents avatar default apply` rewrites.
+ */
+export declare function agentAvatarLine(raw: unknown): string;
+/** The scene-background line, in the shorthand `--scene-background` accepts. */
+export declare function agentSceneBackgroundLine(raw: unknown): string;

package/dist/lib/agent-visual-refs.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCENE_BACKGROUND_FLAG_HELP = void 0;
+exports.imageUploadMimeType = imageUploadMimeType;
 exports.avatarPresetIds = avatarPresetIds;
 exports.sceneBackgroundPresetIds = sceneBackgroundPresetIds;
 exports.parseAvatarRefFlag = parseAvatarRefFlag;
 exports.parseSceneBackgroundFlag = parseSceneBackgroundFlag;
+exports.agentAvatarLine = agentAvatarLine;
+exports.agentSceneBackgroundLine = agentSceneBackgroundLine;
 /**
  * The two "how does this agent look" fields, parsed from a flag.
  *
@@ -35,6 +39,37 @@ exports.parseSceneBackgroundFlag = parseSceneBackgroundFlag;
  * "your avatar silently became someone else's" rather than a parse error.
  */
 const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * The `--scene-background` help, shared by `agents create` and `agents update`.
+ *
+ * It named three forms and no preset ids, while the refusal it led to named a
+ * fourth form (JSON) and listed all the ids — so the only way to learn the valid
+ * values was to type a wrong one on purpose. `--avatar`, one flag away, already
+ * did this right. Built from the shipped catalog so it cannot fall behind it.
+ */
+exports.SCENE_BACKGROUND_FLAG_HELP = 'Backdrop for the 3D view: default, preset:<id>, image:<filepath>@<source>, or a JSON ' +
+    `object such as {"type":"preset","id":"midnight"}. Presets: ${data_provider_1.AGENT_SCENE_BACKGROUND_PRESETS.map((preset) => preset.id).join(', ')}. For your own photo use \`skrr agents scene-background upload\` — ` +
+    '<filepath> is the storage path that command produces, not a file on disk.';
+/**
+ * The MIME type to send an image upload as, from its file extension.
+ *
+ * The upload routes gate on the multipart part's type, and a part built as
+ * `new Blob([bytes])` has none, so it arrives as `application/octet-stream` and
+ * is refused whatever its bytes are. `agents avatar upload` shipped that way and
+ * could not upload any file (OSK-9841). Returns undefined for anything that is
+ * not an image type the routes accept, so a caller can refuse locally.
+ */
+const UPLOAD_IMAGE_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+};
+function imageUploadMimeType(filePath) {
+    const dot = filePath.lastIndexOf('.');
+    return dot < 0 ? undefined : UPLOAD_IMAGE_TYPES[filePath.slice(dot).toLowerCase()];
+}
 /** `image:path/to.png@s3` — the `@` is the LAST one, so a path may contain `@`. */
 function parseImage(rest, flag) {
     const at = rest.lastIndexOf('@');
@@ -62,6 +97,43 @@ function parseJsonObject(value) {
         return undefined;
     }
 }
+/**
+ * Hold a JSON value to the same rules as the shorthand, for the shapes the
+ * grammar knows.
+ *
+ * The JSON form used to be returned unchecked, so the one form with no worked
+ * example was also the one with no local validation: `{"type":"preset"}` went to
+ * the server and came back as a raw zod dump
+ * (`sceneBackground.id: Invalid input: expected string, received undefined`),
+ * while `preset:` with no id got a sentence. A KNOWN `type` is now validated here
+ * exactly as its shorthand is. An unknown `type` still passes through untouched,
+ * because letting a shape this grammar has not learned reach the server is the
+ * reason the escape hatch exists.
+ */
+function checkJsonRef(json, flag, shorthand) {
+    const type = json.type;
+    const str = (value) => (typeof value === 'string' ? value : '');
+    if (type === 'default')
+        return;
+    if (type === 'preset' || type === 'asset') {
+        if (!str(json.id)) {
+            throw new Error(`${flag}: a JSON value of type "${type}" needs a string "id" — for example ` +
+                `{"type":"${type}","id":"<id>"}, or the shorthand ${type}:<id>.`);
+        }
+        shorthand(`${type}:${str(json.id)}`);
+        return;
+    }
+    if (type === 'image') {
+        if (!str(json.filepath) || !str(json.source)) {
+            throw new Error(`${flag}: a JSON value of type "image" needs string "filepath" and "source" — ` +
+                'for example {"type":"image","filepath":"<storage path>","source":"s3"}.');
+        }
+        return;
+    }
+    if (typeof type !== 'string' || !type) {
+        throw new Error(`${flag}: a JSON value needs a string "type" (default, preset, image, …).`);
+    }
+}
 /** Preset ids this build ships, for an error message that can be acted on. */
 function avatarPresetIds() {
     return data_provider_1.AGENT_AVATAR_PRESETS.map((preset) => preset.id);
@@ -82,8 +154,10 @@ function someOf(ids, limit = 6) {
 }
 function parseAvatarRefFlag(value) {
     const json = parseJsonObject(value);
-    if (json)
+    if (json) {
+        checkJsonRef(json, '--avatar', parseAvatarRefFlag);
         return json;
+    }
     const raw = value.trim();
     if (raw === 'default')
         return { type: 'default' };
@@ -113,8 +187,10 @@ function parseAvatarRefFlag(value) {
 }
 function parseSceneBackgroundFlag(value) {
     const json = parseJsonObject(value);
-    if (json)
+    if (json) {
+        checkJsonRef(json, '--scene-background', parseSceneBackgroundFlag);
         return json;
+    }
     const raw = value.trim();
     if (raw === 'default')
         return { type: 'default' };
@@ -140,3 +216,52 @@ function parseSceneBackgroundFlag(value) {
     throw new Error(`--scene-background: cannot read "${value}". Accepted: default, preset:<id>, ` +
         `image:<filepath>@<source>, or a JSON object. Presets: ${sceneBackgroundPresetIds().join(', ')}.`);
 }
+/**
+ * The avatar line for `agents show` text output.
+ *
+ * `agents show` printed no avatar at all, so its output was byte-identical before
+ * and after `agents update --avatar preset:studio-halo`: "has the Halo preset"
+ * and "has no face whatsoever" could not be told apart without `--json` and
+ * knowing which raw field to decode. The coercion `--avatar` performs is the one
+ * thing a reader would want confirmed, and it was the one thing hidden.
+ *
+ * Rendered in the same shorthand `--avatar` accepts, so what is printed is what
+ * can be typed back. An ABSENT avatar is kept apart from an explicit
+ * `{type:'default'}`: both show the platform logo, but only the absent one was
+ * never chosen, and that is exactly what `agents avatar default apply` rewrites.
+ */
+function agentAvatarLine(raw) {
+    if (raw == null) {
+        return 'none chosen — shows the platform logo (`agents avatar default apply` would fill it)';
+    }
+    const ref = raw;
+    switch (ref.type) {
+        case 'default':
+            return 'default — the platform logo, chosen';
+        case 'preset': {
+            const id = typeof ref.id === 'string' ? ref.id : '';
+            const preset = (0, data_provider_1.getAgentAvatarPreset)(id);
+            return preset ? `preset:${id} (${preset.name})` : `preset:${id} (not in this build)`;
+        }
+        case 'asset':
+            return `asset:${typeof ref.id === 'string' ? ref.id : '?'} (from your avatar library)`;
+        case 'image':
+            return 'an uploaded image';
+        default:
+            return 'unrecognised value — see `--json`';
+    }
+}
+/** The scene-background line, in the shorthand `--scene-background` accepts. */
+function agentSceneBackgroundLine(raw) {
+    const ref = (raw ?? { type: 'default' });
+    if (ref.type === 'default')
+        return 'default';
+    if (ref.type === 'preset') {
+        const id = typeof ref.id === 'string' ? ref.id : '';
+        const preset = data_provider_1.AGENT_SCENE_BACKGROUND_PRESETS.find((candidate) => candidate.id === id);
+        return preset ? `preset:${id} (${preset.name})` : `preset:${id} (not in this build)`;
+    }
+    if (ref.type === 'image')
+        return 'an uploaded image';
+    return 'unrecognised value — see `--json`';
+}

package/dist/lib/agentic-stream.d.ts

@@ -1,3 +1,9 @@
+/**
+ * The answer a question gets when no terminal exists to ask it on. Written to the
+ * agent, so it says what happened and what to do rather than pretending a person
+ * replied.
+ */
+export declare const NON_INTERACTIVE_QUESTION_ANSWER: string;
 export type AgenticStreamEvent = {
     type: string;
     sessionId?: string;

package/dist/lib/agentic-stream.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgenticStreamClient = exports.USER_CONNECTION_CAP_CODE = void 0;
+exports.AgenticStreamClient = exports.USER_CONNECTION_CAP_CODE = exports.NON_INTERACTIVE_QUESTION_ANSWER = void 0;
 exports.writeJsonLine = writeJsonLine;
 exports.envelopesText = envelopesText;
 exports.envelopeKey = envelopeKey;
@@ -19,6 +19,13 @@ const socket_io_client_1 = require("socket.io-client");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const config_1 = require("./config");
 const publicEndpoints_generated_1 = require("./publicEndpoints.generated");
+/**
+ * The answer a question gets when no terminal exists to ask it on. Written to the
+ * agent, so it says what happened and what to do rather than pretending a person
+ * replied.
+ */
+exports.NON_INTERACTIVE_QUESTION_ANSWER = 'No answer: this turn was started non-interactively (no terminal), so nobody can reply to ' +
+    'questions. Proceed with your best judgement, or finish by stating exactly what you need.';
 /**
  * Write exactly one complete JSON value on one line.
  *
@@ -667,10 +674,25 @@ class AgenticStreamClient {
     async handleQuestion(event) {
         if (this.closed)
             return;
+        // The same question can arrive twice (both delivery paths carry it — a
+        // non-interactive run showed two `question.requested` for one questionId,
+        // each answered). Answer it once, as tool events are emitted once.
+        if (!this.firstTimeSeen('question', event.questionId))
+            return;
         this.emit({ ...event, type: 'question.requested' });
+        // Nobody can answer a question in a run with no terminal. This used to
+        // prompt on stdin anyway: a scripted `agents chat --jsonl` printed the
+        // question and a `>` to stderr, read nothing, and the turn sat for the
+        // server's full 300-second question timeout — then ended with the agent told
+        // "Not answered … timed out", at the cost of the whole wait. Answer at once
+        // instead, saying why, so the agent proceeds or states what it needs. An
+        // explicit `input` (tests, an embedding caller) is treated as interactive.
+        const interactive = this.options.input !== undefined || Boolean(process.stdin.isTTY);
         const answers = {};
         for (const question of event.questions ?? []) {
-            const answer = await this.ask(`${question.header ?? 'Question'}: ${question.question}\n> `);
+            const answer = interactive
+                ? await this.ask(`${question.header ?? 'Question'}: ${question.question}\n> `)
+                : exports.NON_INTERACTIVE_QUESTION_ANSWER;
             answers[question.header ?? question.question] = answer;
         }
         if (event.questionId && this.socket) {
@@ -680,7 +702,12 @@ class AgenticStreamClient {
                 answers,
             });
         }
-        this.emit({ type: 'question.answered', questionId: event.questionId, answers });
+        this.emit({
+            type: 'question.answered',
+            questionId: event.questionId,
+            answers,
+            ...(interactive ? {} : { nonInteractive: true }),
+        });
     }
     ask(prompt) {
         // A prompt raised after close has nobody to answer it, and re-creating the
@@ -773,6 +800,10 @@ class AgenticStreamClient {
             output.write(`\n[${event.type}]\n`);
             this.renderedText = this.accumulated;
         }
+        else if (event.type === 'question.answered' && event.nonInteractive) {
+            output.write('\n[question] no terminal to answer on, so the agent was told to proceed without an answer\n');
+            this.renderedText = this.accumulated;
+        }
     }
     finish(status, event) {
         if (this.settled)

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

@@ -33,7 +33,7 @@ export type ResolutionFailure = {
      * NO_SPACE   — the reference needs a membership list to match against, but
      *              the task/payload has no space, so only raw ids are possible.
      */
-    code: 'NOT_FOUND' | 'AMBIGUOUS' | 'NO_SPACE';
+    code: 'NOT_FOUND' | 'AMBIGUOUS' | 'NO_SPACE' | 'NOT_A_REFERENCE';
     query: string;
     kind: MemberKind;
     /** For AMBIGUOUS: the tied matches. For NOT_FOUND: everything available. */

package/dist/lib/assignee-resolver.js

@@ -7,6 +7,7 @@ exports.describeMember = describeMember;
 exports.describeCandidates = describeCandidates;
 exports.resolveAssigneeReferences = resolveAssigneeReferences;
 exports.formatResolutionFailure = formatResolutionFailure;
+const failed_lookup_1 = require("./failed-lookup");
 const data_provider_1 = require("@skrr-ai/data-provider");
 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}$/;
@@ -84,6 +85,11 @@ function resolveMember(query, members, kind) {
     if (!q) {
         return { ok: false, code: 'NOT_FOUND', query: raw, kind, candidates: pool };
     }
+    // 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, kind, candidates: [] };
+    }
     const tiers = [
         // 1. Exact id. Case-sensitive on purpose — ids are opaque.
         (m) => m.id === raw,
@@ -186,6 +192,8 @@ function formatResolutionFailure(failure, bin = 'skrr') {
     const noun = failure.kind === 'user' ? 'person' : 'agent';
     const plural = failure.kind === 'user' ? 'people' : 'agents';
     switch (failure.code) {
+        case 'NOT_A_REFERENCE':
+            return (0, failed_lookup_1.describeFailedLookupValue)(failure.query, noun);
         case 'AMBIGUOUS':
             return (`"${failure.query}" matches ${failure.candidates.length} ${plural} in this space:\n` +
                 `${describeCandidates(failure.candidates)}\n` +

package/dist/lib/bulk-task-targets.d.ts

@@ -29,6 +29,18 @@ export type BulkApplyResult = {
  * semantics match `skrr tasks bulk-update`). `apply` returns whether the task
  * actually changed (already-satisfied tasks are reported as no-ops).
  */
+/**
+ * The server's reason for a failed per-task write, not the transport's.
+ *
+ * A bulk run used to record `err.message`, which for a dataService call is the
+ * transport line — `HTTP 400 Bad Request — PATCH https://…/api/tasks/<id>` — so
+ * `tasks actions attach --all-in-space` printed that once per task and named
+ * neither the ref nor the rule that refused it (OSK-9652). The same call made
+ * for a single task goes through `handleApiError`, which reads the body. This
+ * reads it the same way: `message`, then `error`, plus the first validation
+ * detail when the server sent one.
+ */
+export declare function bulkFailureMessage(err: unknown): string;
 export declare function applyToTaskTargets(targets: Array<{
     id: string;
     identifier?: string;

package/dist/lib/bulk-task-targets.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listSpaceTaskTargets = listSpaceTaskTargets;
+exports.bulkFailureMessage = bulkFailureMessage;
 exports.applyToTaskTargets = applyToTaskTargets;
 exports.formatBulkOutcome = formatBulkOutcome;
 exports.parseStatusFilter = parseStatusFilter;
@@ -34,6 +35,38 @@ async function listSpaceTaskTargets(options) {
  * semantics match `skrr tasks bulk-update`). `apply` returns whether the task
  * actually changed (already-satisfied tasks are reported as no-ops).
  */
+/**
+ * The server's reason for a failed per-task write, not the transport's.
+ *
+ * A bulk run used to record `err.message`, which for a dataService call is the
+ * transport line — `HTTP 400 Bad Request — PATCH https://…/api/tasks/<id>` — so
+ * `tasks actions attach --all-in-space` printed that once per task and named
+ * neither the ref nor the rule that refused it (OSK-9652). The same call made
+ * for a single task goes through `handleApiError`, which reads the body. This
+ * reads it the same way: `message`, then `error`, plus the first validation
+ * detail when the server sent one.
+ */
+function bulkFailureMessage(err) {
+    const e = err;
+    if (e && typeof e.body === 'string' && e.body.trim()) {
+        try {
+            const body = JSON.parse(e.body);
+            const reason = [body.message, body.error].find((value) => typeof value === 'string' && value.trim().length > 0);
+            if (reason) {
+                const detail = Array.isArray(body.details) ? body.details[0] : undefined;
+                const detailText = detail && typeof detail.message === 'string'
+                    ? ` — ${Array.isArray(detail.path) && detail.path.length ? `${detail.path.join('.')}: ` : ''}${detail.message}`
+                    : '';
+                const status = typeof e.status === 'number' ? ` (HTTP ${e.status})` : '';
+                return `${reason}${detailText}${status}`;
+            }
+        }
+        catch {
+            /* not JSON: fall back to the transport message below */
+        }
+    }
+    return err instanceof Error ? err.message : String(err);
+}
 async function applyToTaskTargets(targets, apply) {
     const result = { succeeded: [], failed: [] };
     for (const target of targets) {
@@ -46,7 +79,7 @@ async function applyToTaskTargets(targets, apply) {
             result.failed.push({
                 id: target.id,
                 label,
-                error: err instanceof Error ? err.message : String(err),
+                error: bulkFailureMessage(err),
             });
         }
     }