@skrr-ai/cli 0.1.116 → 0.1.118

package/dist/lib/task-operations.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.taskActionCommand = taskActionCommand;
-exports.taskOperationsGuide = taskOperationsGuide;
-exports.taskOperationsGuideLines = taskOperationsGuideLines;
 const shell_quote_1 = require("./shell-quote");
-/** Documentation and display paths only. The server still owns allowedActions. */
+/**
+ * Documentation and display paths only. The server still owns allowedActions.
+ *
+ * `skrr tasks guide`'s command map retired into the tasks guide's `commands`
+ * section (`skrr guide tasks commands`), the one copy every surface reads;
+ * what remains here is the action→command remedies preflight and
+ * actionability render into server-declared allowedActions.
+ */
 function taskActionCommand(action, taskId, targetId, bin = 'skrr', context = {}) {
     const task = (0, shell_quote_1.shellQuoteArg)(taskId);
     const target = targetId ? (0, shell_quote_1.shellQuoteArg)(targetId) : '<id>';
@@ -13,7 +18,7 @@ function taskActionCommand(action, taskId, targetId, bin = 'skrr', context = {})
         assign_task: `tasks assign ${task} --help`,
         // Managed work already has a current Result. Its server-declared
         // continuation surface distinguishes closing from submitting a new Result.
-        complete_task: context.allowedActions?.some(item => item.action === 'continue_task')
+        complete_task: context.allowedActions?.some((item) => item.action === 'continue_task')
             ? `tasks move ${task} --status done`
             : `tasks complete ${task}`,
         continue_task: `tasks continue ${task} --text "<instruction>" --command-key <key>`,
@@ -31,93 +36,3 @@ function taskActionCommand(action, taskId, targetId, bin = 'skrr', context = {})
     };
     return commands[action] ? `${bin} ${commands[action]}` : undefined;
 }
-function taskOperationsGuide(bin = 'skrr') {
-    const command = (usage, purpose) => ({ command: `${bin} ${usage}`, purpose });
-    return {
-        title: 'Task operations',
-        sections: [
-            {
-                title: 'Inspect and plan',
-                commands: [
-                    command('tasks show <task> --json', 'Read the Task, assignment, and dependency IDs.'),
-                    command('tasks actionability <task>', 'Read the canonical next actor, blocker, and allowed actions.'),
-                    command('tasks preflight <task>', 'Read workflow actionability and execution prerequisites together; creates no Run.'),
-                    command('tasks ready --for agent --agent <agent-id>', 'Find workflow-actionable work for an Agent; this does not verify its runtime.'),
-                    command('tasks create-tree --help', 'Create a related Task tree; blockedByTempIds declares dependencies within that tree.'),
-                ],
-            },
-            {
-                title: 'Choose assignment',
-                note: 'Executor intent, assignment, and starting a Run are separate choices. --unassigned clears both assignee kinds and suppresses automatic defaults; it does not start work.',
-                commands: [
-                    command('tasks create --title "Task title" --execution-mode agent --unassigned --dry-run --json', 'Preview Agent-intended work without selecting an Agent or writing a Task.'),
-                    command('tasks assign <task> --unassigned', 'Clear current assignees while retaining executor intent; creates no Run.'),
-                    command('tasks assign <task> --help', 'Choose an eligible Human or Agent explicitly using the native assignment options.'),
-                ],
-            },
-            {
-                title: 'Apply and recover a batch',
-                note: 'Keep the same JSON, scope, and external-key options after an incomplete result. Explicit node externalKey values are preserved; otherwise keys derive from the file and defaults. Changing that input can name new Tasks.',
-                commands: [
-                    command('tasks create-tree --from-json tasks.json --unassigned --readback --json', 'Apply the batch and reread its declared structured fields. This does not start Tasks.'),
-                    command('tasks create-tree --from-json tasks.json --unassigned --resume --readback --json', 'Continue the unchanged file: confirm existing IDs without patching them, create only missing nodes, then read back.'),
-                    command('tasks create-tree --from-json tasks.json --unassigned --verify-spec --json', 'Read-only structured-field comparison. Rich text and unsupported fields are explicitly unchecked; no Expectation assessment or drift repair is performed.'),
-                    command('tasks create-tree --from-json tasks.json --verify --json', 'Read-only existence check by external key. This makes no specification-equality claim.'),
-                ],
-            },
-            {
-                title: 'Name a Project or Goal',
-                note: 'Use exact scoped Project/Goal titles, native refs, or canonical IDs. Duplicate names refuse instead of choosing one. A qualified Project supplies containment; a qualified Goal changes the Goal relationship without moving the Task. Project external keys remain exact and case-sensitive, including keys containing slashes.',
-                commands: [
-                    command('tasks create --title "Task title" --space <space-id> --project "Exact project title" --goal "Exact Goal title" --unassigned --dry-run --json', 'Preview exact names inside the selected Space.'),
-                    command('tasks create --title "Task title" --project "<space-ref>/<project-ref-or-exact-title>" --goal "<space-ref>/<Goal-exact-title>" --unassigned --dry-run --json', 'Preview qualified references; native relationship permissions still apply.'),
-                    command('tasks create --title "Task title" --space <space-id> --project "<project-external-key>" --unassigned --dry-run --json', 'Reuse an existing Project’s native external key without rewriting it.'),
-                ],
-            },
-            {
-                title: 'Edit dependencies',
-                note: 'A waits for B: update A with --add-blocked-by B. These commands change dependencies; inspecting a blocker does not remove it.',
-                commands: [
-                    command('tasks update <task-A> --add-blocked-by <task-B>', 'Make A wait for B.'),
-                    command('tasks update <task-A> --remove-blocked-by <task-B>', 'Remove that dependency when the relationship is no longer intended.'),
-                    command('tasks update <task-B> --add-blocks <task-A>', 'The same relationship, edited from B.'),
-                ],
-            },
-            {
-                title: 'Check execution before starting',
-                note: 'Preflight reads server projections at separate times. It runs no shell command and cannot prove machine directory access, tool availability, or future approval. Starting rechecks current authority.',
-                commands: [
-                    command('tasks start <task> --dry-run --json', 'Read only the server-owned execution preview through the dedicated preview endpoint.'),
-                    command('agents show <agent-id>', 'Inspect the assigned Agent and its configured runtime.'),
-                    command('harnesses show <harness-id> --json', 'Inspect the actual Harness record and reported provider credential readiness, where available.'),
-                    command('harnesses installers --daemon <daemon-id>', 'Ask that daemon about installed coding CLIs and sign-in where it can tell; this is not a shell execution test.'),
-                    command('harnesses ping <harness-id>', 'Explicitly probe a local daemon for reachability; an answer does not prove a provider can run a task.'),
-                    command('tasks start <task>', 'Start a new Run after reviewing the checks. This command executes work.'),
-                ],
-            },
-            {
-                title: 'Follow and finish',
-                commands: [
-                    command('tasks show <task>', 'Inspect current execution and follow the Task link.'),
-                    command('tasks expectations <task>', 'Read what is owed and how it will be checked.'),
-                    command('tasks result submit <task> --help', 'Submit the concrete result and evidence.'),
-                    command('tasks review <task> --help', 'Review another actor’s exact Result.'),
-                    command('tasks complete <task> --help', 'Submit a Result and close out when appropriate.'),
-                    command('instructions guide task-management', 'Read the detailed canonical workflow guide; --offline uses the bundled release copy.'),
-                ],
-            },
-        ],
-    };
-}
-function taskOperationsGuideLines(bin = 'skrr') {
-    const guide = taskOperationsGuide(bin);
-    const lines = [guide.title];
-    for (const section of guide.sections) {
-        lines.push('', section.title);
-        if (section.note)
-            lines.push(section.note);
-        for (const entry of section.commands)
-            lines.push(`  ${entry.command}\n    ${entry.purpose}`);
-    }
-    return lines;
-}

package/dist/lib/task-preflight.js

@@ -22,7 +22,9 @@ function unavailable(error, label) {
             if (typeof body?.code === 'string' && /^[A-Z][A-Z0-9_]{0,100}$/.test(body.code))
                 code = body.code;
         }
-        catch { /* non-JSON server refusal */ }
+        catch {
+            /* non-JSON server refusal */
+        }
     }
     const remedy = status === 401
         ? 'Restore the current CLI sign-in or delegated runtime credential, then repeat this read-only check.'
@@ -32,9 +34,12 @@ function unavailable(error, label) {
                 ? 'Check the Task reference and server support for this diagnostic. No start fallback was attempted.'
                 : 'Read tasks actionability and tasks start --dry-run separately for the native refusal, then repeat preflight after resolving it.';
     return {
-        status: 'unavailable', certainty: 'unknown', code: code || 'TASK_PREFLIGHT_UNAVAILABLE',
+        status: 'unavailable',
+        certainty: 'unknown',
+        code: code || 'TASK_PREFLIGHT_UNAVAILABLE',
         ...(status ? { httpStatus: status } : {}),
-        message: `${label} could not be confirmed${status ? ` (HTTP ${status})` : ''}.`, remedy,
+        message: `${label} could not be confirmed${status ? ` (HTTP ${status})` : ''}.`,
+        remedy,
     };
 }
 function isWorkflow(value, taskId) {
@@ -42,60 +47,92 @@ function isWorkflow(value, taskId) {
         return false;
     const row = value;
     const a = row.actionability;
-    return row.taskId === taskId && Boolean(a &&
-        ['ready', 'running', 'waiting', 'terminal'].includes(a.state) &&
-        ['agent', 'human', 'system', 'external', 'none'].includes(a.nextActor) &&
-        typeof a.reasonCode === 'string' && typeof a.reason === 'string' &&
-        (a.actorRefs === undefined || Array.isArray(a.actorRefs) && a.actorRefs.every(ref => ref && ['user', 'agent'].includes(ref.kind) && typeof ref.id === 'string')) &&
-        Array.isArray(a.allowedActions) && a.allowedActions.every(action => action &&
-        typeof action.action === 'string' && (action.targetId === undefined || typeof action.targetId === 'string')));
+    return (row.taskId === taskId &&
+        Boolean(a &&
+            ['ready', 'running', 'waiting', 'terminal'].includes(a.state) &&
+            ['agent', 'human', 'system', 'external', 'none'].includes(a.nextActor) &&
+            typeof a.reasonCode === 'string' &&
+            typeof a.reason === 'string' &&
+            (a.actorRefs === undefined ||
+                (Array.isArray(a.actorRefs) &&
+                    a.actorRefs.every((ref) => ref && ['user', 'agent'].includes(ref.kind) && typeof ref.id === 'string'))) &&
+            Array.isArray(a.allowedActions) &&
+            a.allowedActions.every((action) => action &&
+                typeof action.action === 'string' &&
+                (action.targetId === undefined || typeof action.targetId === 'string'))));
 }
 function isPreview(value, taskId) {
     if (!(0, task_admission_1.isAdmissionPreview)(value) || value.taskId !== taskId)
         return false;
     const a = value.executionAdmission;
-    return Boolean(typeof a.unattended === 'boolean' && typeof a.approverAvailable === 'boolean' &&
-        (a.constraints === undefined || Array.isArray(a.constraints) && a.constraints.every(c => c &&
-            (c.message === undefined || typeof c.message === 'string') &&
-            (c.requiredAction === undefined || typeof c.requiredAction === 'string'))) &&
-        (a.permission === undefined || a.permission && typeof a.permission === 'object' &&
-            (a.permission.mode == null || typeof a.permission.mode === 'string') &&
-            (a.permission.source === undefined || typeof a.permission.source === 'string')) &&
-        (a.shell === undefined || a.shell && typeof a.shell === 'object' &&
-            (a.shell.state === undefined || typeof a.shell.state === 'string')) &&
-        (a.workingDirectory === undefined || a.workingDirectory &&
-            (a.workingDirectory.path === null || typeof a.workingDirectory.path === 'string') &&
-            typeof a.workingDirectory.source === 'string'));
+    return Boolean(typeof a.unattended === 'boolean' &&
+        typeof a.approverAvailable === 'boolean' &&
+        (a.constraints === undefined ||
+            (Array.isArray(a.constraints) &&
+                a.constraints.every((c) => c &&
+                    (c.message === undefined || typeof c.message === 'string') &&
+                    (c.requiredAction === undefined || typeof c.requiredAction === 'string')))) &&
+        (a.permission === undefined ||
+            (a.permission &&
+                typeof a.permission === 'object' &&
+                (a.permission.mode == null || typeof a.permission.mode === 'string') &&
+                (a.permission.source === undefined || typeof a.permission.source === 'string'))) &&
+        (a.shell === undefined ||
+            (a.shell &&
+                typeof a.shell === 'object' &&
+                (a.shell.state === undefined || typeof a.shell.state === 'string'))) &&
+        (a.workingDirectory === undefined ||
+            (a.workingDirectory &&
+                (a.workingDirectory.path === null || typeof a.workingDirectory.path === 'string') &&
+                typeof a.workingDirectory.source === 'string')));
 }
 /** Compose native reads. This module cannot dispatch execution or infer grants. */
 async function readTaskPreflight(taskId, reads) {
     const [workflowResult, executionResult] = await Promise.allSettled([
-        Promise.resolve().then(reads.workflow), Promise.resolve().then(reads.execution),
+        Promise.resolve().then(reads.workflow),
+        Promise.resolve().then(reads.execution),
     ]);
     const workflow = workflowResult.status === 'fulfilled' && isWorkflow(workflowResult.value, taskId)
         ? { status: 'observed', certainty: 'server_projection', value: workflowResult.value }
-        : unavailable(workflowResult.status === 'rejected' ? workflowResult.reason : { code: 'TASK_ACTIONABILITY_UNSUPPORTED' }, 'Workflow actionability');
+        : unavailable(workflowResult.status === 'rejected'
+            ? workflowResult.reason
+            : { code: 'TASK_ACTIONABILITY_UNSUPPORTED' }, 'Workflow actionability');
     const execution = executionResult.status === 'fulfilled' && isPreview(executionResult.value, taskId)
         ? { status: 'observed', certainty: 'server_projection', value: executionResult.value }
-        : unavailable(executionResult.status === 'rejected' ? executionResult.reason : { code: 'TASK_START_PREVIEW_UNSUPPORTED' }, 'Execution preview');
+        : unavailable(executionResult.status === 'rejected'
+            ? executionResult.reason
+            : { code: 'TASK_START_PREVIEW_UNSUPPORTED' }, 'Execution preview');
     // actionability.revision is the attention revision, not Task.version from
     // start-preview. Equal numbers would not prove the reads shared a snapshot.
     const workflowBlocked = workflow.status === 'observed' &&
-        !workflow.value.actionability.allowedActions.some(action => action.action === 'start_task');
+        !workflow.value.actionability.allowedActions.some((action) => action.action === 'start_task');
     const executionBlocked = execution.status === 'observed' && execution.value.executionAdmission.state === 'blocked';
-    const summary = workflowBlocked || executionBlocked ? 'blocked'
-        : workflow.status === 'unavailable' || execution.status === 'unavailable' ||
-            execution.value.executionAdmission.state !== 'ready' ? 'unknown'
+    const summary = workflowBlocked || executionBlocked
+        ? 'blocked'
+        : workflow.status === 'unavailable' ||
+            execution.status === 'unavailable' ||
+            execution.value.executionAdmission.state !== 'ready'
+            ? 'unknown'
             : 'eligible_to_attempt';
-    return { taskId, summary, workflow, execution, consistency: 'independent_observations', limits: [...LIMITS] };
+    return {
+        taskId,
+        summary,
+        workflow,
+        execution,
+        consistency: 'independent_observations',
+        limits: [...LIMITS],
+    };
 }
 function taskPreflightLines(report, bin = 'skrr') {
-    const lines = [`Task preflight: ${report.taskId}`, `Start eligibility: ${report.summary.replaceAll('_', ' ')} (current server projections)`];
+    const lines = [
+        `Task preflight: ${report.taskId}`,
+        `Start eligibility: ${report.summary.replaceAll('_', ' ')} (current server projections)`,
+    ];
     if (report.workflow.status === 'observed') {
         const a = report.workflow.value.actionability;
         lines.push('', `Workflow: ${a.state} (server projection)`, `Next actor: ${a.nextActor}`, `Why: ${a.reason} [${a.reasonCode}]`);
         if (a.actorRefs?.length)
-            lines.push(`Eligible actors: ${a.actorRefs.map(ref => `${ref.kind}:${ref.id}`).join(', ')}`);
+            lines.push(`Eligible actors: ${a.actorRefs.map((ref) => `${ref.kind}:${ref.id}`).join(', ')}`);
         for (const action of a.allowedActions) {
             const command = (0, task_operations_1.taskActionCommand)(action.action, report.taskId, action.targetId, bin, {
                 allowedActions: a.allowedActions,
@@ -116,6 +153,6 @@ function taskPreflightLines(report, bin = 'skrr') {
     }
     else
         lines.push('', `Execution: unknown. ${report.execution.message} [${report.execution.code}]`, `Next step: ${report.execution.remedy}`);
-    lines.push('', ...report.limits, `More operations: ${bin} tasks guide`);
+    lines.push('', ...report.limits, `More operations: ${bin} guide tasks commands`);
     return lines;
 }

package/dist/lib/task-runtime-headers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Account Authorization decides access; a separate server-issued session
+ * credential proves Agent authorship. Environment ids are selectors only.
+ * Share this across both CLI transports so Task authorship cannot depend on
+ * which command happens to use dataService rather than apiFetch.
+ */
+export declare function withTaskRuntimeHeaders(headers: Record<string, string>, requestUrl: string, method: string, env?: Record<string, string | undefined>): Record<string, string>;
+/** Custom credentials never follow HTTP redirects, including 302 POST-to-GET. */
+export declare function taskRuntimeRedirectOptions(headers: Record<string, string>): {
+    redirect?: 'error';
+};

package/dist/lib/task-runtime-headers.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTaskRuntimeHeaders = withTaskRuntimeHeaders;
+exports.taskRuntimeRedirectOptions = taskRuntimeRedirectOptions;
+/**
+ * Account Authorization decides access; a separate server-issued session
+ * credential proves Agent authorship. Environment ids are selectors only.
+ * Share this across both CLI transports so Task authorship cannot depend on
+ * which command happens to use dataService rather than apiFetch.
+ */
+function withTaskRuntimeHeaders(headers, requestUrl, method, env = process.env) {
+    const sent = { ...headers };
+    // A companion credential never travels on a read, another API surface,
+    // or a caller-selected header. Preserve existing nonsecret correlation
+    // hints outside generic Task mutations for other APIs' provenance checks.
+    for (const key of Object.keys(sent)) {
+        if (key.toLowerCase() === 'x-oversky-session-authorization')
+            delete sent[key];
+    }
+    if (!['POST', 'PUT', 'PATCH', 'DELETE'].includes(method.toUpperCase()))
+        return sent;
+    const refuseOrigin = () => Object.assign(new Error('Managed Task requests require their bound server origin; refusing account-attributed fallback.'), {
+        code: 'SESSION_TASK_ORIGIN_MISMATCH',
+    });
+    let target;
+    try {
+        target = new URL(requestUrl);
+    }
+    catch {
+        if (env.OVERSKY_AUTONOMOUS_SESSION === '1')
+            throw refuseOrigin();
+        return sent;
+    }
+    if (!/^\/api\/tasks(?:\/|$)/.test(target.pathname))
+        return sent;
+    const names = new Set(['x-oversky-agent-id', 'x-oversky-session-id', 'x-oversky-autonomous-run-id']);
+    for (const key of Object.keys(sent))
+        if (names.has(key.toLowerCase()))
+            delete sent[key];
+    if (env.OVERSKY_AUTONOMOUS_SESSION !== '1')
+        return sent;
+    const runId = env.OVERSKY_AUTONOMOUS_RUN_ID?.trim();
+    const sessionId = env.OVERSKY_SESSION_ID?.trim();
+    const token = env.OVERSKY_SESSION_TOKEN?.trim();
+    let trusted;
+    try {
+        trusted = new URL(env.OVERSKY_SERVER_URL || '');
+    }
+    catch {
+        throw refuseOrigin();
+    }
+    // The companion credential only travels to the managed runtime's server
+    // and only to generic Task mutations. Bound routes use it as Authorization.
+    if (target.origin !== trusted.origin)
+        throw refuseOrigin();
+    if (!sessionId || !token) {
+        throw Object.assign(new Error('Managed Task requests require their bound session credential; refusing account-attributed fallback.'), {
+            code: 'SESSION_TASK_CREDENTIAL_MISSING',
+        });
+    }
+    if (runId)
+        sent['X-Oversky-Autonomous-Run-Id'] = runId;
+    sent['X-Oversky-Session-Id'] = sessionId;
+    sent['X-Oversky-Session-Authorization'] = `Bearer ${token}`;
+    const agentId = env.OVERSKY_SESSION_AGENT_ID?.trim();
+    if (agentId)
+        sent['X-Oversky-Agent-Id'] = agentId;
+    return sent;
+}
+/** Custom credentials never follow HTTP redirects, including 302 POST-to-GET. */
+function taskRuntimeRedirectOptions(headers) {
+    return headers['X-Oversky-Session-Authorization'] ? { redirect: 'error' } : {};
+}

package/dist/lib/task-write-attribution.js

@@ -4,7 +4,7 @@ exports.ACCOUNT_ATTRIBUTION_NOTICE = exports.AGENT_BINDING_GUIDANCE = void 0;
 exports.taskWriteAttribution = taskWriteAttribution;
 exports.attributionLines = attributionLines;
 exports.runtimeWriteAttribution = runtimeWriteAttribution;
-exports.AGENT_BINDING_GUIDANCE = 'Assign this runtime in skrr → Engines, then run in its authenticated Agent session. ' +
+exports.AGENT_BINDING_GUIDANCE = 'Run `skrr tasks start <task>` to execute in the assigned Agent’s authenticated runtime. ' +
     'An --agent flag or an environment Agent id cannot establish authenticated authorship.';
 exports.ACCOUNT_ATTRIBUTION_NOTICE = 'Without authenticated Agent provenance, Task writes are attributed to the signed-in account. ' +
     'An account-attributed assessment is not proof of an independent human check.';

package/dist/lib/usage-discovery.d.ts

@@ -33,6 +33,10 @@ export declare const USAGE_OVERVIEW_TOKEN_BUDGET = 240;
  * `skrr widgets check`, and the app runs in the same frame. Its own overview line took the first read from 240 to 241
  * tokens, and this file's rule for that is to fold into a domain that already has the concept, not to raise the bound.
  * `skrr usage apps` still resolves, to the `widgets` pages, which name it in `Includes:`.
+ * `instruction-blocks` (version-pinned instruction blocks for cloud Agents) is the same concept as
+ * `instructions` (version-pinned blocks for local CLAUDE.md / AGENTS.md), aimed at another target. The overview
+ * read 245 once `skrr guide` joined it, and `guide` stays a line of its own because it is where every operation
+ * guide is read.
  */
 export declare const USAGE_DOMAIN_FOLDS: Readonly<Record<string, string>>;
 export declare const USAGE_DOMAIN_TOKEN_BUDGET = 500;

package/dist/lib/usage-discovery.js

@@ -44,10 +44,15 @@ exports.USAGE_OVERVIEW_TOKEN_BUDGET = 240;
  * `skrr widgets check`, and the app runs in the same frame. Its own overview line took the first read from 240 to 241
  * tokens, and this file's rule for that is to fold into a domain that already has the concept, not to raise the bound.
  * `skrr usage apps` still resolves, to the `widgets` pages, which name it in `Includes:`.
+ * `instruction-blocks` (version-pinned instruction blocks for cloud Agents) is the same concept as
+ * `instructions` (version-pinned blocks for local CLAUDE.md / AGENTS.md), aimed at another target. The overview
+ * read 245 once `skrr guide` joined it, and `guide` stays a line of its own because it is where every operation
+ * guide is read.
  */
 exports.USAGE_DOMAIN_FOLDS = {
     proposals: 'inbox',
     apps: 'widgets',
+    'instruction-blocks': 'instructions',
 };
 exports.USAGE_DOMAIN_TOKEN_BUDGET = 500;
 const GENERIC_FLAGS = new Set(['bare', 'help', 'json', 'token', 'workspace']);

package/dist/lib/usd-micros.d.ts

@@ -7,3 +7,30 @@
  * Returns null for anything that is not a positive amount with ≤ 2 decimals.
  */
 export declare function usdToMicros(amount: string): number | null;
+/**
+ * The same parse, but "0" is a price too: `--expected-price 0` pins free.
+ * Returns null for anything that is not an amount with ≤ 2 decimals.
+ */
+export declare function usdToMicrosOrZero(amount: string): number | null;
+/**
+ * `--expected-price` as micros: `undefined` when the flag was not passed,
+ * `null` when the value is not a USD amount.
+ */
+export declare function expectedPriceFlagMicros(value: string | undefined): number | null | undefined;
+/**
+ * The refusal text when `--expected-price` does not match what a paid
+ * install would now charge — one wording for every install command so the
+ * pin reads the same whichever listing it guarded (OSK-18256).
+ */
+export declare function expectedPriceMismatchMessage(expectedMicros: number, chargeMicros: number): string;
+/**
+ * A `--json` payload with every unstated-unit store price restated in
+ * dollars: a numeric `price`, `listPrice` or `charge` (integer micro-USD,
+ * the one unit store prices travel the wire in — see `storePricing.ts` in
+ * `@skrr-ai/data-provider`) gains a sibling `<name>Usd` in dollars, so a
+ * reader never has to know the conversion (OSK-18256). Fields that already
+ * name their unit (`amountMicros`, `*Micros`) and anything that is not a
+ * finite number pass through untouched; the wire fields themselves keep
+ * their values.
+ */
+export declare function withUsdPrices<T>(payload: T): T;

package/dist/lib/usd-micros.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.usdToMicros = usdToMicros;
+exports.usdToMicrosOrZero = usdToMicrosOrZero;
+exports.expectedPriceFlagMicros = expectedPriceFlagMicros;
+exports.expectedPriceMismatchMessage = expectedPriceMismatchMessage;
+exports.withUsdPrices = withUsdPrices;
+const data_provider_1 = require("@skrr-ai/data-provider");
 /**
  * Parse a user-typed USD amount ("5", "2.50") into integer micros.
  *
@@ -10,12 +15,72 @@ exports.usdToMicros = usdToMicros;
  * Returns null for anything that is not a positive amount with ≤ 2 decimals.
  */
 function usdToMicros(amount) {
+    const cents = parseUsdCents(amount);
+    if (cents === null || cents <= 0)
+        return null;
+    return cents * 10_000;
+}
+/**
+ * The same parse, but "0" is a price too: `--expected-price 0` pins free.
+ * Returns null for anything that is not an amount with ≤ 2 decimals.
+ */
+function usdToMicrosOrZero(amount) {
+    const cents = parseUsdCents(amount);
+    return cents === null ? null : cents * 10_000;
+}
+function parseUsdCents(amount) {
     const trimmed = amount.trim();
     if (!/^\d+(\.\d{1,2})?$/.test(trimmed))
         return null;
     const [whole, frac = ''] = trimmed.split('.');
     const cents = Number(whole) * 100 + Number(frac.padEnd(2, '0'));
-    if (!Number.isSafeInteger(cents) || cents <= 0)
+    // cents * 10_000 must stay an exact integer micros value.
+    if (!Number.isSafeInteger(cents) || cents > Number.MAX_SAFE_INTEGER / 10_000)
         return null;
-    return cents * 10_000;
+    return cents;
+}
+/**
+ * `--expected-price` as micros: `undefined` when the flag was not passed,
+ * `null` when the value is not a USD amount.
+ */
+function expectedPriceFlagMicros(value) {
+    return value === undefined ? undefined : usdToMicrosOrZero(value);
+}
+/**
+ * The refusal text when `--expected-price` does not match what a paid
+ * install would now charge — one wording for every install command so the
+ * pin reads the same whichever listing it guarded (OSK-18256).
+ */
+function expectedPriceMismatchMessage(expectedMicros, chargeMicros) {
+    return (`--expected-price ${(0, data_provider_1.formatStoreAcquisitionPrice)(expectedMicros)} does not match the price ` +
+        `the listing now charges (${(0, data_provider_1.formatStoreAcquisitionPrice)(chargeMicros)}). ` +
+        'Nothing was installed — read the price again and ask the person before buying.');
+}
+/** Fields that carry a store price in integer micro-USD without saying so. */
+const MICROS_PRICE_FIELDS = new Set(['price', 'listPrice', 'charge']);
+/**
+ * A `--json` payload with every unstated-unit store price restated in
+ * dollars: a numeric `price`, `listPrice` or `charge` (integer micro-USD,
+ * the one unit store prices travel the wire in — see `storePricing.ts` in
+ * `@skrr-ai/data-provider`) gains a sibling `<name>Usd` in dollars, so a
+ * reader never has to know the conversion (OSK-18256). Fields that already
+ * name their unit (`amountMicros`, `*Micros`) and anything that is not a
+ * finite number pass through untouched; the wire fields themselves keep
+ * their values.
+ */
+function withUsdPrices(payload) {
+    if (Array.isArray(payload)) {
+        return payload.map((item) => withUsdPrices(item));
+    }
+    if (payload === null || typeof payload !== 'object') {
+        return payload;
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(payload)) {
+        out[key] = withUsdPrices(value);
+        if (MICROS_PRICE_FIELDS.has(key) && typeof value === 'number' && Number.isFinite(value)) {
+            out[`${key}Usd`] = (0, data_provider_1.listingPriceMicrosToUsd)(value);
+        }
+    }
+    return out;
 }

package/dist/lib/voice-call-intent.js

@@ -74,9 +74,11 @@ function readVoiceCallSessionContext(env = process.env) {
     };
 }
 function generatedVoiceCallIdempotencyKey({ context, reason, conversationId, expiresInSeconds, }) {
+    if (!context.requestId)
+        return `voice-call:${crypto.randomUUID()}`;
     const input = [
         context.sessionId,
-        context.requestId || 'no-request-id',
+        context.requestId,
         context.agentId,
         reason,
         conversationId || '',

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/harnessPermissionControls.d.ts

@@ -30,3 +30,20 @@ export interface HarnessPermissionControlReport {
  * rather than a green badge. Additive fields are stripped for compatibility.
  */
 export declare function parseHarnessPermissionControls(value: unknown): HarnessPermissionControls | null;
+/** Last-reported local configuration and adapter protocol, never authority. */
+export interface HarnessSessionPolicyReport {
+    version: 1;
+    configuredDefault: {
+        provider: 'claude';
+        engine: 'sdk' | 'cli';
+        permissionMode: 'default' | 'acceptEdits' | 'plan' | 'bypassPermissions';
+    } | null;
+    taskCommandApproval: {
+        protocol: 'task_command_once_v1';
+        adapters: readonly {
+            provider: 'claude';
+            engine: 'sdk';
+        }[];
+    } | null;
+}
+export declare function parseHarnessSessionPolicyReport(value: unknown): HarnessSessionPolicyReport | null;

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/harnessPermissionControls.js

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var harnessPermissionControls_exports = {};
 __export(harnessPermissionControls_exports, {
-  parseHarnessPermissionControls: () => parseHarnessPermissionControls
+  parseHarnessPermissionControls: () => parseHarnessPermissionControls,
+  parseHarnessSessionPolicyReport: () => parseHarnessSessionPolicyReport
 });
 module.exports = __toCommonJS(harnessPermissionControls_exports);
 const PLAN = ["harness", "reported-actions", "unsupported", "unknown"];
@@ -63,7 +64,39 @@ function parseHarnessPermissionControls(value) {
     return null;
   }
 }
+function parseHarnessSessionPolicyReport(value) {
+  try {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      return null;
+    const row = value;
+    if (row.version !== 1)
+      return null;
+    let configuredDefault = null;
+    let taskCommandApproval = null;
+    const config = row.configuredDefault;
+    if (config && typeof config === "object" && !Array.isArray(config) && config.provider === "claude" && ["sdk", "cli"].includes(config.engine) && ["default", "acceptEdits", "plan", "bypassPermissions"].includes(config.permissionMode)) {
+      configuredDefault = Object.freeze({
+        provider: "claude",
+        engine: config.engine,
+        permissionMode: config.permissionMode
+      });
+    }
+    const approval = row.taskCommandApproval;
+    if (approval && typeof approval === "object" && !Array.isArray(approval) && approval.protocol === "task_command_once_v1" && Array.isArray(approval.adapters) && approval.adapters.length === 1 && approval.adapters[0]?.provider === "claude" && approval.adapters[0]?.engine === "sdk") {
+      taskCommandApproval = Object.freeze({
+        protocol: "task_command_once_v1",
+        adapters: Object.freeze([
+          Object.freeze({ provider: "claude", engine: "sdk" })
+        ])
+      });
+    }
+    return Object.freeze({ version: 1, configuredDefault, taskCommandApproval });
+  } catch {
+    return null;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  parseHarnessPermissionControls
+  parseHarnessPermissionControls,
+  parseHarnessSessionPolicyReport
 });

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/harnessPermissionControls.d.ts

@@ -30,3 +30,20 @@ export interface HarnessPermissionControlReport {
  * rather than a green badge. Additive fields are stripped for compatibility.
  */
 export declare function parseHarnessPermissionControls(value: unknown): HarnessPermissionControls | null;
+/** Last-reported local configuration and adapter protocol, never authority. */
+export interface HarnessSessionPolicyReport {
+    version: 1;
+    configuredDefault: {
+        provider: 'claude';
+        engine: 'sdk' | 'cli';
+        permissionMode: 'default' | 'acceptEdits' | 'plan' | 'bypassPermissions';
+    } | null;
+    taskCommandApproval: {
+        protocol: 'task_command_once_v1';
+        adapters: readonly {
+            provider: 'claude';
+            engine: 'sdk';
+        }[];
+    } | null;
+}
+export declare function parseHarnessSessionPolicyReport(value: unknown): HarnessSessionPolicyReport | null;