@skrr-ai/cli 0.1.37 → 0.1.38

package/dist/commands/tasks/show.js

@@ -1,14 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskPointerLines = taskPointerLines;
 exports.taskFailureLines = taskFailureLines;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const api_fetch_1 = require("../../lib/api-fetch");
 const session_task_endpoints_1 = require("../../lib/session-task-endpoints");
 const base_command_1 = require("../../base-command");
+const task_closure_1 = require("../../lib/task-closure");
 const task_resolver_1 = require("../../lib/task-resolver");
 const web_url_1 = require("../../lib/web-url");
 const html_text_1 = require("../../lib/html-text");
+/**
+ * Where to look next — as COMMANDS, not as facts about the task.
+ *
+ * These used to print as `What the agent produced: skrr tasks output <ref>`,
+ * in the same `Label: value` grammar as every line above them, so the line read
+ * as a statement of what the agent had produced. It also printed on tasks no
+ * agent had ever run, asserting output that did not exist (OSK-9669). They are
+ * now a visibly separate list, and only once a run, a conversation or a Result
+ * exists for them to show.
+ */
+function taskPointerLines(t, ref, bin = 'skrr') {
+    const hasSomethingToShow = Boolean(t.conversationId || t.lastFinalizedRunId || t.checkoutRunId || t.currentResultId);
+    if (!hasSomethingToShow)
+        return [];
+    const pointers = [
+        [`${bin} tasks output ${ref}`, 'what the agent produced'],
+    ];
+    if (t.conversationId) {
+        pointers.push([`${bin} tasks transcript ${ref}`, 'the full agent transcript']);
+    }
+    const width = Math.max(...pointers.map(([command]) => command.length));
+    return [
+        '',
+        'See also:',
+        ...pointers.map(([command, what]) => `  ${command.padEnd(width)}  ${what}`),
+    ];
+}
 /**
  * The failure rows of `tasks show`, when there are any. (S3 dogfood finding)
  *
@@ -179,13 +208,80 @@ class TasksShow extends base_command_1.BaseCommand {
          * it stood on at close. Show it so a bare "done" never reads as "clean."
          */
         const resolution = t.resolution;
-        if (resolution?.closure && resolution.closure.closable === false) {
-            const parts = [];
-            const unmet = resolution.closure.expectations?.unmet?.length ?? 0;
-            if (unmet > 0)
-                parts.push(`${unmet} Expectation${unmet === 1 ? '' : 's'} still unmet`);
-            parts.push(...(resolution.closure.blockers || []).filter((c) => c !== 'TASK_EXPECTATIONS_NOT_MET'));
-            this.log(`Resolution:  ${resolution.kind ?? '-'} — closed over ${parts.join('; ') || 'outstanding items'}`);
+        /*
+         * Same renderer as the `tasks move` receipt, so the two cannot disagree
+         * about a Task they are both describing.
+         *
+         * This copy showed an owner's ordinary close as an override:
+         * `TASK_RESULT_REVIEW_REQUIRED` lands in `blockers` whenever the policy is
+         * unsatisfied — including when the owner, who is not bound by the Review
+         * they declared, closes it themselves — and this rendered it identically to
+         * a genuine forced close. So the only read surface for "was this gate
+         * overridden?" could not answer the question.
+         */
+        if (resolution?.closure) {
+            const sentences = (0, task_closure_1.closureSnapshotLines)(resolution.closure);
+            if (sentences.length > 0) {
+                this.log(`Resolution:  ${resolution.kind ?? '-'} — ${sentences.join(' ')}`);
+            }
+        }
+        /*
+         * A Result orphaned by a spec edit is not the same as no Result.
+         *
+         * Editing a `description` or an Expectation advances `specVersion`, which
+         * unsets `currentResultId` by design — the old answer replied to a question
+         * that has changed. But every CLI surface then reported the Task as though
+         * nothing had ever been submitted, and the prior Result is still there. The
+         * web already says this correctly ("No Result answers the current Task spec
+         * vN", plus the previous one); the CLI said nothing at all.
+         *
+         * The extra request is paid only in the ambiguous case — when there is no
+         * current Result — and `tasks show` is a detail view, so one call to
+         * distinguish "nobody answered" from "the answer is out of date" is worth
+         * it. A failed lookup degrades to silence rather than to a claim.
+         */
+        const taskSpecVersion = Number(t.specVersion) || 1;
+        if (t.currentResultId) {
+            this.log(`Result:      ${String(t.currentResultId)} (answers spec v${taskSpecVersion})`);
+            /*
+             * The Review on that Result, with its REASON.
+             *
+             * Closing over a `changes_requested` Review is allowed and recorded, and
+             * the closure line says "a reviewer requested changes" — the verdict. What
+             * they asked for lived only on the Review row, which no text surface
+             * printed, so the objection survived as a fact and lost its content. One
+             * read, on a detail view, only when there is a Result to have been
+             * reviewed; a failed read says nothing rather than implying no Review.
+             */
+            try {
+                const history = await data_provider_1.dataService.listTaskResults(taskIdentity.id);
+                const review = (history?.reviews || []).find((row) => row.resultId === String(t.currentResultId));
+                if (review) {
+                    const who = (0, task_closure_1.describeAssessor)(review.reviewedBy?.kind);
+                    const when = review.reviewedAt ? ` on ${String(review.reviewedAt).slice(0, 10)}` : '';
+                    const why = review.rationale ? `: ${review.rationale}` : '';
+                    this.log(`Review:      ${review.decision} by ${who}${when}${why}`);
+                }
+            }
+            catch {
+                // Silence, not "no Review": this read failing is not evidence of absence.
+            }
+        }
+        else {
+            let priorLine = 'none submitted';
+            try {
+                const history = await data_provider_1.dataService.listTaskResults(taskIdentity.id);
+                const prior = history?.results?.[0];
+                if (prior) {
+                    priorLine =
+                        `none answers spec v${taskSpecVersion} — previous v${prior.version} ` +
+                            `answered spec v${prior.specVersion ?? '?'}`;
+                }
+            }
+            catch {
+                priorLine = 'none answers the current spec (earlier Results could not be read)';
+            }
+            this.log(`Result:      ${priorLine}`);
         }
         this.log(`Executor:    ${t.executionMode ?? 'legacy / inferred'}`);
         this.log(`Priority:    ${t.priority ?? '-'}`);
@@ -333,11 +429,8 @@ class TasksShow extends base_command_1.BaseCommand {
             // Silent: a Task this caller can VIEW but whose acceptance they cannot
             // read is a permissions shape, not something to shout about mid-page.
         }
-        this.log('');
-        this.log(`What the agent produced: skrr tasks output ${ref}`);
-        if (t.conversationId) {
-            this.log(`Full agent transcript:   skrr tasks transcript ${ref}`);
-        }
+        for (const line of taskPointerLines(t, ref, this.config.bin))
+            this.log(line);
     }
 }
 exports.default = TasksShow;

package/dist/commands/tasks/trust.js

@@ -41,8 +41,13 @@ class TasksTrust extends base_command_1.BaseCommand {
         level: core_1.Flags.string({
             options: [...data_provider_1.DELIVERABLE_AUTHORITIES],
             required: true,
-            description: 'How well evidenced the answer must be: self_reported (the doer says so), ' +
-                'human_confirmed (someone else looked), observation_backed (the platform saw it).',
+            description: 
+            // `observation_backed` is a RETIRED rung name for this domain — the flag
+            // rejects it, so the only two values the help explained were one real one
+            // and one the command refuses. The four the enum actually accepts:
+            'How well evidenced the answer must be: self_reported (the doer says so), ' +
+                'human_confirmed (a person confirmed it), system_observed (the platform saw it), ' +
+                'external_receipt (a provider receipt proves it).',
         }),
         reason: core_1.Flags.string({
             required: true,

package/dist/commands/tasks/update.js

@@ -251,26 +251,62 @@ class TasksUpdate extends base_command_1.BaseCommand {
          * rewrote the list and revoked the assessments with no warning at all.
          * Same write, same price: the disclosure belongs on the effective change.
          */
-        if (expectationsPatch !== undefined || body.expectations !== undefined) {
-            let settledCount = 0;
+        /*
+         * The DESCRIPTION is a spec field too.
+         *
+         * `TaskSpecFence.TASK_SPEC_FIELDS` is `['description', 'expectations']`, and
+         * both advance `specVersion` — which revokes every assessment, because they
+         * are matched by exact version. The disclosure was wired to the Expectations
+         * payload alone, so fixing a typo in the prose voided a reviewer's sign-off
+         * with no warning and no receipt. Same write, same price, same disclosure.
+         */
+        const changesSpec = expectationsPatch !== undefined ||
+            body.expectations !== undefined ||
+            flags.description !== undefined ||
+            body.description !== undefined;
+        if (changesSpec) {
+            let settled = [];
+            let unreadable = false;
             try {
                 const acceptance = await data_provider_1.dataService.getTaskAcceptance(taskIdentity.id);
-                settledCount = acceptance.expectations.filter((e) => e.assessmentId).length;
+                settled = acceptance.expectations.filter((e) => e.assessmentId);
             }
             catch {
                 // An unreadable acceptance is not a reason to refuse the edit. Warn
                 // without a number rather than inventing one or blocking the write.
-                settledCount = -1;
+                unreadable = true;
             }
-            if (settledCount !== 0 && !flags.yes) {
-                const noun = settledCount === 1 ? 'assessment' : 'assessments';
-                const count = settledCount < 0 ? 'Any existing' : `${settledCount} existing`;
-                this.log(`Changing Expectations advances the Task specification, so ${count} ${noun} ` +
+            if ((unreadable || settled.length > 0) && !flags.yes) {
+                const noun = settled.length === 1 ? 'assessment' : 'assessments';
+                const count = unreadable ? 'Any existing' : `${settled.length} existing`;
+                const field = expectationsPatch !== undefined || body.expectations !== undefined
+                    ? 'Changing Expectations'
+                    : 'Changing the description';
+                this.log(`${field} advances the Task specification, so ${count} ${noun} ` +
                     'will stop counting and must be recorded again.');
+                /*
+                 * NAME them. The count alone made the warning unactionable — and it is
+                 * task-WIDE, so Expectations you are not touching lose their judgements
+                 * too, which a bare number actively hides.
+                 */
+                for (const row of settled) {
+                    this.log(`  ${row.id}  ${row.sentence || row.text || ''}`);
+                }
+                if (settled.length > 0) {
+                    this.log('Revocation covers every Expectation on this Task, including ones this edit ' +
+                        'does not touch.');
+                }
                 const ok = await this.confirm('Continue? [y/N] ');
                 if (!ok) {
-                    this.log('No change made.');
-                    return;
+                    /*
+                     * Non-zero, because the edit did NOT happen.
+                     *
+                     * This printed "No change made." and exited 0, so `skrr tasks update
+                     * … && echo applied` printed `applied`. The guard exists to protect
+                     * the non-interactive path, and the non-interactive path is precisely
+                     * the one that cannot see a message — it can only read the exit code.
+                     */
+                    this.error('No change made — re-run with `--yes` to accept the revocation.', { exit: 2 });
                 }
             }
         }

package/dist/commands/tasks/updates/add.js

@@ -42,7 +42,7 @@ class TasksUpdatesAdd extends base_command_1.BaseCommand {
                 'fields are required even when empty. ' +
                 'progress {completedSinceLast:[],nextActions:[],currentFocus?} · ' +
                 'finding {finding,evidenceRefs:[],impact?,severity?} · ' +
-                'decision {decision,rationale,alternativesConsidered?} · ' +
+                'decision {decision,rationale,alternativesConsidered?:[]} · ' +
                 'blocker {cause,requiredAction,nextOwner} · ' +
                 'verification {claim,result:passed|failed|inconclusive,evidenceRefs:[]}. ' +
                 'nextOwner is a principal object like {"kind":"human","userId":"..."}, not a name. ' +

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

@@ -0,0 +1,22 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr token list`
+ *
+ * The other half of `token mint`. Minting binds a long-lived refresh session to
+ * a machine and records the `--label` with it — which reads as a promise that
+ * the credential can be found again — and there was no way to see it: `token`
+ * had only `mint`, and `list-tokens` shows CI tokens, a different credential
+ * type, so `revoke-token` had nothing to aim at. The only remedy was
+ * `logout --all-devices`, which signs every machine out.
+ *
+ * `GET /api/auth/sessions/refresh` has served exactly this list all along; it
+ * was simply not reachable from the CLI.
+ */
+export default class TokenList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/token/list.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const api_fetch_1 = require("../../lib/api-fetch");
+const format_1 = require("../../lib/format");
+/**
+ * `skrr token list`
+ *
+ * The other half of `token mint`. Minting binds a long-lived refresh session to
+ * a machine and records the `--label` with it — which reads as a promise that
+ * the credential can be found again — and there was no way to see it: `token`
+ * had only `mint`, and `list-tokens` shows CI tokens, a different credential
+ * type, so `revoke-token` had nothing to aim at. The only remedy was
+ * `logout --all-devices`, which signs every machine out.
+ *
+ * `GET /api/auth/sessions/refresh` has served exactly this list all along; it
+ * was simply not reachable from the CLI.
+ */
+class TokenList extends base_command_1.BaseCommand {
+    static description = 'List the active sessions a minted token belongs to — the other half of `token mint`';
+    static examples = [
+        '<%= config.bin %> token list',
+        '<%= config.bin %> token list --json',
+    ];
+    static flags = { json: core_1.Flags.boolean({ description: 'Output JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(TokenList);
+        let data = null;
+        try {
+            data = await (0, api_fetch_1.apiFetch)('/api/auth/sessions/refresh', {
+                method: 'GET',
+                credential: this.resolvedCredential,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const sessions = data?.sessions || [];
+        if (flags.json)
+            return this.log(JSON.stringify({ sessions, count: sessions.length }, null, 2));
+        if (!sessions.length)
+            return this.log('No active sessions.');
+        (0, format_1.renderTable)(sessions.map((session) => ({
+            id: session.id,
+            kind: session.kind,
+            // The operator's own name for the credential wins over a derived
+            // device string — it is what they would search by.
+            device: session.label || session.device || '-',
+            ip: session.ip || '-',
+            lastActive: session.lastActiveAt || session.createdAt || '-',
+            // The session you are typing in. Revoking it signs THIS machine out,
+            // which is the one outcome nobody means when they revoke a credential.
+            current: session.current ? 'yes' : '',
+        })), [
+            { key: 'id', header: 'ID' },
+            { key: 'kind', header: 'KIND' },
+            { key: 'device', header: 'DEVICE', maxWidth: 34 },
+            { key: 'ip', header: 'IP' },
+            { key: 'lastActive', header: 'LAST ACTIVE' },
+            { key: 'current', header: 'CURRENT' },
+        ], (line) => this.log(line));
+        this.log('');
+        this.log('Retire one with: skrr token revoke <id>');
+    }
+}
+exports.default = TokenList;

package/dist/commands/token/revoke.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr token revoke <id>`
+ *
+ * Retire ONE session — the credential `token mint` handed to one machine —
+ * without signing every other machine out. `logout --all-devices` was the only
+ * way to do this, which is a blunt instrument for "that one CI box is
+ * decommissioned".
+ *
+ * Owner-gated server-side: a row that is not the caller's returns
+ * `{ revoked: false }` rather than an error, so ids cannot be enumerated.
+ */
+export default class TokenRevoke extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/token/revoke.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const api_fetch_1 = require("../../lib/api-fetch");
+/**
+ * `skrr token revoke <id>`
+ *
+ * Retire ONE session — the credential `token mint` handed to one machine —
+ * without signing every other machine out. `logout --all-devices` was the only
+ * way to do this, which is a blunt instrument for "that one CI box is
+ * decommissioned".
+ *
+ * Owner-gated server-side: a row that is not the caller's returns
+ * `{ revoked: false }` rather than an error, so ids cannot be enumerated.
+ */
+class TokenRevoke extends base_command_1.BaseCommand {
+    static description = 'Revoke one session by id — see `skrr token list` for the ids';
+    static examples = ['<%= config.bin %> token revoke 665f1c2e9a4b3d0011aa77bc'];
+    static args = {
+        id: core_1.Args.string({
+            required: true,
+            ignoreStdin: true,
+            description: 'Session id from `skrr token list`',
+        }),
+    };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TokenRevoke);
+        let data = null;
+        try {
+            data = await (0, api_fetch_1.apiFetch)(`/api/auth/sessions/refresh/${encodeURIComponent(args.id)}/revoke`, {
+                method: 'POST',
+                credential: this.resolvedCredential,
+                body: {},
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(data, null, 2));
+        if (data?.revoked)
+            return this.log(`Revoked session ${args.id}. Other machines stay signed in.`);
+        // The server does not distinguish "already gone" from "not yours" on
+        // purpose, so neither does this — saying "not found" would leak the
+        // difference and let somebody probe for ids.
+        this.log(`Nothing to revoke for ${args.id} — it is already revoked, or it is not one of your sessions.`);
+        this.log('List what is active with: skrr token list');
+    }
+}
+exports.default = TokenRevoke;

package/dist/lib/agent-actions.d.ts

@@ -1,11 +1,50 @@
 import type { Agent, AgentAction, AgentActionOutcome, AgentActionScope, BuiltinActionConfig, BuiltinActionType, BuiltinAgentAction, EmbeddedActionRef, PromptAgentAction } from '@skrr-ai/data-provider';
-export declare const BUILTIN_ACTION_TYPES: readonly ["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"];
+export { BUILTIN_ACTION_TYPES } from '@skrr-ai/data-provider';
 export declare const ACTION_TARGET_TYPES: readonly ["group-chats", "spaces", "tasks", "goals", "slack-channels", "slack-users"];
 export type ActionTargetType = (typeof ACTION_TARGET_TYPES)[number];
 export declare function parseJsonObjectFlag(value: string | undefined, flagName: string): Record<string, unknown> | undefined;
 export declare function fetchAgentForActionEdit(agentId: string): Promise<Agent>;
 export declare function getAgentActions(agent: Agent): AgentAction[];
 export declare function findAgentAction(agent: Agent, actionId: string): AgentAction | undefined;
+/**
+ * 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.
+ */
+export declare function storedActionOrLocal(agent: Agent | null | undefined, local: AgentAction): AgentAction;
+export type AppendedAgentAction = {
+    /** The action as the server stored it. */
+    action: AgentAction;
+    /** False when this id was already in the library — a replayed request. */
+    created: boolean;
+    total: number;
+};
+/**
+ * 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.
+ */
+export declare function appendAgentAction(agentId: string, action: AgentAction): Promise<AppendedAgentAction>;
 export declare function updateAgentActions(agentId: string, actions: AgentAction[]): Promise<Agent>;
 /**
  * Fields every action shape carries regardless of kind.
@@ -52,7 +91,23 @@ export type AgentActionScopeFlags = {
  * `--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.
  */
-export declare function resolveAgentActionScopeFlags(flags: AgentActionScopeFlags): AgentActionScope | undefined;
+/**
+ * `--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.
+ */
+export declare function resolveAgentActionScopeFlags(flags: AgentActionScopeFlags): Promise<AgentActionScope | undefined>;
 /** Human-readable one-liner for a scope, used by list/show renderers. */
 export declare function describeAgentActionScope(scope?: AgentActionScope | null): string;
 export declare function nextActionOrder(actions: AgentAction[]): number;