@skrr-ai/cli 0.1.118 → 0.1.119

package/dist/base-command.d.ts

@@ -32,6 +32,7 @@ export declare abstract class BaseCommand extends Command {
      * acquiring unrelated account authority. Human invocations are unaffected.
      */
     static autonomousCredentialPolicy: 'delegated' | 'bound-session';
+    static sessionReadPolicy?: 'memory-history-v1';
     /** Add the owning agent's web detail link without overwriting resource URLs. */
     protected withAgentContext<T>(agentId: string, value: T): T & {
         agentUrl: string | null;

package/dist/base-command.js

@@ -53,6 +53,7 @@ const cli_id_1 = require("./lib/cli-id");
 const keychain_2 = require("./lib/keychain");
 const outbox_1 = require("./lib/outbox");
 const node_adapter_1 = require("./lib/node-adapter");
+const memory_history_session_1 = require("./lib/memory-history-session");
 const migrate_1 = require("./lib/migrate");
 const auth_core_init_1 = require("./lib/auth-core-init");
 const credential_resolver_1 = require("./lib/credential-resolver");
@@ -125,6 +126,7 @@ class BaseCommand extends core_1.Command {
      * acquiring unrelated account authority. Human invocations are unaffected.
      */
     static autonomousCredentialPolicy = 'delegated';
+    static sessionReadPolicy;
     /** Add the owning agent's web detail link without overwriting resource URLs. */
     withAgentContext(agentId, value) {
         const agentUrl = (0, web_url_1.agentUrlFrom)(this.cliConfig.baseURL, { id: agentId });
@@ -292,7 +294,11 @@ class BaseCommand extends core_1.Command {
         // touching migration, Keychain/file auth, refresh, or daemon auto-broker
         // state. The restricted session token (or a null credential when it is
         // missing) is the only adapter authority exposed to the command.
-        let autonomousCredential = (0, credential_resolver_1.resolveTrustedAutonomousCredential)();
+        const historySession = this.constructor.sessionReadPolicy === 'memory-history-v1' &&
+            (0, memory_history_session_1.hasMemoryHistoryRuntime)() ? (0, memory_history_session_1.memoryHistorySession)() : null;
+        let autonomousCredential = historySession
+            ? { token: historySession.token, source: 'env-token', kind: (0, auth_core_1.classifyTokenKind)(historySession.token) }
+            : (0, credential_resolver_1.resolveTrustedAutonomousCredential)();
         const boundSessionCommand = Boolean(autonomousCredential &&
             this.constructor.autonomousCredentialPolicy === 'bound-session');
         if ((0, delegated_cli_1.isDelegatedCliSession)() && !boundSessionCommand) {

package/dist/commands/memory/versions/list.d.ts

@@ -1,5 +1,7 @@
 import { ScopedMemoryCommand } from '../../../lib/scoped-memory-command';
 export default class MemoryVersionsList extends ScopedMemoryCommand {
+    static autonomousCredentialPolicy: "bound-session";
+    static sessionReadPolicy: "memory-history-v1";
     static description: string;
     static args: {
         memory: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;

package/dist/commands/memory/versions/list.js

@@ -4,14 +4,15 @@ const list_output_1 = require("../../../lib/list-output");
 const core_1 = require("@oclif/core");
 const scoped_memory_command_1 = require("../../../lib/scoped-memory-command");
 class MemoryVersionsList extends scoped_memory_command_1.ScopedMemoryCommand {
+    static autonomousCredentialPolicy = 'bound-session';
+    static sessionReadPolicy = 'memory-history-v1';
     static description = 'List immutable versions for one Memory topic';
     static args = { memory: core_1.Args.string({ required: true, ignoreStdin: true }) };
     static flags = { ...scoped_memory_command_1.scopedMemoryFlags, limit: core_1.Flags.integer({ default: 100 }) };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(MemoryVersionsList);
-        const store = await this.resolveStore(flags);
-        const result = await this.memoryApi(flags.agent, `/stores/${store.id}/versions${this.query(flags, { memoryId: args.memory, limit: flags.limit })}`);
+        const result = await this.memoryHistoryApi(flags, { memoryId: args.memory, limit: flags.limit });
         if (flags.json)
             return this.printJsonResult((0, list_output_1.listResult)(result, 'versions'));
         for (const version of result.versions)

package/dist/commands/memory/versions/show.d.ts

@@ -1,5 +1,7 @@
 import { ScopedMemoryCommand } from '../../../lib/scoped-memory-command';
 export default class MemoryVersionsShow extends ScopedMemoryCommand {
+    static autonomousCredentialPolicy: "bound-session";
+    static sessionReadPolicy: "memory-history-v1";
     static description: string;
     static args: {
         id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;

package/dist/commands/memory/versions/show.js

@@ -3,14 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const scoped_memory_command_1 = require("../../../lib/scoped-memory-command");
 class MemoryVersionsShow extends scoped_memory_command_1.ScopedMemoryCommand {
+    static autonomousCredentialPolicy = 'bound-session';
+    static sessionReadPolicy = 'memory-history-v1';
     static description = 'Show one immutable MemoryVersion';
     static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
     static flags = scoped_memory_command_1.scopedMemoryFlags;
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(MemoryVersionsShow);
-        const store = await this.resolveStore(flags);
-        const result = await this.memoryApi(flags.agent, `/stores/${store.id}/versions/${encodeURIComponent(args.id)}${this.query(flags)}`);
+        const result = await this.memoryHistoryApi(flags, { versionId: args.id });
         this.print(result, flags.json, `${result.id}  ${result.operation}\n${JSON.stringify(result.payloadSnapshot, null, 2)}`);
     }
 }

package/dist/lib/api-fetch.d.ts

@@ -5,6 +5,8 @@ export interface ApiFetchOptions {
     body?: unknown;
     /** Override credential resolution — useful for tests. */
     credential?: ResolvedCredential;
+    /** Exact admitted-session Memory history GET; never uses owner credentials. */
+    sessionRead?: 'memory-history-v1';
     /**
      * Extra request headers. Added for `X-Idempotency-Key` (OSK-2806): the
      * shared data-provider transport takes no per-call options, so a replayed
@@ -37,6 +39,8 @@ export declare class ApiFetchError extends Error {
      * attributed by guesswork — see `node-adapter.ts`.
      */
     readonly requestId?: string;
+    /** Client recovery guidance; never changes the server's refusal status/code. */
+    recoveryHint?: string;
     /** Milliseconds the server asked us to wait (`Retry-After`) on a 429. */
     retryAfterMs?: number;
     /**

package/dist/lib/api-fetch.js

@@ -49,6 +49,7 @@ const workspace_header_1 = require("./workspace-header");
 const task_runtime_headers_1 = require("./task-runtime-headers");
 const non_json_response_1 = require("./non-json-response");
 const rate_limit_retry_1 = require("./rate-limit-retry");
+const memory_history_session_1 = require("./memory-history-session");
 class ApiFetchError extends Error {
     status;
     body;
@@ -65,6 +66,8 @@ class ApiFetchError extends Error {
      * attributed by guesswork — see `node-adapter.ts`.
      */
     requestId;
+    /** Client recovery guidance; never changes the server's refusal status/code. */
+    recoveryHint;
     /** Milliseconds the server asked us to wait (`Retry-After`) on a 429. */
     retryAfterMs;
     /**
@@ -92,7 +95,11 @@ exports.ApiFetchError = ApiFetchError;
  * `err.status` / `err.code`.
  */
 async function apiFetch(pathOrUrl, opts = {}) {
-    const sessionCredential = (0, credential_resolver_1.resolveTrustedAutonomousCredential)();
+    const historyRead = opts.sessionRead
+        ? (0, memory_history_session_1.bindMemoryHistoryRead)(pathOrUrl, opts.method ?? 'GET') : null;
+    const sessionCredential = historyRead
+        ? { token: historyRead.token, source: 'env-token', kind: (0, credential_resolver_1.kindOf)(historyRead.token) }
+        : (0, credential_resolver_1.resolveTrustedAutonomousCredential)();
     // A few Agent-only APIs (message/voice/telephony intents) deliberately pass
     // the daemon-issued session token explicitly. Keep those endpoints bound to
     // the session principal; every other CLI API call in a delegated Agent uses
@@ -104,17 +111,17 @@ async function apiFetch(pathOrUrl, opts = {}) {
     // equality check against it silently fail open.
     const envSessionToken = process.env.OVERSKY_SESSION_TOKEN?.trim() || null;
     const explicitSessionCredential = Boolean(opts.credential?.token && envSessionToken && opts.credential.token === envSessionToken);
-    const delegatedCli = (0, delegated_cli_1.isDelegatedCliSession)() && !explicitSessionCredential;
+    const delegatedCli = (0, delegated_cli_1.isDelegatedCliSession)() && !explicitSessionCredential && !historyRead;
     const autonomousCredential = delegatedCli
         ? await (0, delegated_cli_1.fetchDelegatedCliCredential)()
         : sessionCredential;
     const baseURL = autonomousCredential ? trustedAutonomousBaseUrl() : (0, config_1.loadConfig)().baseURL;
     const method = opts.method ?? 'GET';
-    const url = /^https?:\/\//i.test(pathOrUrl)
+    const url = historyRead?.url ?? (/^https?:\/\//i.test(pathOrUrl)
         ? autonomousCredential
             ? assertTrustedAutonomousUrl(pathOrUrl, baseURL)
             : pathOrUrl
-        : `${baseURL.replace(/\/+$/, '')}${pathOrUrl.startsWith('/') ? '' : '/'}${pathOrUrl}`;
+        : `${baseURL.replace(/\/+$/, '')}${pathOrUrl.startsWith('/') ? '' : '/'}${pathOrUrl}`);
     // A FormData body passes through untouched — fetch sets the multipart
     // boundary itself, and stringifying would destroy it. Upload commands
     // (tasks attachments) need this on the session-scoped path, which is not
@@ -190,13 +197,16 @@ async function apiFetch(pathOrUrl, opts = {}) {
         // OSK-12020 — a fresh proof per attempt for a DPoP-bound hand-off token
         // (the 401 retry below re-enters here and gets its own). No-op otherwise.
         Object.assign(headers, await (0, dpop_auth_1.dpopHeadersFor)(credential.token, method, url));
-        const sent = (0, task_runtime_headers_1.withTaskRuntimeHeaders)((0, workspace_header_1.withWorkspaceHeader)(headers), url, method);
+        const sent = (0, task_runtime_headers_1.withTaskRuntimeHeaders)((0, workspace_header_1.withWorkspaceHeader)(headers, historyRead ? {
+            OVERSKY_AUTONOMOUS_SESSION: '1',
+            OVERSKY_SESSION_WORKSPACE_ID: process.env.OVERSKY_SESSION_WORKSPACE_ID,
+        } : process.env), url, method);
         // E6: a 429 on a GET or an idempotency-keyed write is retried (bounded,
         // jittered, honouring Retry-After). The last 429's wait is kept for the error.
         const { response, retryAfterMs } = await (0, rate_limit_retry_1.fetchWithRateLimitRetry)(() => fetch(url, {
             method,
             headers: sent,
-            ...(0, task_runtime_headers_1.taskRuntimeRedirectOptions)(sent),
+            ...(historyRead ? { redirect: 'error' } : (0, task_runtime_headers_1.taskRuntimeRedirectOptions)(sent)),
             body,
             ...(opts.signal ? { signal: opts.signal } : {}),
         }), { method, headers: sent, signal: opts.signal });
@@ -218,6 +228,7 @@ async function apiFetch(pathOrUrl, opts = {}) {
         }
     }
     else if (res.status === 401 &&
+        !historyRead &&
         (0, daemonBroker_1.isBrokeredHandoffToken)(cred.token) &&
         !isAuthEndpoint(pathOrUrl)) {
         // Broker-mode hand-off credential: nothing was persisted, so there is no
@@ -279,7 +290,14 @@ async function apiFetch(pathOrUrl, opts = {}) {
         catch {
             /* ignore body read failures */
         }
-        const error = new ApiFetchError(`HTTP ${res.status} ${res.statusText} — ${method} ${pathOrUrl}`, res.status, text, code, method, res.headers.get('x-request-id') || undefined);
+        const unsupportedHistory = historyRead && res.status === 404 &&
+            (!code || ['API_ROUTE_NOT_FOUND', 'ROUTE_NOT_FOUND'].includes(code));
+        const error = new ApiFetchError(unsupportedHistory
+            ? 'This server does not support session-scoped Memory history. Upgrade the server before retrying; owner-credential fallback is disabled.'
+            : `HTTP ${res.status} ${res.statusText} — ${method} ${pathOrUrl}`, res.status, text, unsupportedHistory ? 'MEMORY_HISTORY_API_UNSUPPORTED' : code, method, res.headers.get('x-request-id') || undefined);
+        if (historyRead && res.status === 401) {
+            error.recoveryHint = 'Reconnect the managed Agent session and retry. If the refusal persists, check that this server supports session-scoped Memory history. Owner-credential fallback is disabled.';
+        }
         if (brokerFailure)
             error.brokerFailure = brokerFailure;
         if (res.status === 429 && lastRetryAfterMs !== undefined)

package/dist/lib/memory-history-session.d.ts

@@ -0,0 +1,14 @@
+type RuntimeEnv = Record<string, string | undefined>;
+export declare function hasMemoryHistoryRuntime(env?: RuntimeEnv): boolean;
+/** Only this explicit read contract may select a primary session credential. */
+export declare function bindMemoryHistoryRead(pathOrUrl: string, method: string, env?: RuntimeEnv): {
+    url: string;
+    origin: string;
+    token: string;
+};
+export declare function memoryHistorySession(env?: RuntimeEnv): {
+    sessionId: string;
+    token: string;
+    server: URL;
+};
+export {};

package/dist/lib/memory-history-session.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasMemoryHistoryRuntime = hasMemoryHistoryRuntime;
+exports.bindMemoryHistoryRead = bindMemoryHistoryRead;
+exports.memoryHistorySession = memoryHistorySession;
+function hasMemoryHistoryRuntime(env = process.env) {
+    // Interactive SDK children can carry the daemon's session tuple without an
+    // AutonomousRun or the wrapper's autonomous marker. Partial tuples must not
+    // silently turn a managed history read into an owner-account read.
+    return env.OVERSKY_AUTONOMOUS_SESSION === '1' ||
+        Boolean(env.OVERSKY_SESSION_ID?.trim() || env.OVERSKY_SESSION_TOKEN?.trim());
+}
+function refusal(message, code, status) {
+    return Object.assign(new Error(message), { code, status });
+}
+/** Only this explicit read contract may select a primary session credential. */
+function bindMemoryHistoryRead(pathOrUrl, method, env = process.env) {
+    const { sessionId, token, server } = memoryHistorySession(env);
+    let target;
+    try {
+        target = new URL(pathOrUrl, server);
+    }
+    catch {
+        throw refusal('Memory history requires the bound session server. Start a new managed Agent session.', 'MEMORY_RUNTIME_ORIGIN_MISMATCH', 403);
+    }
+    if (target.origin !== server.origin || target.username || target.password) {
+        throw refusal('Memory history cannot send its session credential to another server.', 'MEMORY_RUNTIME_ORIGIN_MISMATCH', 403);
+    }
+    const route = /^\/api\/agentic\/sessions\/([^/]+)\/memory\/agents\/([^/]+)\/versions(?:\/([^/]+))?$/.exec(target.pathname);
+    let selectedSession;
+    let selectedAgent;
+    try {
+        selectedSession = route ? decodeURIComponent(route[1]) : undefined;
+        selectedAgent = route ? decodeURIComponent(route[2]) : undefined;
+    }
+    catch { /* malformed encoded selectors are refused below */ }
+    if (method.toUpperCase() !== 'GET' || !route || selectedSession !== sessionId ||
+        (env.OVERSKY_SESSION_AGENT_ID?.trim() && selectedAgent !== env.OVERSKY_SESSION_AGENT_ID.trim())) {
+        throw refusal('Memory history must target this admitted Agent session. Start a session for the selected Agent.', 'MEMORY_RUNTIME_SCOPE_MISMATCH', 403);
+    }
+    return { url: target.toString(), origin: server.origin, token };
+}
+function memoryHistorySession(env = process.env) {
+    const sessionId = env.OVERSKY_SESSION_ID?.trim();
+    const token = env.OVERSKY_SESSION_TOKEN?.trim();
+    if (!sessionId || !token?.startsWith('agst_')) {
+        throw refusal('Memory history requires the bound Agent session credential. Start a managed Agent session; owner credentials cannot replace it.', 'MEMORY_RUNTIME_CREDENTIAL_MISSING', 401);
+    }
+    let trusted;
+    try {
+        trusted = new URL(env.OVERSKY_SERVER_URL || '');
+    }
+    catch {
+        throw refusal('Memory history requires the bound session server. Start a new managed Agent session.', 'MEMORY_RUNTIME_ORIGIN_MISMATCH', 403);
+    }
+    if (!['https:', 'http:'].includes(trusted.protocol) || trusted.username || trusted.password) {
+        throw refusal('Memory history cannot send its session credential to another server.', 'MEMORY_RUNTIME_ORIGIN_MISMATCH', 403);
+    }
+    return { sessionId, token, server: trusted };
+}

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/task-runtime-headers.js

@@ -12,7 +12,7 @@ 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.
+    // 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];
@@ -31,7 +31,17 @@ function withTaskRuntimeHeaders(headers, requestUrl, method, env = process.env)
             throw refuseOrigin();
         return sent;
     }
-    if (!/^\/api\/tasks(?:\/|$)/.test(target.pathname))
+    // 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))
@@ -50,7 +60,7 @@ function withTaskRuntimeHeaders(headers, requestUrl, method, env = process.env)
         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.
+    // and only to Task mutations/materialization. Bound routes use it as Authorization.
     if (target.origin !== trusted.origin)
         throw refuseOrigin();
     if (!sessionId || !token) {

package/oclif.manifest.json

@@ -73568,6 +73568,8 @@
       "pluginName": "@skrr-ai/cli",
       "pluginType": "core",
       "strict": true,
+      "autonomousCredentialPolicy": "bound-session",
+      "sessionReadPolicy": "memory-history-v1",
       "isESM": false,
       "relativePath": [
         "dist",
@@ -73928,6 +73930,8 @@
       "pluginName": "@skrr-ai/cli",
       "pluginType": "core",
       "strict": true,
+      "autonomousCredentialPolicy": "bound-session",
+      "sessionReadPolicy": "memory-history-v1",
       "isESM": false,
       "relativePath": [
         "dist",
@@ -138173,5 +138177,5 @@
       ]
     }
   },
-  "version": "0.1.118"
+  "version": "0.1.119"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skrr-ai/cli",
-  "version": "0.1.118",
+  "version": "0.1.119",
   "description": "Command-line interface for skrr",
   "license": "ISC",
   "author": "skrr",