@skrr-ai/cli 0.1.24 → 0.1.25

package/dist/base-command.d.ts

@@ -199,10 +199,10 @@ export declare abstract class BaseCommand extends Command {
      *
      * Shared by every command that accepts an assignee reference. A failure is
      * fatal rather than a silent fall-back to a global directory search: the
-     * server only accepts assignees who are members of the space
-     * (`ASSIGNEE_NOT_IN_SPACE`), so widening the lookup could only ever produce
-     * a request guaranteed to be rejected — or, worse, resolve a typo to a
-     * stranger the caller never intended to name.
+     * server accepts space members, plus only the caller's own unshared agents
+     * (`AgentTaskConsent`; anything else is `ASSIGNEE_NOT_IN_SPACE`), so widening
+     * the lookup could only ever produce a request the server refuses — or,
+     * worse, resolve a typo to a stranger the caller never intended to name.
      */
     protected loadSpaceMembers(spaceId: string): Promise<SpaceMember[]>;
     /**

package/dist/base-command.js

@@ -645,10 +645,10 @@ class BaseCommand extends core_1.Command {
      *
      * Shared by every command that accepts an assignee reference. A failure is
      * fatal rather than a silent fall-back to a global directory search: the
-     * server only accepts assignees who are members of the space
-     * (`ASSIGNEE_NOT_IN_SPACE`), so widening the lookup could only ever produce
-     * a request guaranteed to be rejected — or, worse, resolve a typo to a
-     * stranger the caller never intended to name.
+     * server accepts space members, plus only the caller's own unshared agents
+     * (`AgentTaskConsent`; anything else is `ASSIGNEE_NOT_IN_SPACE`), so widening
+     * the lookup could only ever produce a request the server refuses — or,
+     * worse, resolve a typo to a stranger the caller never intended to name.
      */
     async loadSpaceMembers(spaceId) {
         let response;
@@ -1376,8 +1376,10 @@ function describeAssigneeNotInSpace(serverMessage, bin = 'skrr') {
     const base = serverMessage?.trim() || 'That assignee is not a member of this space.';
     if (base.includes(`${bin} spaces members add`))
         return base;
+    // Two ways forward, because the server accepts two consents: membership, or
+    // an owner assigning their own unshared agent to one task (AgentTaskConsent).
     return (`${base}\n  → add it to the space with \`${bin} spaces members add\`, ` +
-        'or assign someone already in it.');
+        'assign someone already in it, or — for your own unshared agent — assign it yourself.');
 }
 /**
  * Server-declared TERMINAL refusals: a state conflict the caller must resolve

package/dist/commands/spaces/auto-executor/preview.d.ts

@@ -1,3 +1,4 @@
+import { type SpaceAutoExecutorRefillState } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../../base-command';
 export default class SpacesAutoExecutorPreview extends BaseCommand {
     static description: string;
@@ -10,3 +11,10 @@ export default class SpacesAutoExecutorPreview extends BaseCommand {
     };
     run(): Promise<void>;
 }
+/**
+ * The refill latch in words: whether start work is owed, why it last woke, and
+ * what each recent task-pool change did. This is how "the board is not picking
+ * up work" becomes a question with an answer. `undefined` is a server that does
+ * not report it; `null` is one that could not read it, and says so.
+ */
+export declare function refillLines(refill: SpaceAutoExecutorRefillState | null | undefined): string[];

package/dist/commands/spaces/auto-executor/preview.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.refillLines = refillLines;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
@@ -49,6 +50,8 @@ class SpacesAutoExecutorPreview extends base_command_1.BaseCommand {
         if (capacity.budget && !capacity.budget.unlimited) {
             this.log(`Budget:     ${capacity.budget.consumedStarts}/${capacity.budget.maxStarts} starts used this round`);
         }
+        for (const line of refillLines(result.refill))
+            this.log(line);
         const { actions, summary } = plan;
         this.log('');
         this.log(`Board:      ${summary.readyCount} ready · ${summary.unassignedCount} unassigned · ` +
@@ -70,6 +73,44 @@ class SpacesAutoExecutorPreview extends base_command_1.BaseCommand {
     }
 }
 exports.default = SpacesAutoExecutorPreview;
+/**
+ * The refill latch in words: whether start work is owed, why it last woke, and
+ * what each recent task-pool change did. This is how "the board is not picking
+ * up work" becomes a question with an answer. `undefined` is a server that does
+ * not report it; `null` is one that could not read it, and says so.
+ */
+function refillLines(refill) {
+    if (refill === undefined)
+        return [];
+    if (refill === null)
+        return ['Refill:     state unavailable (the server could not read it)'];
+    const owed = refill.requestedGeneration - refill.processedGeneration;
+    const lines = [
+        `Refill:     ${refill.pending
+            ? `${owed} wake${owed === 1 ? '' : 's'} owed (generation ${refill.processedGeneration} → ${refill.requestedGeneration})`
+            : `caught up (generation ${refill.processedGeneration})`}${refill.lastReason ? ` · last: ${refill.lastReason}` : ''}`,
+    ];
+    if (refill.notBefore)
+        lines.push(`            deferred until ${refill.notBefore}`);
+    if (refill.waitingOnAgentIds.length) {
+        lines.push(`            waiting on agent capacity: ${refill.waitingOnAgentIds.join(', ')}`);
+    }
+    const wakes = refill.taskPool.recentWakes;
+    if (wakes.length) {
+        lines.push('');
+        lines.push(`Recent task-pool changes (${wakes.length}):`);
+        for (const wake of wakes) {
+            const effect = wake.refillRelevant === true
+                ? 'can start work'
+                : wake.refillRelevant === false
+                    ? 'nothing to start'
+                    : 'unclassified';
+            const outcome = wake.status === 'processed' ? (wake.decision ?? 'processed') : wake.status;
+            lines.push(`  - #${wake.generation} ${wake.mutation} · ${effect} · ${outcome}`);
+        }
+    }
+    return lines;
+}
 function taskLine(task) {
     return `${task.identifier ? `${task.identifier} ` : ''}${task.title}`;
 }

package/dist/commands/spaces/task-rollups.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr spaces task-rollups` — task-status counts for every Space you can view,
+ * in one request: the same rollup the Spaces sidebar row reads, counted by the
+ * project-rollup rules (`done` is done only; `open` excludes cancelled).
+ */
+export default class SpacesTaskRollups extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/spaces/task-rollups.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+/**
+ * `skrr spaces task-rollups` — task-status counts for every Space you can view,
+ * in one request: the same rollup the Spaces sidebar row reads, counted by the
+ * project-rollup rules (`done` is done only; `open` excludes cancelled).
+ */
+class SpacesTaskRollups extends base_command_1.BaseCommand {
+    static description = 'Show task-status counts for every space you can view';
+    static examples = [
+        '<%= config.bin %> spaces task-rollups',
+        '<%= config.bin %> spaces task-rollups --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(SpacesTaskRollups);
+        let response;
+        // Titles are best-effort: the rollup carries only ids, and a failed title
+        // lookup must not hide counts the rollup did return.
+        let titles = new Map();
+        try {
+            const [rollups, spaces] = await Promise.all([
+                data_provider_1.dataService.listSpaceTaskRollups(),
+                data_provider_1.dataService.listSpaces({ includeArchived: true, limit: 500 }).catch(() => null),
+            ]);
+            response = rollups;
+            const rows = (spaces?.data ||
+                []);
+            titles = new Map(rows.map((space) => [String(space.id), space.title || '']));
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        if (response.degraded) {
+            // A partial walk is not the whole picture; say so before the numbers.
+            this.log(`Degraded: ${(response.warnings || []).join('; ') || 'some spaces were not counted'}`);
+        }
+        const rows = [...(response.rollups || [])].sort((a, b) => b.tasks.open - a.tasks.open);
+        if (rows.length === 0) {
+            this.log('No spaces with tasks.');
+            return;
+        }
+        const label = (spaceId) => {
+            const title = titles.get(spaceId);
+            const text = title ? `${title} (${spaceId.slice(0, 8)})` : spaceId;
+            return text.length > 48 ? `${text.slice(0, 45)}...` : text;
+        };
+        this.log(`${'SPACE'.padEnd(48)} ${'OPEN'.padStart(5)} ${'DONE'.padStart(5)} ${'BLOCKED'.padStart(7)} ${'TOTAL'.padStart(5)}`);
+        for (const { spaceId, tasks } of rows) {
+            this.log(`${label(spaceId).padEnd(48)} ${String(tasks.open).padStart(5)} ${String(tasks.done).padStart(5)} ` +
+                `${String(tasks.blocked).padStart(7)} ${String(tasks.total).padStart(5)}`);
+        }
+    }
+}
+exports.default = SpacesTaskRollups;

package/dist/commands/spaces/work-sync/telemetry.js

@@ -52,6 +52,28 @@ class SpacesWorkSyncTelemetry extends base_command_1.BaseCommand {
         this.log(`Verdict:       ${summary.rollout.verdict}`);
         this.log(`Sampled rows:  ${summary.sampledEvents}`);
         this.log(`Repair backlog: ${summary.repairBacklog}`);
+        if (summary.coverage && summary.coverage.hits + summary.coverage.misses > 0) {
+            const { hits, misses, hitRate } = summary.coverage;
+            this.log(`Coverage:      ${hits} hits · ${misses} misses` +
+                (hitRate === null ? '' : ` (${Math.round(hitRate * 1000) / 10}% of cold opens)`));
+        }
+        // Before the zero-events early return: writes are measured from the command
+        // queue, not from board telemetry, so a Space can have one without the other.
+        const commandRows = Object.entries(summary.commands || {}).sort(([a], [b]) => a.localeCompare(b));
+        if (commandRows.length > 0) {
+            const percent = (value) => value === null ? 'n/a' : `${Math.round(value * 1000) / 10}%`;
+            this.log('');
+            this.log('Writes (durable command queue):');
+            for (const [kind, stats] of commandRows) {
+                this.log(`  ${kind.padEnd(20)} ${stats.commands} commands · ${stats.accepted} accepted · ` +
+                    `${stats.pending} pending · ${stats.deadLettered} refused`);
+                this.log(`  ${''.padEnd(20)} version conflicts ${stats.versionConflicts} ` +
+                    `(${percent(stats.rates.versionConflict)} of settled) · authorization changed ` +
+                    `${stats.authorizationChanged} (${percent(stats.rates.authorizationChanged)}) · ` +
+                    `duplicate deliveries ${stats.duplicateDeliveries} ` +
+                    `(${percent(stats.rates.duplicateDelivery)} of deliveries)`);
+            }
+        }
         // Zero sampled rows is a REAL answer and the most misread one: it means
         // nothing has been measured in this Space, not that everything is fine. The
         // server already distinguishes it (`insufficient_evidence`); say so here too

package/dist/commands/tasks/assign.js

@@ -74,7 +74,7 @@ class TasksAssign extends base_command_1.BaseCommand {
             options: ['agent', 'human'],
         }),
         list: core_1.Flags.boolean({
-            description: "List the task's space members (who can be assigned) and exit",
+            description: "List the task's space members and exit (your own unshared agents can also be assigned, by id)",
         }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
     };

package/dist/commands/tasks/create.js

@@ -460,8 +460,9 @@ class TasksCreate extends base_command_1.BaseCommand {
             defaultAgentResolution = {
                 applied: false,
                 source: 'none',
-                note: 'Created unassigned: the agent bound to this session is not a member of that space. ' +
-                    'Add it to the space, or pass an assignee explicitly.',
+                note: 'Created unassigned: the agent bound to this session is not a member of that space, ' +
+                    'and it is not your own agent shared with no one else, which is the only other way ' +
+                    'an agent can work there. Add it to the space, or pass an assignee explicitly.',
             };
             try {
                 const result = await this.createTaskOrRecover(payload);
@@ -572,9 +573,14 @@ class TasksCreate extends base_command_1.BaseCommand {
         const dropped = (0, tasks_1.droppedDefaultAssignees)(resolution, memberIds);
         const warnings = [];
         if (dropped.agentIds.length > 0) {
+            // Membership is one of TWO consents the server accepts (AgentTaskConsent);
+            // the other — your own agent, shared with no one else — needs the agent's
+            // sharing, which a dry run does not read. So this says what decides it
+            // rather than predicting a drop that owner delegation would not make.
             warnings.push(`The defaulted assignee agent ${dropped.agentIds.join(', ')} is not a member of ` +
-                `space ${spaceId}, so the real create will drop it and record the task ` +
-                'unassigned. Add the agent to the space, or pass an assignee explicitly.');
+                `space ${spaceId}. The real create keeps it only if it is your own agent shared ` +
+                'with no one else; otherwise it records the task unassigned. Add the agent to the ' +
+                'space, or pass an assignee explicitly.');
         }
         if (dropped.userIds.length > 0) {
             warnings.push(`The defaulted assignee ${dropped.userIds.join(', ')} is not a member of space ` +

package/dist/lib/api-fetch.js

@@ -37,6 +37,8 @@ const config_1 = require("./config");
 // (b) tests that mock './auth-storage' get a single mock target.
 const auth_storage_1 = require("./auth-storage");
 const credential_resolver_1 = require("./credential-resolver");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const idempotency_scope_1 = require("./idempotency-scope");
 const node_adapter_1 = require("./node-adapter");
 const refresh_1 = require("./refresh");
 const delegated_cli_1 = require("./delegated-cli");
@@ -95,6 +97,12 @@ async function apiFetch(pathOrUrl, opts = {}) {
     if (opts.body !== undefined && method !== 'GET') {
         body = JSON.stringify(opts.body);
     }
+    // Same rule as every `dataService` write (`@skrr-ai/data-provider`
+    // idempotency), chosen once so the 401 retries below resend the same key.
+    (0, idempotency_scope_1.bindAutonomousIdempotencyScope)();
+    const callerHeaders = method === 'GET'
+        ? (opts.headers ?? {})
+        : (0, data_provider_1.withIdempotencyKey)(opts.headers, { method, url: pathOrUrl, body: opts.body });
     // A trusted Agent process cannot smuggle an explicit human credential into
     // this escape hatch. The daemon-issued session token is the sole principal.
     //
@@ -146,7 +154,7 @@ async function apiFetch(pathOrUrl, opts = {}) {
         // Caller headers are applied BEFORE the auth header below is read, and
         // deliberately cannot clobber Authorization / Content-Type: an idempotency
         // key is additive metadata, not a way to re-auth the request.
-        for (const [k, v] of Object.entries(opts.headers ?? {})) {
+        for (const [k, v] of Object.entries(callerHeaders)) {
             const lower = k.toLowerCase();
             if (lower === 'authorization' || lower === 'content-type')
                 continue;

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

@@ -9,12 +9,13 @@
  * reference into exactly one member of the task's space, or an actionable
  * failure that names the candidates.
  *
- * Scoping to the space is not just ergonomics. The server rejects assignees
- * that are not space members (`SpacePermissionService.validateAssigneeSpaceMembership`
- * → `ASSIGNEE_NOT_IN_SPACE`), so resolving against the space membership list
- * means a name that resolves is a name that will be accepted — we never build
- * a request the server is guaranteed to refuse, and we cannot accidentally
- * leak a directory-wide user search into a space the caller can't see.
+ * Scoping to the space is not just ergonomics. The server accepts space members
+ * and, beyond them, only the caller's own agent when it is shared with no one
+ * else (`AgentTaskConsent` → otherwise `ASSIGNEE_NOT_IN_SPACE`), so a name that
+ * resolves against the membership list is a name that will be accepted, and we
+ * cannot accidentally leak a directory-wide user search into a space the caller
+ * can't see. An owner-delegated agent is not a member and so is not resolvable
+ * by name here; it is passed by raw id.
  */
 export type MemberKind = 'user' | 'agent';
 export type SpaceMember = {

package/dist/lib/daemonBroker.d.ts

@@ -139,6 +139,8 @@ export interface DaemonBrokerOptions {
     profile?: string;
     /** Override the bootstrap file path entirely (tests / unusual layouts). */
     bootstrapPathOverride?: string;
+    /** Test seam: the ordered candidate list, when one path is not enough. */
+    candidatePathsOverride?: readonly string[];
     /** Override total request timeout. Tests use a short value. */
     timeoutMs?: number;
 }
@@ -159,6 +161,24 @@ export declare function resolveProfileBootstrapPaths(primary: string, entryNames
  * deterministic when more than one matching daemon is running.
  */
 export declare function resolveBootstrapCandidatePaths(profile?: string): string[];
+/**
+ * A Dedicated Runtime guest's workload hand-off descriptor.
+ *
+ * On that product the daemon runs as `skrr-runtime` and everything the user runs
+ * — terminals, Bash tool calls, engines — as `skrr-workload`, so the island
+ * bootstrap above sits in a home this process cannot read. The daemon publishes
+ * this second descriptor to the shared workload group instead
+ * (`daemon/src/dedicated-cli-handoff.ts`). Its secret is accepted by the
+ * cli-handoff route and nothing else, so it is a hand-off candidate ONLY: it is
+ * deliberately absent from `resolveBootstrapCandidatePaths`, which message-intent
+ * submission also reads and which needs the island secret.
+ *
+ * Fixed and root-controlled (the daemon unit's RuntimeDirectory), so nothing the
+ * user configures can point the broker somewhere else.
+ */
+export declare const DEDICATED_RUNTIME_CLI_HANDOFF_DESCRIPTOR = "/run/skrr-dedicated-runtime/cli-handoff/descriptor.json";
+/** Where the cli-handoff broker looks, in order. */
+export declare function resolveCliHandoffCandidatePaths(profile?: string): string[];
 /**
  * Resolve the first live daemon bootstrap for a profile. Message-intent
  * submission reuses the same authenticated loopback discovery as the login

package/dist/lib/daemonBroker.js

@@ -71,10 +71,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEDICATED_RUNTIME_CLI_HANDOFF_DESCRIPTOR = void 0;
 exports.normalizeBaseUrl = normalizeBaseUrl;
 exports.resolveBootstrapPath = resolveBootstrapPath;
 exports.resolveProfileBootstrapPaths = resolveProfileBootstrapPaths;
 exports.resolveBootstrapCandidatePaths = resolveBootstrapCandidatePaths;
+exports.resolveCliHandoffCandidatePaths = resolveCliHandoffCandidatePaths;
 exports.findLiveDaemonBootstrap = findLiveDaemonBootstrap;
 exports.readBootstrap = readBootstrap;
 exports.attemptDaemonBrokerLogin = attemptDaemonBrokerLogin;
@@ -164,6 +166,33 @@ function resolveBootstrapCandidatePaths(profile = 'default') {
         return process.platform === 'darwin' ? [primary] : [primary, legacyBootstrapPath()];
     }
 }
+/**
+ * A Dedicated Runtime guest's workload hand-off descriptor.
+ *
+ * On that product the daemon runs as `skrr-runtime` and everything the user runs
+ * — terminals, Bash tool calls, engines — as `skrr-workload`, so the island
+ * bootstrap above sits in a home this process cannot read. The daemon publishes
+ * this second descriptor to the shared workload group instead
+ * (`daemon/src/dedicated-cli-handoff.ts`). Its secret is accepted by the
+ * cli-handoff route and nothing else, so it is a hand-off candidate ONLY: it is
+ * deliberately absent from `resolveBootstrapCandidatePaths`, which message-intent
+ * submission also reads and which needs the island secret.
+ *
+ * Fixed and root-controlled (the daemon unit's RuntimeDirectory), so nothing the
+ * user configures can point the broker somewhere else.
+ */
+exports.DEDICATED_RUNTIME_CLI_HANDOFF_DESCRIPTOR = '/run/skrr-dedicated-runtime/cli-handoff/descriptor.json';
+/** Where the cli-handoff broker looks, in order. */
+function resolveCliHandoffCandidatePaths(profile = 'default') {
+    const candidates = resolveBootstrapCandidatePaths(profile);
+    // Any profile: a guest runs one daemon, and the auto-broker resolves the
+    // default profile regardless of `--profile`, so a narrower condition here would
+    // only describe behaviour production never reaches.
+    if (process.platform === 'linux') {
+        candidates.push(exports.DEDICATED_RUNTIME_CLI_HANDOFF_DESCRIPTOR);
+    }
+    return candidates;
+}
 /**
  * Pre-Phase-K bootstrap path (non-darwin). Read-only fallback consulted
  * when the canonical path is absent — covers a freshly-upgraded daemon
@@ -247,13 +276,15 @@ function readBootstrap(filePath) {
  */
 async function attemptDaemonBrokerLogin(opts) {
     const profile = opts.profile ?? 'default';
-    const candidates = opts.bootstrapPathOverride
-        ? [opts.bootstrapPathOverride]
-        : resolveBootstrapCandidatePaths(profile);
-    let bootstrap = null;
-    let usedPath = null;
-    let unboundBootstrap = null;
-    let unboundPath = null;
+    const candidates = opts.candidatePathsOverride
+        ? [...opts.candidatePathsOverride]
+        : opts.bootstrapPathOverride
+            ? [opts.bootstrapPathOverride]
+            : resolveCliHandoffCandidatePaths(profile);
+    // Bound candidates (their serverUrl matches this CLI) in order, then unbound
+    // ones. Every usable candidate is kept, not just the first: see below.
+    const usable = [];
+    const unbound = [];
     let mismatchedBootstrap = null;
     for (const candidate of candidates) {
         const candidateBootstrap = readBootstrap(candidate);
@@ -269,19 +300,13 @@ async function attemptDaemonBrokerLogin(opts) {
         }
         if (typeof candidateBootstrap.serverUrl !== 'string' ||
             candidateBootstrap.serverUrl.length === 0) {
-            unboundBootstrap ??= candidateBootstrap;
-            unboundPath ??= candidate;
+            unbound.push(candidateBootstrap);
             continue;
         }
-        bootstrap = candidateBootstrap;
-        usedPath = candidate;
-        break;
-    }
-    if (!bootstrap && unboundBootstrap && unboundPath) {
-        bootstrap = unboundBootstrap;
-        usedPath = unboundPath;
+        usable.push(candidateBootstrap);
     }
-    if (!bootstrap || !usedPath) {
+    usable.push(...unbound);
+    if (usable.length === 0) {
         if (mismatchedBootstrap?.serverUrl) {
             return {
                 ok: false,
@@ -296,6 +321,22 @@ async function attemptDaemonBrokerLogin(opts) {
             detail: `No daemon bootstrap file found (looked in ${candidates.join(', ')})`,
         };
     }
+    // A candidate nothing is listening behind moves on to the next one. Liveness is
+    // only a pid check, and EPERM counts as alive — on a Dedicated Runtime guest
+    // nearly every pid belongs to another uid, so a stale island file in the
+    // workload's own home (restored dotfiles, say) passes it and used to shadow the
+    // daemon's live hand-off descriptor forever, with `skrr` reporting "Not signed
+    // in". Only a refused connection falls through: any answer, or a timeout, is a
+    // daemon that is really there, and its outcome stands.
+    let outcome = null;
+    for (const bootstrap of usable) {
+        outcome = await brokerThrough(bootstrap, opts);
+        if (outcome.ok || outcome.reason !== 'network')
+            return outcome;
+    }
+    return outcome;
+}
+async function brokerThrough(bootstrap, opts) {
     const url = `http://${bootstrap.host}:${bootstrap.port}/v1/auth/cli-handoff`;
     const timeoutMs = opts.timeoutMs ?? REQUEST_TIMEOUT_MS;
     const controller = new AbortController();

package/dist/lib/idempotency-scope.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A process running one autonomous ACTION binds every write to it, so the same
+ * action re-run in a new process converges on the server instead of writing
+ * twice. The rule itself lives in `@skrr-ai/data-provider` (`idempotency.ts`),
+ * shared with the web client; the CLI only says which action it is.
+ *
+ * Bound by both transports — the `dataService` adapter and `apiFetch` — because
+ * either may be the first to write.
+ */
+export declare function bindAutonomousIdempotencyScope(env?: NodeJS.ProcessEnv): void;

package/dist/lib/idempotency-scope.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindAutonomousIdempotencyScope = bindAutonomousIdempotencyScope;
+const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * A process running one autonomous ACTION binds every write to it, so the same
+ * action re-run in a new process converges on the server instead of writing
+ * twice. The rule itself lives in `@skrr-ai/data-provider` (`idempotency.ts`),
+ * shared with the web client; the CLI only says which action it is.
+ *
+ * Bound by both transports — the `dataService` adapter and `apiFetch` — because
+ * either may be the first to write.
+ */
+function bindAutonomousIdempotencyScope(env = process.env) {
+    (0, data_provider_1.setIdempotencyScope)(env.OVERSKY_AUTONOMOUS_ACTION_KEY?.trim() || null);
+}

package/dist/lib/node-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { HttpAdapter } from '@skrr-ai/data-provider';
+import { type HttpAdapter } from '@skrr-ai/data-provider';
 import { type ResolvedCredential } from '@skrr-ai/auth-core';
 import './auth-core-init';
 /**

package/dist/lib/node-adapter.js

@@ -5,7 +5,8 @@ exports.clearAdapterCredentialOverride = clearAdapterCredentialOverride;
 exports.getAdapterCredentialOverride = getAdapterCredentialOverride;
 exports.createNodeAdapter = createNodeAdapter;
 exports.__recomputeCredentialForTest = __recomputeCredentialForTest;
-const node_crypto_1 = require("node:crypto");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const idempotency_scope_1 = require("./idempotency-scope");
 const auth_core_1 = require("@skrr-ai/auth-core");
 const config_1 = require("./config");
 const auth_storage_1 = require("./auth-storage");
@@ -72,6 +73,7 @@ function currentCredential() {
 }
 function createNodeAdapter(opts = {}) {
     const { onTokenRefresh, onAuthFailure } = opts;
+    (0, idempotency_scope_1.bindAutonomousIdempotencyScope)();
     // In-process single-flight: collapses N parallel 401s into one refresh
     // round-trip. Cross-process serialization happens inside refresh.ts.
     let refreshInFlight = null;
@@ -157,15 +159,6 @@ function createNodeAdapter(opts = {}) {
             }
         }
         const finalUrl = appendQuery(resolveUrl(url), options?.params);
-        const actionKey = process.env.OVERSKY_AUTONOMOUS_ACTION_KEY?.trim();
-        const hasIdempotencyKey = Object.keys(headers).some((key) => key.toLowerCase() === 'x-idempotency-key');
-        if (actionKey && method !== 'GET' && !isFormData && !hasIdempotencyKey) {
-            const requestUrl = new URL(finalUrl);
-            const scope = `${actionKey}\u001f${method}\u001f${requestUrl.pathname}${requestUrl.search}\u001f${typeof finalBody === 'string' ? finalBody : ''}`;
-            headers['X-Idempotency-Key'] = `autonomous:${(0, node_crypto_1.createHash)('sha256')
-                .update(scope)
-                .digest('hex')}`;
-        }
         return fetch(finalUrl, { method, headers, body: finalBody });
     }
     /**
@@ -291,6 +284,15 @@ function createNodeAdapter(opts = {}) {
         return true;
     }
     async function request(method, url, body, options, isFormData = false) {
+        // Writes that arrive through `request.ts` already carry a key. A direct
+        // adapter call gets one by the same shared rule, chosen HERE, once, so the
+        // 401-refresh retries below resend the same key rather than a new one.
+        if (method !== 'GET' && !isFormData && !(0, data_provider_1.hasIdempotencyKey)(options?.headers)) {
+            options = {
+                ...(options ?? {}),
+                headers: (0, data_provider_1.withIdempotencyKey)(options?.headers, { method, url, body }),
+            };
+        }
         let res = await rawRequest(method, url, body, options, isFormData);
         // Never retry auth endpoints themselves — prevents refresh recursion
         // and lets login/logout/refresh surface their real errors.

package/dist/lib/triggers.js

@@ -147,6 +147,13 @@ exports.TRIGGER_EVENT_CATALOG = {
         'task.assigned',
         'task.completed',
         'task.archived',
+        'task.unassigned',
+        'task.scheduled',
+        'task.rescheduled',
+        'task.unscheduled',
+        'task.deleted',
+        'task.execution_completed',
+        'task.execution_failed',
     ],
     space: [
         'space.created',

package/dist/lib/work-sync.d.ts

@@ -27,9 +27,44 @@ export type WorkSyncEventStats = {
     p95Bytes: number | null;
     mismatchCount: number;
 };
+/**
+ * What happened to WRITES of one operation kind, from the durable command queue.
+ * Rates are `null` when their denominator is zero: conflict rates are over
+ * settled commands (accepted + dead-lettered), the duplicate rate over deliveries.
+ */
+export type WorkSyncCommandStats = {
+    commands: number;
+    deliveries: number;
+    duplicateDeliveries: number;
+    accepted: number;
+    pending: number;
+    deadLettered: number;
+    versionConflicts: number;
+    authorizationChanged: number;
+    expired: number;
+    retryExhausted: number;
+    otherRejections: number;
+    rates: {
+        versionConflict: number | null;
+        authorizationChanged: number | null;
+        duplicateDelivery: number | null;
+    };
+};
 export type WorkSyncTelemetrySummary = {
     sampledEvents: number;
     events: Record<string, WorkSyncEventStats>;
+    /** Absent from a server older than the write-side rates. */
+    commands?: Record<string, WorkSyncCommandStats>;
+    /**
+     * Cold opens of a task detail plane that found (hit) or did not find (miss) a
+     * completed coverage record on the device. `hitRate` is null with no cold
+     * opens. Absent from a server older than the coverage read path.
+     */
+    coverage?: {
+        hits: number;
+        misses: number;
+        hitRate: number | null;
+    };
     repairBacklog: number;
     rollout: {
         verdict: 'ready' | 'hold' | 'insufficient_evidence';