@skrr-ai/cli 0.1.114 → 0.1.115

package/dist/lib/lookbackPlans.d.ts

@@ -1,13 +1,27 @@
-import { lookbackPlansApi, type CreateLookbackPlanRequest, type LookbackPlan, type LookbackPlanInput } from '@skrr-ai/data-provider';
-export { lookbackPlansApi };
+import { lookbackPlansApi, isLookbackMutationOutcomeUnknown, type CreateLookbackPlanRequest, type LookbackPlan, type LookbackPlanInput } from '@skrr-ai/data-provider';
+export { lookbackPlansApi, isLookbackMutationOutcomeUnknown };
 export declare function lookbackInputFailure(error: unknown): {
+    code: "LOOKBACK_INVALID_FIELD" | "LOOKBACK_INVALID_TIME" | "LOOKBACK_INVALID_TIMEZONE" | "LOOKBACK_AMBIGUOUS_TIME" | "LOOKBACK_NONEXISTENT_TIME" | "LOOKBACK_LIMIT_EXCEEDED";
+    message: string;
+    details: {
+        field?: string | undefined;
+        stage: string;
+        retryCondition: string;
+        remedy: string;
+    };
     exit: number;
     retryable: boolean;
-    details?: {
-        field: string;
-    } | undefined;
-    code: "LOOKBACK_INVALID_FIELD" | "LOOKBACK_INVALID_TIME" | "LOOKBACK_INVALID_TIMEZONE" | "LOOKBACK_AMBIGUOUS_TIME" | "LOOKBACK_NONEXISTENT_TIME" | "LOOKBACK_LIMIT_EXCEEDED";
+};
+export declare function lookbackUnconfirmedFailure(details: Record<string, unknown>): {
+    code: string;
     message: string;
+    exit: number;
+    retryable: boolean;
+    details: {
+        stage: string;
+        retryCondition: string;
+        remedy: string;
+    };
 };
 export declare const lookbackPlanIdArg: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
 /** JSON can be the plan itself or the canonical create envelope. Never copy identity fields. */

package/dist/lib/lookbackPlans.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lookbackPlanIdArg = exports.lookbackPlansApi = void 0;
+exports.lookbackPlanIdArg = exports.isLookbackMutationOutcomeUnknown = exports.lookbackPlansApi = void 0;
 exports.lookbackInputFailure = lookbackInputFailure;
+exports.lookbackUnconfirmedFailure = lookbackUnconfirmedFailure;
 exports.lookbackCreateBody = lookbackCreateBody;
 exports.lookbackInput = lookbackInput;
 exports.lookbackPlanSummary = lookbackPlanSummary;
@@ -9,6 +10,7 @@ exports.lookbackArmingLine = lookbackArmingLine;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 Object.defineProperty(exports, "lookbackPlansApi", { enumerable: true, get: function () { return data_provider_1.lookbackPlansApi; } });
+Object.defineProperty(exports, "isLookbackMutationOutcomeUnknown", { enumerable: true, get: function () { return data_provider_1.isLookbackMutationOutcomeUnknown; } });
 const followups_1 = require("./followups");
 class LookbackValidationError extends Error {
     issue;
@@ -18,12 +20,23 @@ class LookbackValidationError extends Error {
     }
 }
 function lookbackInputFailure(error) {
+    const repair = { stage: 'validation', retryCondition: 'correct_input',
+        remedy: 'Correct the indicated input field before submitting again.',
+        ...(error instanceof LookbackValidationError ? { field: error.issue.field } : {}),
+    };
     return {
         code: error instanceof LookbackValidationError ? error.issue.code : 'LOOKBACK_INVALID_FIELD',
         message: error instanceof Error ? error.message : String(error),
-        ...(error instanceof LookbackValidationError ? { details: { field: error.issue.field } } : {}),
-        exit: 2,
-        retryable: false,
+        // BaseCommand's machine envelope carries additive domain facts in details.
+        details: repair, exit: 2, retryable: false,
+    };
+}
+function lookbackUnconfirmedFailure(details) {
+    return {
+        code: 'LOOKBACK_OUTCOME_UNCONFIRMED', message: 'The plan update outcome could not be confirmed. Read the original source or known plan before submitting another change.',
+        exit: 5, retryable: false,
+        details: { stage: 'lifecycle', retryCondition: 'read_original_source_or_known_plan',
+            remedy: 'Read the known plan or original source. Do not submit a replacement source or blindly repeat this mutation.', ...details },
     };
 }
 exports.lookbackPlanIdArg = core_1.Args.string({
@@ -75,7 +88,8 @@ function lookbackInput(raw, allowPast = false) {
     return raw;
 }
 function lookbackPlanSummary(plan) {
-    const next = plan.steps.find((step) => step.state === 'pending');
+    const next = plan.steps.filter((step) => step.state === 'pending')
+        .reduce((earliest, step) => !earliest || Date.parse(step.runAt) < Date.parse(earliest.runAt) ? step : earliest, undefined);
     return `${plan.id}  [${plan.state}] r${plan.revision}  ${plan.title || plan.objective}` +
         `  ${plan.steps.length} lookbacks${next ? `  next:${next.runAt}` : ''}`;
 }

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

@@ -0,0 +1,228 @@
+/**
+ * Computer Use v1 is a host-to-host protocol, never a model tool schema.
+ * Models see exactly the runtime's js/js_reset surface. In particular, script
+ * contents cannot prove that a call is read-only or supply execution identity.
+ * Kept dependency-free so daemon, API, browser and native clients agree.
+ */
+export declare const COMPUTER_USE_TOOL: "ComputerUse";
+export declare const COMPUTER_USE_PROVIDER: "lcu";
+export declare const COMPUTER_USE_PROTOCOL: "computer_use_mcp_v1";
+export declare const COMPUTER_USE_ROTATE_CREDENTIAL_EVENT: "daemon:computer-use:rotate-credential";
+/** Owner-approved hosted credential upgrade; no bearer secret travels in this request. */
+export interface ComputerUseRotateCredentialRequest {
+    requestId: string;
+    ownerUserId: string;
+    machineUuid: string;
+    leaseId: string;
+    generation: number;
+}
+export declare const COMPUTER_USE_EXECUTION_CAPABILITY: "computer_use";
+export declare const COMPUTER_USE_CLOUD_CONSENT: "computer_use_cloud_agents_v1";
+export declare const COMPUTER_USE_PUBLIC_TOOLS: readonly ["js", "js_reset"];
+export type ComputerUsePublicTool = (typeof COMPUTER_USE_PUBLIC_TOOLS)[number];
+export declare const COMPUTER_USE_OPERATIONS: readonly ["describe", "call", "end_turn", "close", "status", "control_stop"];
+export type ComputerUseOperation = (typeof COMPUTER_USE_OPERATIONS)[number];
+export type ComputerUseSurfaceMode = 'computer' | 'browser' | 'all';
+export type ComputerUseEndReason = 'Stop' | 'Interrupt';
+/** Identity is derived from authenticated execution, never tool arguments. */
+export interface ComputerUseHostContext {
+    principalId: string;
+    machineId: string;
+    sessionId: string;
+    turnId: string;
+    generation: number;
+    toolCallId?: string;
+    agentId?: string;
+    engine?: string;
+    conversationId?: string;
+    contextKey?: string;
+}
+export interface ComputerUseBudgets {
+    activeExecutionMs: number;
+    humanResponseMs: number;
+    totalLifetimeMs: number;
+    cleanupGraceMs: number;
+}
+export declare const COMPUTER_USE_DEFAULT_BUDGETS: Readonly<ComputerUseBudgets>;
+/** Negotiated ceilings; exceeding a limit is an error, never silent clipping. */
+export declare const COMPUTER_USE_LIMITS: Readonly<{
+    maxEnvelopeBytes: number;
+    maxInstructionsBytes: number;
+    maxSchemaBytes: number;
+    maxContentBlocks: 512;
+    maxIdentityChars: 512;
+    maxActiveExecutionMs: 900000;
+    maxHumanResponseMs: 900000;
+    maxTotalLifetimeMs: 1800000;
+    maxCleanupGraceMs: 60000;
+}>;
+/** Preserve upstream fields and schemas, including annotations and extensions. */
+export interface ComputerUseToolDescriptor {
+    name: ComputerUsePublicTool;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface ComputerUseMcpContent {
+    type: string;
+    [key: string]: unknown;
+}
+export interface ComputerUseMcpResult {
+    content: ComputerUseMcpContent[];
+    isError?: boolean;
+    structuredContent?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface ComputerUseVersions {
+    lcu: string;
+    adapter?: string;
+    app?: string;
+    runtime?: string;
+    [key: string]: string | undefined;
+}
+export interface ComputerUseRuntimePolicy {
+    replPersistence: 'turn';
+    audioCleanup: 'retire-runtime';
+}
+export interface ComputerUseSurface {
+    protocol: typeof COMPUTER_USE_PROTOCOL;
+    provider: typeof COMPUTER_USE_PROVIDER;
+    instructions: string;
+    tools: ComputerUseToolDescriptor[];
+    versions: ComputerUseVersions;
+    /** Digest of the actual instructions and full descriptors, not a version label. */
+    digest: string;
+    surfaceMode: ComputerUseSurfaceMode;
+    /** Host-observed lifecycle constraints, separate from original runtime instructions. */
+    runtimePolicy?: ComputerUseRuntimePolicy;
+}
+/** Preserve original documentation while explaining the host's narrower lifecycle. */
+export declare function computerUseModelInstructions(surface: ComputerUseSurface): string;
+export declare const COMPUTER_USE_RUNTIME_STATES: readonly ["disabled", "starting", "ready", "executing", "awaiting_approval", "ending_turn", "unavailable", "closed"];
+export type ComputerUseRuntimeState = (typeof COMPUTER_USE_RUNTIME_STATES)[number];
+export interface ComputerUseReadiness {
+    provider: typeof COMPUTER_USE_PROVIDER;
+    protocol: typeof COMPUTER_USE_PROTOCOL;
+    state: ComputerUseRuntimeState;
+    available: boolean;
+    enabled: boolean;
+    cloudAgentsAllowed: boolean;
+    reason?: string;
+    versions?: ComputerUseVersions;
+    surfaceDigest?: string;
+    /** Capability readiness is independent of whether a person granted consent. */
+    browserReady?: boolean;
+    audioReady?: boolean;
+}
+export interface ComputerUseStatus extends ComputerUseReadiness {
+    controller?: Pick<ComputerUseHostContext, 'sessionId' | 'turnId' | 'generation' | 'agentId' | 'conversationId'>;
+    pendingApprovalId?: string;
+    cleanupConfirmed?: boolean;
+}
+export type ComputerUseInput = {
+    operation: 'describe';
+    surfaceMode?: ComputerUseSurfaceMode;
+} | {
+    operation: 'call';
+    tool: ComputerUsePublicTool;
+    arguments: Record<string, unknown>;
+    surfaceDigest?: string;
+    budgets?: Partial<ComputerUseBudgets>;
+} | {
+    operation: 'end_turn';
+    reason: ComputerUseEndReason;
+} | {
+    operation: 'close';
+    reason?: string;
+} | {
+    operation: 'status';
+} | {
+    operation: 'control_stop';
+    reason?: string;
+};
+export type ComputerUseRequest = ComputerUseInput & {
+    protocol: typeof COMPUTER_USE_PROTOCOL;
+    provider: typeof COMPUTER_USE_PROVIDER;
+    context: ComputerUseHostContext;
+};
+export interface ComputerUseCleanupResult {
+    /** True only after the runtime confirms execution can no longer produce input. */
+    cleanupConfirmed: boolean;
+    closed: boolean;
+    generation: number;
+}
+export type ComputerUseResponse = {
+    operation: 'describe';
+    surface: ComputerUseSurface;
+} | {
+    operation: 'call';
+    mcpResult: ComputerUseMcpResult;
+} | {
+    operation: 'status';
+    status: ComputerUseStatus;
+} | {
+    operation: 'end_turn' | 'close' | 'control_stop';
+    cleanup: ComputerUseCleanupResult;
+};
+export declare const COMPUTER_USE_ELICITATION_CHOICES: readonly ["once", "session", "always", "decline"];
+export type ComputerUseElicitationChoice = (typeof COMPUTER_USE_ELICITATION_CHOICES)[number];
+export interface ComputerUseElicitationOption {
+    value: ComputerUseElicitationChoice;
+    label: string;
+    description?: string;
+}
+/** This is a dedicated permission request, not AskUserQuestion or sticky tool approval. */
+export interface ComputerUseElicitationRequest {
+    kind: 'computer_use_runtime';
+    requestId: string;
+    context: ComputerUseHostContext & {
+        toolCallId: string;
+    };
+    message: string;
+    resource?: Record<string, unknown>;
+    options: ComputerUseElicitationOption[];
+    expiresAt: number;
+}
+export interface ComputerUseElicitationResponse {
+    requestId: string;
+    context: ComputerUseHostContext & {
+        toolCallId: string;
+    };
+    choice: ComputerUseElicitationChoice;
+}
+export declare class ComputerUseContractError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/** Validate the hosted rotation envelope before changing runtime admission. */
+export declare function assertComputerUseRotateCredentialRequest(value: unknown): asserts value is ComputerUseRotateCredentialRequest;
+export declare function assertComputerUseHostContext(value: unknown): asserts value is ComputerUseHostContext;
+export declare function computerUseBudgets(value?: unknown): ComputerUseBudgets;
+export declare function assertComputerUseInput(value: unknown): asserts value is ComputerUseInput;
+export declare function assertComputerUseRequest(value: unknown): asserts value is ComputerUseRequest;
+export declare function assertComputerUseSurface(value: unknown): asserts value is ComputerUseSurface;
+/** Validate the envelope without rewriting blocks or discarding upstream extensions. */
+export declare function assertComputerUseMcpResult(value: unknown): asserts value is ComputerUseMcpResult;
+/** Compare full execution identity; a matching conversation alone never grants access. */
+export declare function sameComputerUseContext(left: ComputerUseHostContext, right: ComputerUseHostContext): boolean;
+export declare function assertComputerUseElicitationRequest(value: unknown): asserts value is ComputerUseElicitationRequest;
+export declare function assertComputerUseElicitationResponse(value: unknown): asserts value is ComputerUseElicitationResponse;
+/** A human answer can only satisfy this exact pending request and offered scope.
+ * This matcher is not authentication: the caller must verify the human responder.
+ */
+export declare function acceptsComputerUseElicitationResponse(request: ComputerUseElicitationRequest, response: ComputerUseElicitationResponse, now?: number): boolean;
+export type ComputerUseModelProjectionOptions = {
+    audio: 'inline';
+} | {
+    audio: 'artifact-reference';
+    principalId: string;
+    sessionId: string;
+    consumer?: string;
+};
+/**
+ * Consumer capability projection, never a rewrite of the canonical daemon
+ * result. Some model hosts accept MCP AudioContent but silently omit its bytes.
+ * Those hosts receive explicit references to already-persisted owned audio.
+ * This function never uploads, transcribes, invents a path or grants access.
+ */
+export declare function projectComputerUseResultForModel(result: ComputerUseMcpResult, options: ComputerUseModelProjectionOptions): ComputerUseMcpResult;