@skrr-ai/cli 0.1.117 → 0.1.119

package/dist/lib/scoped-memory-command.d.ts

@@ -67,6 +67,12 @@ export declare function parseMemoryApiError(error: ApiFetchError): {
 export declare abstract class ScopedMemoryCommand extends BaseCommand {
     protected endpoint(agentId: string, suffix?: string): string;
     protected memoryApi<T>(agentId: string, suffix: string, options?: ApiFetchOptions): Promise<T>;
+    protected memoryHistoryApi<T>(flags: ScopedFlags, options: {
+        versionId?: string;
+        memoryId?: string;
+        limit?: number;
+    }): Promise<T>;
+    private memoryRequest;
     protected query(flags: ScopedFlags, extra?: Record<string, unknown>): string;
     protected resolveStore(flags: ScopedFlags, { write }?: {
         write?: boolean | undefined;

package/dist/lib/scoped-memory-command.js

@@ -10,6 +10,7 @@ const core_1 = require("@oclif/core");
 const node_crypto_1 = require("node:crypto");
 const base_command_1 = require("../base-command");
 const api_fetch_1 = require("./api-fetch");
+const memory_history_session_1 = require("./memory-history-session");
 function parseMemoryStoreResolutions(value) {
     if (value === undefined)
         return undefined;
@@ -120,6 +121,9 @@ const ERROR_EXITS = {
     MEMORY_AUTHORIZATION_STALE: 8,
 };
 function parseMemoryApiError(error) {
+    if (error.code === 'MEMORY_HISTORY_API_UNSUPPORTED') {
+        return { code: error.code, message: error.message, retryable: false };
+    }
     try {
         const body = JSON.parse(error.body || '{}');
         const details = {
@@ -136,7 +140,7 @@ function parseMemoryApiError(error) {
         };
         return {
             code: String(body.code || body.error || error.code || 'MEMORY_API_ERROR').toUpperCase(),
-            message: [body.message || error.message, body.remedy].filter(Boolean).join(' '),
+            message: [body.message || error.message, body.remedy, error.recoveryHint].filter(Boolean).join(' '),
             retryable: body.retryable === true,
             ...(Object.keys(details).length ? { details } : {}),
         };
@@ -144,7 +148,7 @@ function parseMemoryApiError(error) {
     catch {
         return {
             code: error.code || 'MEMORY_API_ERROR',
-            message: error.message,
+            message: [error.message, error.recoveryHint].filter(Boolean).join(' '),
             retryable: false,
         };
     }
@@ -154,8 +158,35 @@ class ScopedMemoryCommand extends base_command_1.BaseCommand {
         return `/api/agents/${encodeURIComponent(agentId)}/memories/workspace${suffix}`;
     }
     async memoryApi(agentId, suffix, options = {}) {
+        return this.memoryRequest(this.endpoint(agentId, suffix), options);
+    }
+    async memoryHistoryApi(flags, options) {
+        const suffix = options.versionId ? `/${encodeURIComponent(options.versionId)}` : '';
+        const query = { memoryId: options.memoryId, limit: options.limit };
+        if (!(0, memory_history_session_1.hasMemoryHistoryRuntime)()) {
+            const store = await this.resolveStore(flags);
+            return this.memoryApi(flags.agent, `/stores/${store.id}/versions${suffix}${this.query(flags, query)}`);
+        }
+        const { sessionId } = (0, memory_history_session_1.memoryHistorySession)();
+        if (Boolean(flags.store) === Boolean(flags.scope)) {
+            this.error('Pass exactly one of --store <id> or --scope agent:<id>|space:<id>.', { exit: 2 });
+        }
+        if (flags.scope && !/^(agent|space):[^:]+$/.test(flags.scope)) {
+            this.error('--scope must be agent:<id> or space:<id>.', { exit: 2 });
+        }
+        if (flags.scope?.startsWith('space:') && !flags.space) {
+            this.error(`MEMORY_SPACE_CONTEXT_REQUIRED: --space ${flags.scope.slice(6)} is required when selecting ${flags.scope}.`, { exit: 2, code: 'MEMORY_SPACE_CONTEXT_REQUIRED' });
+        }
+        // Mount resolution belongs to the admitted session facade. A generic Store
+        // preflight would require an owner credential before the session-only read.
+        const path = `/api/agentic/sessions/${encodeURIComponent(sessionId)}/memory/agents/${encodeURIComponent(flags.agent)}/versions${suffix}`;
+        return this.memoryRequest(`${path}${this.query(flags, {
+            ...query, ...(flags.store ? { storeId: flags.store } : { scope: flags.scope }),
+        })}`, { sessionRead: 'memory-history-v1' });
+    }
+    async memoryRequest(path, options) {
         try {
-            return await (0, api_fetch_1.apiFetch)(this.endpoint(agentId, suffix), options);
+            return await (0, api_fetch_1.apiFetch)(path, options);
         }
         catch (error) {
             if (error instanceof api_fetch_1.ApiFetchError) {

package/dist/lib/store-listing.d.ts

@@ -15,7 +15,12 @@ import { type ReleaseCapabilityManifestView, type StoreAgentInstallFunnelSummary
  *     "withheld" with the floor it missed, never as 0 — a zero is a claim that
  *     nobody did the thing, and the server did not make that claim.
  */
-/** A listing's price in token credits (1,000,000 = $1), as the Store states it. */
+/**
+ * A listing's price as the Store prints it — `$4.00`, or `Free`. The wire
+ * value is integer micro-USD (1,000,000 = $1); every store, skills and
+ * actions command prints through this one formatter so no surface can quote
+ * the same price in a different unit (OSK-18256).
+ */
 export declare function formatListingPrice(price: number | null | undefined): string;
 /** `4.6 ★ (12 ratings)`, or `No ratings yet` — never `0.0` for an unrated listing. */
 export declare function formatListingRating(rating: number | null | undefined, count: number | null | undefined): string;

package/dist/lib/store-listing.js

@@ -29,7 +29,12 @@ const data_provider_1 = require("@skrr-ai/data-provider");
  *     "withheld" with the floor it missed, never as 0 — a zero is a claim that
  *     nobody did the thing, and the server did not make that claim.
  */
-/** A listing's price in token credits (1,000,000 = $1), as the Store states it. */
+/**
+ * A listing's price as the Store prints it — `$4.00`, or `Free`. The wire
+ * value is integer micro-USD (1,000,000 = $1); every store, skills and
+ * actions command prints through this one formatter so no surface can quote
+ * the same price in a different unit (OSK-18256).
+ */
 function formatListingPrice(price) {
     return (0, data_provider_1.formatStoreAcquisitionPrice)(price);
 }

package/dist/lib/task-admission.js

@@ -6,14 +6,34 @@ function admissionLines(value) {
     if (!value)
         return ['Execution admission: not reported by this server.'];
     const lines = [`Approval prerequisites: ${value.state}.`];
+    const observation = value.runtimePolicyObservation;
     if (value.permission) {
-        lines.push(`Permission policy: ${value.permission.mode || 'inherited/unknown'} (${value.permission.source || 'source unavailable'}).`);
+        lines.push(!value.permission.mode &&
+            value.permission.source === 'daemon' &&
+            observation?.source !== 'not_applicable'
+            ? 'Permission override: inherit daemon (no Agent or Harness override).'
+            : `Permission policy: ${value.permission.mode || 'inherited/unknown'} (${value.permission.source || 'source unavailable'}).`);
+    }
+    const configured = observation?.configuredDefault;
+    if (observation ? observation.source !== 'not_applicable' : value.permission?.source === 'daemon') {
+        if (configured && observation?.source === 'daemon_registration') {
+            lines.push(`Daemon last reported configured default: ${configured.permissionMode} (${configured.provider}/${configured.engine}; process registration at ${observation.reportedAt}). This is not the future effective policy.`);
+        }
+        else {
+            lines.push('Daemon configured default: unreported. Check status on the selected machine and daemon profile; reconnect or update that daemon to refresh its report.');
+        }
+        if (value.taskCommandApproval?.support === 'reported') {
+            lines.push(`Exact Task-command approval protocol: reported (${value.taskCommandApproval.provider}/${value.taskCommandApproval.engine}). Run, owner and command readiness remain unverified; no command is authorized.`);
+        }
+        else {
+            lines.push('Exact Task-command approval protocol: unreported for the selected engine.');
+        }
     }
     if (value.workingDirectory) {
         lines.push(`Working directory: ${value.workingDirectory.path || 'daemon configured default'} (${value.workingDirectory.source}; existence and access are checked on the machine at start).`);
     }
     if (value.unattended && !value.approverAvailable) {
-        lines.push('This run is unattended. Tools that need approval cannot obtain it during the run.');
+        lines.push('This run is unattended; generic provider interactive approval is unavailable. Exact Task-command requests have a separate approval path when supported.');
     }
     for (const constraint of value.constraints || []) {
         if (constraint.message)
@@ -29,7 +49,9 @@ function isAdmissionPreview(value) {
         return false;
     const row = value;
     const admission = row.executionAdmission;
-    return row.dryRun === true && typeof row.taskId === 'string' && Boolean(admission &&
-        ['ready', 'blocked', 'unknown'].includes(String(admission.state)) &&
-        admission.scope === 'approval_prerequisites');
+    return (row.dryRun === true &&
+        typeof row.taskId === 'string' &&
+        Boolean(admission &&
+            ['ready', 'blocked', 'unknown'].includes(String(admission.state)) &&
+            admission.scope === 'approval_prerequisites'));
 }

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,83 @@
+"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 Task authorship 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;
+    }
+    // Some platform operations materialize Tasks outside the Task router. Keep
+    // their exact POST routes here; action/library edits, picker reads and other
+    // integration routes must never receive the companion credential.
+    const taskMutation = /^\/api\/tasks(?:\/|$)/.test(target.pathname);
+    const taskCreation = method.toUpperCase() === 'POST' && [
+        /^\/api\/agents\/[^/]+\/agent-actions\/[^/]+\/run\/?$/,
+        /^\/api\/(?:shortcuts|task-templates)\/[^/]+\/(?:instantiate|trigger)\/?$/,
+        /^\/api\/templates\/[^/]+\/(?:instantiate|fork)\/?$/,
+        /^\/api\/store\/services\/[^/]+\/install\/?$/,
+    ].some((route) => route.test(target.pathname));
+    if (!taskMutation && !taskCreation)
+        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 Task mutations/materialization. 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/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/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;

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

@@ -57,3 +57,47 @@ export function parseHarnessPermissionControls(value) {
         return null;
     }
 }
+export 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;
+    }
+}

package/dist/node_modules/@skrr-ai/auth-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skrr-ai/auth-core",
-  "version": "0.4.30",
+  "version": "0.4.31",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",
   "exports": {