@skrr-ai/cli 0.1.86 → 0.1.88

package/dist/commands/machines/unshare.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const machines_1 = require("../../lib/machines");
+const machine_grants_1 = require("../../lib/machine-grants");
+/**
+ * `skrr machines unshare` — revoke one person's grant on a machine (design §9;
+ * OSK-13558). Revocation bumps the machine's grant-set version, so its daemon
+ * detaches that person's attachments and releases any lease they hold when
+ * the new set arrives. Reversible — `machines share` grants again.
+ */
+class MachinesUnshare extends base_command_1.BaseCommand {
+    static description = 'Stop sharing a machine with a person — detaches their surfaces and releases their control lease';
+    static examples = [
+        '<%= config.bin %> machines unshare 03548116 68db4b2f0b4f5a9c1d2e3f40',
+    ];
+    static args = {
+        machine: core_1.Args.string({
+            ignoreStdin: true,
+            description: 'Machine id, uuid, daemon id, name, or a unique prefix',
+            required: true,
+        }),
+        user: core_1.Args.string({
+            ignoreStdin: true,
+            description: 'The user id of the person to stop sharing with',
+            required: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(MachinesUnshare);
+        let target;
+        try {
+            target = (0, machines_1.resolveMachineRef)(await (0, machines_1.listMachines)(), args.machine);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (!target) {
+            this.error('Machine not found.', { exit: 1 });
+        }
+        let result;
+        try {
+            result = await (0, machine_grants_1.unshareMachine)(target.id, args.user);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const label = target.preferences?.name || target.name || target.id;
+        this.log(`Stopped sharing ${label} with ${args.user}.`);
+    }
+}
+exports.default = MachinesUnshare;

package/dist/commands/tasks/labels/create.d.ts

@@ -3,6 +3,7 @@ export default class TasksLabelsCreate extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        'allow-duplicate-name': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

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

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 const prompt_1 = require("../../../lib/prompt");
+const label_scope_1 = require("../../../lib/label-scope");
 // Accept both `#e11d48` and `e11d48` forms; the server's Zod regex
 // (`api/server/routes/tasks.js:206`) is `/^[0-9a-fA-F]{6}$/` — NO leading
 // `#`. We normalize before sending so users can pass either form.
@@ -24,6 +25,7 @@ class TasksLabelsCreate extends base_command_1.BaseCommand {
         color: core_1.Flags.string({
             description: 'Label color as 6-digit hex, e.g. e11d48 (leading # is accepted and stripped)',
         }),
+        ...label_scope_1.allowDuplicateNameFlags,
     };
     async run() {
         this.requireAuth();
@@ -38,6 +40,7 @@ class TasksLabelsCreate extends base_command_1.BaseCommand {
         const payload = (0, prompt_1.mergeDefined)(jsonBody, {
             name: flags.name,
             color: flags.color,
+            allowDuplicateName: flags['allow-duplicate-name'] ? true : undefined,
         });
         if (!payload.name || typeof payload.name !== 'string') {
             this.error('A label name is required. Pass --name "..." or include it in --from-json.', {

package/dist/commands/views/create.d.ts

@@ -14,6 +14,7 @@ export default class ViewsCreate extends BaseCommand {
         priority: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         assignee: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         label: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'label-match': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         goal: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         project: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         search: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/views/create.js

@@ -35,6 +35,10 @@ class ViewsCreate extends base_command_1.BaseCommand {
         }),
         assignee: core_1.Flags.string({ multiple: true, description: 'Filter by agent or user ID' }),
         label: core_1.Flags.string({ multiple: true, description: 'Filter by label ID' }),
+        'label-match': core_1.Flags.string({
+            options: [...vocabulary_1.VIEW_LABEL_MATCH_VALUES],
+            description: 'How --label values combine: any (default) or all',
+        }),
         goal: core_1.Flags.string({ multiple: true, description: 'Filter by goal ID' }),
         project: core_1.Flags.string({ multiple: true, description: 'Filter by project ID' }),
         search: core_1.Flags.string({ description: 'Filter by title, identifier, or description' }),
@@ -67,6 +71,7 @@ class ViewsCreate extends base_command_1.BaseCommand {
             priorities: flags.priority,
             assignees: flags.assignee,
             labels: flags.label,
+            labelMatch: flags['label-match'],
             goalIds: flags.goal,
             projectIds: flags.project,
             search: flags.search,

package/dist/lib/agent-home-workspace.d.ts

@@ -17,3 +17,29 @@
 export declare function applyAgentHomeWorkspaceDefault(agentId: string, lookup: (agentId: string) => Promise<{
     workspaceId?: string | null;
 } | null | undefined>, env?: NodeJS.ProcessEnv): Promise<string | null>;
+/**
+ * The read half of `applyAgentHomeWorkspaceDefault`: the workspace a turn
+ * would default to, WITHOUT setting it.
+ *
+ * Split so `agents chat` can start the agent read at the same time as its
+ * other pre-flight reads (`--task`, `--thread-root`, `--local-skill`) instead
+ * of after them — each is a full round trip — while those reads still go out
+ * exactly as before, with no workspace header. The default is committed only
+ * right before the turn is started.
+ */
+export declare function lookupAgentHomeWorkspaceDefault(agentId: string, lookup: (agentId: string) => Promise<{
+    workspaceId?: string | null;
+} | null | undefined>, env?: NodeJS.ProcessEnv): Promise<string | null>;
+/**
+ * The write half: apply a looked-up default, unless something chose a
+ * workspace in the meantime (that choice still wins) or this is an autonomous
+ * Agent process.
+ */
+export declare function commitAgentHomeWorkspaceDefault(workspaceId: string | null, env?: NodeJS.ProcessEnv): string | null;
+/** Does this origin's server default a headerless chat turn's workspace itself? */
+export declare function serverAppliesAgentHomeDefault(cacheDir: string | undefined, baseURL: string | undefined, now?: number): boolean;
+/**
+ * Record what an acceptance says about the server, and return it. Writes only
+ * when the verdict changes or the observation is getting old.
+ */
+export declare function recordAgentHomeDefaultObservation(cacheDir: string | undefined, baseURL: string | undefined, accepted: unknown, now?: number): 'supported' | 'unsupported';

package/dist/lib/agent-home-workspace.js

@@ -1,6 +1,45 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAgentHomeWorkspaceDefault = applyAgentHomeWorkspaceDefault;
+exports.lookupAgentHomeWorkspaceDefault = lookupAgentHomeWorkspaceDefault;
+exports.commitAgentHomeWorkspaceDefault = commitAgentHomeWorkspaceDefault;
+exports.serverAppliesAgentHomeDefault = serverAppliesAgentHomeDefault;
+exports.recordAgentHomeDefaultObservation = recordAgentHomeDefaultObservation;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 /**
  * The workspace an `agents chat` turn runs in when the caller named none.
  *
@@ -18,6 +57,19 @@ exports.applyAgentHomeWorkspaceDefault = applyAgentHomeWorkspaceDefault;
  * daemon session.
  */
 async function applyAgentHomeWorkspaceDefault(agentId, lookup, env = process.env) {
+    return commitAgentHomeWorkspaceDefault(await lookupAgentHomeWorkspaceDefault(agentId, lookup, env), env);
+}
+/**
+ * The read half of `applyAgentHomeWorkspaceDefault`: the workspace a turn
+ * would default to, WITHOUT setting it.
+ *
+ * Split so `agents chat` can start the agent read at the same time as its
+ * other pre-flight reads (`--task`, `--thread-root`, `--local-skill`) instead
+ * of after them — each is a full round trip — while those reads still go out
+ * exactly as before, with no workspace header. The default is committed only
+ * right before the turn is started.
+ */
+async function lookupAgentHomeWorkspaceDefault(agentId, lookup, env = process.env) {
     if (env.OVERSKY_AUTONOMOUS_SESSION === '1')
         return null;
     if (env.OVERSKY_WORKSPACE_ID?.trim())
@@ -32,8 +84,130 @@ async function applyAgentHomeWorkspaceDefault(agentId, lookup, env = process.env
         return null;
     }
     const workspaceId = typeof agent?.workspaceId === 'string' ? agent.workspaceId.trim() : '';
+    return workspaceId || null;
+}
+/**
+ * The write half: apply a looked-up default, unless something chose a
+ * workspace in the meantime (that choice still wins) or this is an autonomous
+ * Agent process.
+ */
+function commitAgentHomeWorkspaceDefault(workspaceId, env = process.env) {
     if (!workspaceId)
         return null;
+    if (env.OVERSKY_AUTONOMOUS_SESSION === '1')
+        return null;
+    if (env.OVERSKY_WORKSPACE_ID?.trim())
+        return null;
     env.OVERSKY_WORKSPACE_ID = workspaceId;
     return workspaceId;
 }
+/**
+ * OSK-13599 — whether the server this CLI talks to chooses the agent-home
+ * workspace itself.
+ *
+ * A server that does (it defaults a headerless `POST /api/agentic/chat` to the
+ * agent's CURRENT home workspace, under exactly the checks the header would
+ * pass) makes the pre-flight agent read above redundant, and that read is a
+ * full round trip (~480ms at production RTT) on every turn.
+ *
+ * What is remembered is a fact about the SERVER, never the agent's workspace:
+ * agents move between workspaces, so caching their workspace could start a turn
+ * in the wrong one, while "this origin applies the default" stays true until
+ * the server is rolled back. The evidence is the acceptance itself — a server
+ * that applies the default always answers with a `workspaceSource` key (null
+ * included); an older one never does. So:
+ *
+ *   - first turn against an origin: no observation → the agent read happens,
+ *     exactly as before; the acceptance records the observation;
+ *   - later turns: the read is skipped and the server chooses;
+ *   - a rollback: the acceptance lacks the key, the observation is dropped and
+ *     the NEXT turn reads again. The one turn in between ran with no workspace
+ *     (the pre-OSK-9937 behaviour), which the command reports on stderr.
+ *
+ * Best-effort everywhere: an unreadable or unwritable cache is "not observed",
+ * which is today's behaviour, never an error.
+ */
+const SERVER_FEATURES_FILE = 'server-features.json';
+/** Re-confirm at most this often, so a supported server is not a write per turn. */
+const OBSERVATION_REFRESH_MS = 24 * 60 * 60 * 1000;
+/** An observation nobody has re-confirmed for this long is not trusted. */
+const OBSERVATION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+function originOf(baseURL) {
+    try {
+        return new URL(baseURL).origin;
+    }
+    catch {
+        return null;
+    }
+}
+function featuresPath(cacheDir) {
+    return path.join(cacheDir, SERVER_FEATURES_FILE);
+}
+function readFeatures(cacheDir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(featuresPath(cacheDir), 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Does this origin's server default a headerless chat turn's workspace itself? */
+function serverAppliesAgentHomeDefault(cacheDir, baseURL, now = Date.now()) {
+    if (!cacheDir || !baseURL)
+        return false;
+    const origin = originOf(baseURL);
+    if (!origin)
+        return false;
+    const seen = readFeatures(cacheDir)[origin];
+    if (seen?.agentHomeWorkspaceDefault !== true)
+        return false;
+    const at = Date.parse(seen.observedAt);
+    return Number.isFinite(at) && now - at <= OBSERVATION_MAX_AGE_MS;
+}
+/**
+ * Record what an acceptance says about the server, and return it. Writes only
+ * when the verdict changes or the observation is getting old.
+ */
+function recordAgentHomeDefaultObservation(cacheDir, baseURL, accepted, now = Date.now()) {
+    const supported = !!accepted && typeof accepted === 'object' && 'workspaceSource' in accepted;
+    const verdict = supported ? 'supported' : 'unsupported';
+    if (!cacheDir || !baseURL)
+        return verdict;
+    const origin = originOf(baseURL);
+    if (!origin)
+        return verdict;
+    try {
+        const features = readFeatures(cacheDir);
+        const previous = features[origin];
+        if (!supported && !previous)
+            return verdict;
+        const previousAt = previous ? Date.parse(previous.observedAt) : NaN;
+        if (supported &&
+            previous?.agentHomeWorkspaceDefault === true &&
+            Number.isFinite(previousAt) &&
+            now - previousAt < OBSERVATION_REFRESH_MS) {
+            return verdict;
+        }
+        if (supported) {
+            features[origin] = {
+                agentHomeWorkspaceDefault: true,
+                observedAt: new Date(now).toISOString(),
+            };
+        }
+        else {
+            delete features[origin];
+        }
+        fs.mkdirSync(cacheDir, { recursive: true, mode: 0o700 });
+        const file = featuresPath(cacheDir);
+        const tmp = `${file}.${process.pid}.${now}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(features), { mode: 0o600 });
+        fs.renameSync(tmp, file);
+    }
+    catch {
+        // Best-effort: the next turn simply reads the agent again.
+    }
+    return verdict;
+}

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

@@ -20,6 +20,12 @@ export type AgenticStreamResult = {
     responseMessageId?: string;
     text: string;
     status: 'completed' | 'aborted' | 'failed';
+    /**
+     * The run first failed as handed over (a deploy replaced the relaying server)
+     * and the machine's completed reply was then repaired onto the record
+     * (OSK-13543). Absent on every ordinary run.
+     */
+    repaired?: true;
     lastEvent?: AgenticStreamEvent;
 };
 /**
@@ -45,7 +51,82 @@ export type ReconciledTerminal = {
     text?: string;
     /** The recorded failure reason — `metadata.agentic.error` on the message. */
     error?: string;
+    /**
+     * The failure is a hand-over, not an ending (OSK-13543): the row is failed
+     * with {@link DAEMON_HANDOVER_REASON}, which the server itself treats as
+     * "outcome pending the machine's own turn-end".
+     */
+    handedOver?: boolean;
+};
+/**
+ * OSK-13517 / OSK-13543 — the one failure that is not an ending.
+ *
+ * A deploy replaced the server RELAYING a local-daemon turn while the daemon
+ * kept running it. The server saves the turn `error: true` with this reason
+ * (`metadata.agentic.errorSubtype`), keeps the conversation quarantined, and
+ * converges the row later from the machine's own turn-end: completed →
+ * repaired (`error: false`, `metadata.agentic.deliveryRepair`), anything else →
+ * settled failed (`errorSubtype: worker_replaced_daemon_failed`).
+ *
+ * Mirrors `WORKER_REPLACED_DAEMON_RUNNING_REASON` in
+ * `api/server/services/AgentWorker/workerReplacedNotice.js` and the code
+ * beside it in `daemonHandlers.js` / `conversationAdmissionClaim.js`; a parity
+ * spec reads those files so the two cannot drift.
+ */
+export declare const WORKER_REPLACED_CODE = "AGENT_WORKER_REPLACED";
+export declare const DAEMON_HANDOVER_REASON = "worker_replaced_daemon_running";
+/**
+ * Is this terminal event the hand-over failure, and nothing else?
+ *
+ * The server sends it on two paths with different shapes, so the reason is
+ * read wherever either puts it:
+ *   - the QueueEvents backstop (`queue.js`): `{code: 'AGENT_WORKER_REPLACED',
+ *     errorType: 'worker_replaced_daemon_running', errors}`;
+ *   - the worker's own result (`buildExecutionErrorEvent`): `errorType` and
+ *     `reason` both carry the daemon reason, `code` only when the result had one.
+ * The plain deploy failure shares the CODE (`errorType: 'worker_replaced'`, the
+ * turn really ended), so the code alone must never qualify, and a code that
+ * is present but different disqualifies.
+ */
+export declare function isDaemonHandoverFailure(event: Record<string, unknown> | null | undefined): boolean;
+/** What the durable record says about a handed-over turn, read while waiting. */
+export type HandoverReading = 
+/** Still failed with the hand-over reason, or not yet written: keep waiting. */
+{
+    state: 'pending';
+}
+/** The machine finished and the server repaired the row. */
+ | {
+    state: 'repaired';
+    text: string;
+    repairedAt?: string;
+}
+/** The machine's turn ended without finishing, and the server settled it so. */
+ | {
+    state: 'failed';
+    error: string;
+    text?: string;
+};
+export type HandoverWaitOptions = {
+    /** Read the persisted response message. A throw or null is "no evidence". */
+    read: () => Promise<HandoverReading | null>;
+    /** The response message the repair notification names. */
+    responseMessageId?: string;
+    conversationId?: string;
+    /** How long to wait for the machine's reply. 0 disables the wait. */
+    maxWaitMs: number;
+    /** Fallback re-read cadence when no notification arrives. Default 15s. */
+    pollIntervalMs?: number;
+    /**
+     * Where the human status line goes when stdout is reserved for the final
+     * result (`--no-stream`). Default stderr.
+     */
+    statusOutput?: NodeJS.WritableStream;
 };
+/** Default fallback re-read cadence while waiting on a handed-over turn. */
+export declare const HANDOVER_POLL_INTERVAL_MS = 15000;
+/** `600000` → `10m`, `90000` → `1m30s`, `45000` → `45s`. */
+export declare function formatWaitDuration(ms: number): string;
 /**
  * Write exactly one complete JSON value on one line.
  *
@@ -106,6 +187,12 @@ export type AgenticStreamOptions = {
      * owns that stream and its contract does not include diagnostics.
      */
     debug?: (line: string) => void;
+    /**
+     * OSK-13543 — wait for a handed-over local-daemon turn instead of ending on
+     * its failure. See {@link isDaemonHandoverFailure}. Omitted: today's
+     * behaviour, every `execution:error` settles the run at once.
+     */
+    awaitHandover?: HandoverWaitOptions;
     /** Silence before the first durable-record probe. Default 20s. */
     idleTerminalProbeMs?: number;
     /** How long to keep trying to attach before reporting a detach. Default 30s. */
@@ -493,6 +580,11 @@ export declare class AgenticStreamClient {
      * a reconciled detach report the real outcome instead of the detach.
      */
     private terminalResult;
+    /**
+     * A handed-over turn being waited on (OSK-13543): the failure event that
+     * started the wait, and the timers bounding it. Null otherwise.
+     */
+    private handover;
     private resolve;
     private reject;
     /** The terminal result, or null while the run is still in flight. */
@@ -542,6 +634,44 @@ export declare class AgenticStreamClient {
     probeTerminal(reason: string): Promise<boolean>;
     cancel(reason?: string): void;
     close(): void;
+    /**
+     * True while a handed-over turn is being waited on (OSK-13543). A Ctrl-C in
+     * this state stops the wait; it cannot cancel the machine's turn.
+     */
+    awaitingHandover(): boolean;
+    /**
+     * OSK-13543 — the run failed because a deploy replaced the server relaying a
+     * turn the machine is still running. That failure is the server's PROVISIONAL
+     * verdict: it keeps the conversation held and rewrites the row from the
+     * machine's own turn-end. Ending here told a CLI user "failed" about a turn
+     * whose answer the web showed ninety seconds later.
+     *
+     * So keep the stream, the user-room subscription and the envelope replay
+     * open, and settle on what the RECORD converges to: repaired → completed,
+     * settled failed → failed with the machine's reason, neither within the
+     * bound → the original failure. The record, not the notification, decides:
+     * a notification only says "read again", so a lost or duplicated one costs
+     * at most a poll interval.
+     *
+     * Returns false (and changes nothing) when the run cannot wait: no hand-over
+     * reader configured, a zero bound, or a run already settling.
+     */
+    private beginHandoverWait;
+    /** Ask the record again; coalesces with a read already in flight. */
+    private requestHandoverRead;
+    /** One read of the record. True when it settled the run. */
+    private readHandover;
+    /** The bound ran out: one last look, then the original failure. */
+    private expireHandover;
+    private stopHandoverTimers;
+    private endHandover;
+    /**
+     * The server's "this row was rewritten" notice (`lateDeliveryRepair`
+     * `notifyViewersMessageRewritten`), delivered to every socket of the user
+     * through the `user:<id>` room this socket joins on connect. A hint to read,
+     * never a verdict.
+     */
+    private onConversationUpdate;
     private debug;
     /**
      * Record a hole being passed over — the moment replay has given up on it.
@@ -622,6 +752,11 @@ export declare class AgenticStreamClient {
      */
     private emitToolEvent;
     private emit;
+    /**
+     * Human-mode lines for the hand-over wait. Returns true when the event is
+     * fully rendered here; false lets the ordinary rendering continue.
+     */
+    private renderHandoverStatus;
     private finish;
     private finishAfterReplay;
     /**