@skrr-ai/cli 0.1.108 → 0.1.109

package/dist/lib/stewardship-output.js

@@ -4,6 +4,7 @@ exports.printStewardshipCoverage = printStewardshipCoverage;
 exports.printWorkspaceGrants = printWorkspaceGrants;
 exports.printWorkspaceStewardship = printWorkspaceStewardship;
 const format_1 = require("./format");
+const grants_1 = require("./grants");
 function printStewardshipCoverage(report, log) {
     if (report.coverage.complete) {
         log('Coverage: complete within the bounded sources.');
@@ -41,23 +42,24 @@ function printStewardshipCoverage(report, log) {
         }
     }
 }
-/** Who holds the Grant, in the same `kind id` words `skrr grants list` uses. */
-function principalText(principal) {
-    const value = principal;
-    if (!value?.kind)
-        return '—';
-    const id = value.agentId ?? value.commitmentId;
-    return id ? `${value.kind} ${id}` : value.kind;
-}
-/** What the Grant allows: its capability names, or an honest dash when it lists none. */
-function accessText(capabilities) {
+/** What the Grant's capabilities name, or an honest dash when it lists none. */
+function capabilitiesText(capabilities) {
     return Array.isArray(capabilities) && capabilities.length ? capabilities.join(', ') : '—';
 }
-function printWorkspaceGrants(report, log) {
+/**
+ * The owner as a person reads it: `Name (id)` when the id belongs to a current
+ * member, the bare id otherwise — an owner who has left is not a member, and
+ * the id is still the thing to act on.
+ */
+function ownerText(ownerUserId, members) {
+    const name = members?.get(ownerUserId);
+    return name ? `${name} (${ownerUserId})` : ownerUserId;
+}
+function printWorkspaceGrants(report, log, members) {
     printStewardshipCoverage(report, log);
-    printGrantRows(report, log);
+    printGrantRows(report, log, members);
 }
-function printGrantRows(report, log) {
+function printGrantRows(report, log, members) {
     if (report.grants === null) {
         log('Grants: unavailable.');
         return;
@@ -69,30 +71,24 @@ function printGrantRows(report, log) {
             : 'No workspace Grants observed.');
         return;
     }
+    // The columns `skrr grants list` shows come from the same function, so a
+    // header means the same thing in both tables (OSK-15357); the workspace view
+    // adds who owns the Grant, its capabilities, its expiry and what uses it.
     (0, format_1.renderTable)(report.grants.map((row) => ({
-        id: row.id,
-        label: row.label,
-        provider: row.provider || '—',
-        principal: principalText(row.principal),
-        access: accessText(row.capabilities),
-        owner: row.ownerUserId,
-        active: row.active ? 'yes' : 'no',
+        ...(0, grants_1.grantTableCells)(row),
+        owner: ownerText(row.ownerUserId, members),
+        capabilities: capabilitiesText(row.capabilities),
         // No expiry is a fact about the Grant; a blank cell read as "not readable" (OSK-15357).
         expires: row.expiresAt ?? 'never',
-        envKeys: row.credential?.envKeys.length ? row.credential.envKeys.join(', ') : '—',
         referencedBy: row.referencedBy === null
             ? 'unavailable'
-            : `${row.referencedBy.join(', ')}${row.referencesTruncated ? ' (truncated)' : ''}`,
+            : `${row.referencedBy.join(', ') || '—'}${row.referencesTruncated ? ' (truncated)' : ''}`,
     })), [
-        { key: 'id', header: 'ID' },
-        { key: 'label', header: 'LABEL' },
-        { key: 'provider', header: 'PROVIDER' },
-        { key: 'principal', header: 'HELD BY' },
-        { key: 'access', header: 'ACCESS' },
+        { key: 'id', header: 'ID', verbatim: true },
+        ...grants_1.GRANT_TABLE_COLUMNS,
         { key: 'owner', header: 'OWNER' },
-        { key: 'active', header: 'ACTIVE' },
+        { key: 'capabilities', header: 'CAPABILITIES' },
         { key: 'expires', header: 'EXPIRES' },
-        { key: 'envKeys', header: 'ENV NAMES' },
         { key: 'referencedBy', header: 'REFERENCED BY' },
     ], log);
 }
@@ -101,7 +97,7 @@ function printWorkspaceStewardship(report, log) {
     log(`Membership: ${report.membership.status}${report.membership.role ? ` (${report.membership.role})` : ''}${
     // "Absent" is all the report knows: a removed member and an id that never existed read alike (OSK-15356).
     report.membership.status === 'absent'
-        ? ' — not a current member; this report cannot tell a removed member from an id that never existed'
+        ? ' — not a current member; this report cannot tell a removed member from an id that never existed (`skrr workspaces members <workspace-id>` lists current members)'
         : ''}`);
     const isCut = (source) => report.coverage.sources.some((entry) => entry.name === source && entry.truncated);
     const count = (rows, source) => rows === null

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

@@ -26,6 +26,12 @@ export declare function batchIdempotencyKey(kind: 'create' | 'patch', items: unk
 export type BatchCreateNode = {
     key: string;
     parentKey?: string;
+    /**
+     * Keys of other nodes that block this one. Each blocker must come BEFORE this
+     * node in the list; the batch resolves them to real ids on the server (same
+     * chunk) or from `mapping` (an earlier chunk, or a task that already existed).
+     */
+    blockerKeys?: string[];
     payload: Record<string, unknown>;
 };
 export type BatchCreatedRow = {
@@ -56,13 +62,64 @@ export type BatchCreateOutcome = {
     supported: true;
     rows: BatchCreatedRow[];
     failures: BatchCreateFailure[];
+    /** Requests made to the batch route, retries included. */
+    rounds: number;
+};
+/** What a long create reports between requests (the command decides whether anyone sees it). */
+export type BatchProgress = {
+    /** Nodes confirmed to exist so far, created now or found already there. */
+    confirmed: number;
+    total: number;
+    round: number;
+    elapsedMs: number;
+    /** Set while waiting before the next attempt, with why. */
+    waiting?: {
+        ms: number;
+        reason: string;
+    };
+};
+export type BatchCreateOptions = {
+    onProgress?: (progress: BatchProgress) => void;
+};
+/**
+ * How a create that is not finishing is retried. A seam rather than constants so
+ * a test can run the whole policy without waiting through it.
+ *
+ * Each round that confirms nothing waits the next interval and counts toward the
+ * limit; a round that confirms anything resets it. The total wait is bounded
+ * (about 15 s), on purpose: this is a courtesy to a server that is briefly slow
+ * or rate-limited, not a promise to outlast an outage — past it the command says
+ * what is unknown and how to continue.
+ */
+export declare const batchRetryPolicy: {
+    backoffMs: number[];
+    sleep: (ms: number) => Promise<void>;
 };
 /**
- * Create `nodes` (parents before children) in chunks. `mapping` holds key -> id
- * for nodes that already exist and is extended in place. Stops after the first
- * chunk that reports a failure, as the serial path stopped at its first failure.
+ * Create `nodes` — parents and blockers BEFORE what depends on them — until every
+ * one exists, or say precisely which do not and why.
+ *
+ * One request is a bounded unit of work, not the whole job: the server answers
+ * within a response budget, creating what it can and reporting the rest as not
+ * started (`BATCH_DEADLINE_EXCEEDED`) or still in flight (`pending`). That is a
+ * normal, successful answer, so this loop is what turns it into a finished tree:
+ * submit, record what is confirmed, submit what is left. It used to stop at the
+ * first row the server had not confirmed and hand the person a `--resume` to
+ * type — once per row or two, against a server that confirms a row or two per
+ * request (OSK-S-440 #1, #3, #4).
+ *
+ * The one rule that makes resubmitting safe is the one the server enforces: a
+ * node with a stable `externalKey` can be created once. A submitted write whose
+ * outcome is unknown is therefore READ first (`reconcileSubmittedNodes`), and only
+ * if the key is still absent is the node sent again — where, if the first write
+ * has landed in the meantime, the unique index turns it into `exists`. A node with
+ * no stable key is never resubmitted after an uncertain outcome, because nothing
+ * could tell the second write from a duplicate; that case stops and says so, as
+ * before.
+ *
+ * `mapping` holds key -> id for nodes that already exist and is extended in place.
  */
-export declare function createNodesViaBatch(nodes: BatchCreateNode[], mapping: Record<string, string>): Promise<BatchCreateOutcome>;
+export declare function createNodesViaBatch(nodes: BatchCreateNode[], mapping: Record<string, string>, options?: BatchCreateOptions): Promise<BatchCreateOutcome>;
 export type BatchPatchOutcome = {
     supported: false;
 } | {