@xopcai/xopc 0.0.391 → 0.0.393

package/dist/src/computer/diagnostics.d.ts

@@ -0,0 +1,223 @@
+import { z } from 'zod';
+import type { ComputerAction, ComputerObservation, ComputerReceipt } from '@xopcai/computer-control-contract';
+import type { ComputerVerification } from './task-state.js';
+export declare const ComputerFailurePhaseSchema: z.ZodEnum<{
+    open: "open";
+    executor: "executor";
+    model: "model";
+    observe: "observe";
+    release: "release";
+    dispatch: "dispatch";
+    frame_upload: "frame_upload";
+    oracle: "oracle";
+}>;
+export type ComputerFailurePhase = z.infer<typeof ComputerFailurePhaseSchema>;
+export declare const ComputerFailureCategorySchema: z.ZodEnum<{
+    permission: "permission";
+    target: "target";
+    cancelled: "cancelled";
+    unknown: "unknown";
+    model: "model";
+    observation: "observation";
+    transport: "transport";
+    native: "native";
+    budget: "budget";
+    no_progress: "no_progress";
+    harness: "harness";
+}>;
+export declare const ComputerFailureSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        permission: "permission";
+        target: "target";
+        cancelled: "cancelled";
+        unknown: "unknown";
+        model: "model";
+        observation: "observation";
+        transport: "transport";
+        native: "native";
+        budget: "budget";
+        no_progress: "no_progress";
+        harness: "harness";
+    }>;
+    phase: z.ZodEnum<{
+        open: "open";
+        executor: "executor";
+        model: "model";
+        observe: "observe";
+        release: "release";
+        dispatch: "dispatch";
+        frame_upload: "frame_upload";
+        oracle: "oracle";
+    }>;
+    errorCode: z.ZodString;
+    dispatch: z.ZodEnum<{
+        unknown: "unknown";
+        completed: "completed";
+        started: "started";
+        notStarted: "notStarted";
+    }>;
+    diagnosticId: z.ZodOptional<z.ZodUUID>;
+    httpStatus: z.ZodOptional<z.ZodNumber>;
+    requestId: z.ZodOptional<z.ZodString>;
+    validationReason: z.ZodOptional<z.ZodEnum<{
+        invalid_json: "invalid_json";
+        invalid_arguments: "invalid_arguments";
+        missing_call: "missing_call";
+        multiple_calls: "multiple_calls";
+        invalid_envelope: "invalid_envelope";
+        output_limit: "output_limit";
+    }>>;
+    serviceErrorCode: z.ZodOptional<z.ZodEnum<{
+        provider_error: "provider_error";
+        max_input_tokens_exceeded: "max_input_tokens_exceeded";
+        max_tokens_exceeded: "max_tokens_exceeded";
+        model_capability_unsupported: "model_capability_unsupported";
+        unsupported_request_field: "unsupported_request_field";
+        invalid_image: "invalid_image";
+        request_too_large: "request_too_large";
+        invalid_request: "invalid_request";
+        free_pool_unavailable: "free_pool_unavailable";
+    }>>;
+}, z.core.$strict>;
+export type ComputerFailure = z.infer<typeof ComputerFailureSchema>;
+/** Unknown exception prose and arbitrary code-like strings never become report data. */
+export declare function classifyComputerFailure(error: unknown, phase: ComputerFailurePhase, dispatch?: ComputerFailure['dispatch'], aborted?: boolean): ComputerFailure;
+export declare const ComputerSessionReportSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    reportId: z.ZodUUID;
+    sessionId: z.ZodOptional<z.ZodUUID>;
+    status: z.ZodEnum<{
+        active: "active";
+        released: "released";
+        release_unconfirmed: "release_unconfirmed";
+    }>;
+    startedAt: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    counters: z.ZodObject<{
+        observations: z.ZodNumber;
+        predictionAttempts: z.ZodNumber;
+        modelRequests: z.ZodNumber;
+        proposedInputs: z.ZodNumber;
+        completedInputs: z.ZodNumber;
+        unknownDispatches: z.ZodNumber;
+        unchangedInputs: z.ZodNumber;
+        observationChanges: z.ZodNumber;
+        rescueAttempts: z.ZodNumber;
+        rescueExhaustions: z.ZodNumber;
+        takeovers: z.ZodNumber;
+        successClaims: z.ZodNumber;
+        verifiedConditions: z.ZodNumber;
+    }, z.core.$strict>;
+    phaseMs: z.ZodObject<{
+        open: z.ZodNumber;
+        observe: z.ZodNumber;
+        model: z.ZodNumber;
+        dispatch: z.ZodNumber;
+        release: z.ZodNumber;
+    }, z.core.$strict>;
+    failure: z.ZodOptional<z.ZodObject<{
+        category: z.ZodEnum<{
+            permission: "permission";
+            target: "target";
+            cancelled: "cancelled";
+            unknown: "unknown";
+            model: "model";
+            observation: "observation";
+            transport: "transport";
+            native: "native";
+            budget: "budget";
+            no_progress: "no_progress";
+            harness: "harness";
+        }>;
+        phase: z.ZodEnum<{
+            open: "open";
+            executor: "executor";
+            model: "model";
+            observe: "observe";
+            release: "release";
+            dispatch: "dispatch";
+            frame_upload: "frame_upload";
+            oracle: "oracle";
+        }>;
+        errorCode: z.ZodString;
+        dispatch: z.ZodEnum<{
+            unknown: "unknown";
+            completed: "completed";
+            started: "started";
+            notStarted: "notStarted";
+        }>;
+        diagnosticId: z.ZodOptional<z.ZodUUID>;
+        httpStatus: z.ZodOptional<z.ZodNumber>;
+        requestId: z.ZodOptional<z.ZodString>;
+        validationReason: z.ZodOptional<z.ZodEnum<{
+            invalid_json: "invalid_json";
+            invalid_arguments: "invalid_arguments";
+            missing_call: "missing_call";
+            multiple_calls: "multiple_calls";
+            invalid_envelope: "invalid_envelope";
+            output_limit: "output_limit";
+        }>>;
+        serviceErrorCode: z.ZodOptional<z.ZodEnum<{
+            provider_error: "provider_error";
+            max_input_tokens_exceeded: "max_input_tokens_exceeded";
+            max_tokens_exceeded: "max_tokens_exceeded";
+            model_capability_unsupported: "model_capability_unsupported";
+            unsupported_request_field: "unsupported_request_field";
+            invalid_image: "invalid_image";
+            request_too_large: "request_too_large";
+            invalid_request: "invalid_request";
+            free_pool_unavailable: "free_pool_unavailable";
+        }>>;
+    }, z.core.$strict>>;
+    recentActions: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            wait: "wait";
+            activate: "activate";
+            showMenu: "showMenu";
+            click: "click";
+            drag: "drag";
+            setValue: "setValue";
+            typeText: "typeText";
+            pressKeys: "pressKeys";
+            scroll: "scroll";
+        }>;
+        dispatch: z.ZodEnum<{
+            unknown: "unknown";
+            completed: "completed";
+            started: "started";
+            notStarted: "notStarted";
+        }>;
+        outcome: z.ZodEnum<{
+            unknown: "unknown";
+            applied: "applied";
+            notApplied: "notApplied";
+        }>;
+        unchanged: z.ZodBoolean;
+        condition: z.ZodOptional<z.ZodEnum<{
+            unavailable: "unavailable";
+            satisfied: "satisfied";
+            not_met: "not_met";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ComputerSessionReport = z.infer<typeof ComputerSessionReportSchema>;
+/** A bounded metadata-only companion to task history; it never retains action arguments or pixels. */
+export declare class ComputerSessionDiagnostics {
+    private readonly now;
+    private readonly data;
+    private readonly receipts;
+    private pending?;
+    private endedAt?;
+    phase: ComputerFailurePhase;
+    constructor(now?: () => number);
+    bind(sessionId: string): void;
+    count(key: keyof ComputerSessionReport['counters']): void;
+    measure<T>(phase: keyof ComputerSessionReport['phaseMs'], fn: () => Promise<T>): Promise<T>;
+    propose(id: string, kind: ComputerAction['kind']): void;
+    discard(): void;
+    record(receipt: ComputerReceipt, before?: ComputerObservation, after?: ComputerObservation, verification?: ComputerVerification): void;
+    verify(verification?: ComputerVerification): void;
+    fail(error: unknown, phase?: "open" | "executor" | "model" | "observe" | "release" | "dispatch" | "frame_upload" | "oracle", dispatch?: ComputerFailure['dispatch'], aborted?: boolean): void;
+    finish(released: boolean): void;
+    snapshot(): ComputerSessionReport;
+}

package/dist/src/computer/diagnostics.js

@@ -0,0 +1,360 @@
+import { ComputerDiagnosticSchema, computerDiagnostic } from "./errors.js";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+//#region src/computer/diagnostics.ts
+const ComputerFailurePhaseSchema = z.enum([
+	"open",
+	"observe",
+	"frame_upload",
+	"model",
+	"dispatch",
+	"release",
+	"executor",
+	"oracle"
+]);
+const ComputerFailureCategorySchema = z.enum([
+	"permission",
+	"target",
+	"observation",
+	"model",
+	"transport",
+	"native",
+	"budget",
+	"no_progress",
+	"cancelled",
+	"harness",
+	"unknown"
+]);
+const ComputerFailureSchema = z.object({
+	category: ComputerFailureCategorySchema,
+	phase: ComputerFailurePhaseSchema,
+	errorCode: z.string().regex(/^COMPUTER_[A-Z_0-9]+$/).max(100),
+	dispatch: z.enum([
+		"notStarted",
+		"started",
+		"completed",
+		"unknown"
+	]),
+	diagnosticId: z.uuid().optional(),
+	httpStatus: z.number().int().min(100).max(599).optional(),
+	requestId: z.string().regex(/^(?:[a-f0-9]{32}|[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12})$/i).optional(),
+	validationReason: ComputerDiagnosticSchema.shape.validationReason,
+	serviceErrorCode: ComputerDiagnosticSchema.shape.serviceErrorCode
+}).strict();
+const categories = Object.create(null);
+for (const [category, codes] of Object.entries({
+	permission: [
+		"DISABLED",
+		"READ_ONLY",
+		"LOCAL_UI_REQUIRED",
+		"CONTROL_PAUSED",
+		"APP_NOT_AUTHORIZED",
+		"OS_PERMISSION_REQUIRED",
+		"SELF_CONTROL_DENIED",
+		"SENSITIVE_APP_MANUAL_ONLY",
+		"REVOKED",
+		"GRANT_REVOKED",
+		"KEY_SCOPE_UNSAFE"
+	],
+	target: [
+		"APP_NOT_FOUND",
+		"APP_NOT_RUNNING",
+		"APP_REF_EXPIRED",
+		"APP_INSTANCE_AMBIGUOUS",
+		"WINDOW_REQUIRED",
+		"WINDOW_AMBIGUOUS",
+		"WINDOW_CHANGED",
+		"WINDOW_ID_UNSUPPORTED",
+		"PROCESS_CHANGED",
+		"PROCESS_EXITED",
+		"ELEMENT_REF_REQUIRED",
+		"ELEMENT_TARGET_CHANGED",
+		"TARGET_CHANGED",
+		"TARGET_MISMATCH",
+		"CLOSE_BEFORE_TARGET_CHANGE",
+		"FLOW_TARGET_MISMATCH",
+		"FLOW_NOT_FOUND",
+		"DESKTOP_BINDING_REQUIRED",
+		"DESKTOP_UPGRADE_REQUIRED"
+	],
+	observation: [
+		"OBSERVATION_CHANGED",
+		"STALE_OBSERVATION",
+		"STALE_ACTION",
+		"UI_UNSTABLE",
+		"FRAME_REQUIRED",
+		"CAPTURE_REQUIRED",
+		"CAPTURE_TARGET_MISMATCH",
+		"FRAME_HANDOFF_FAILED",
+		"UNEXPECTED_FRAME",
+		"SESSION_MISMATCH",
+		"AMBIGUOUS_WINDOW_TREE",
+		"OBSERVE_FAILED"
+	],
+	model: [
+		"MODEL_REQUIRED",
+		"MODEL_KEY_MISSING",
+		"MODEL_CAPABILITY_REQUIRED",
+		"INVALID_MODEL_OUTPUT",
+		"EXPECTED_SINGLE_ACTION",
+		"READ_ONLY_MODEL_OUTPUT",
+		"MODEL_FAILED",
+		"MODEL_EMPTY_RESPONSE",
+		"MODEL_INCOMPLETE_RESPONSE",
+		"MODEL_INVALID_JSON",
+		"MODEL_PROTOCOL_MISMATCH",
+		"MODEL_REQUIRES_HTTPS_ORIGIN",
+		"UNSUPPORTED_MODEL_HEADER",
+		"DEPLOYMENT_UNAVAILABLE"
+	],
+	transport: [
+		"RECEIPT_MISMATCH",
+		"DISPATCH_FAILED",
+		"RELEASE_UNCONFIRMED",
+		"SESSION_NOT_FOUND",
+		"BUSY",
+		"DEVICE_BUSY",
+		"NOT_READY",
+		"ACTION_ID_REUSED",
+		"ACTION_PENDING",
+		"DIFFERENT_ACTION_PENDING"
+	],
+	native: [
+		"NATIVE_SETUP_FAILED",
+		"NATIVE_ACTION_FAILED",
+		"POST_ACTION_OBSERVATION_FAILED",
+		"SEMANTIC_ACTION_UNSUPPORTED",
+		"SEMANTIC_ACTION_UNCONFIRMED",
+		"EDITABLE_TARGET_REQUIRED",
+		"COORDINATE_OUTSIDE_WINDOW",
+		"KEY_NOT_SUPPORTED",
+		"SCROLL_REQUIRES_ONE_AXIS",
+		"DRAG_REQUIRES_MOVEMENT",
+		"DRIVER_HOST_IDENTITY_MISMATCH",
+		"DRIVER_INVALID_RESULT",
+		"DRIVER_OFFLINE",
+		"DRIVER_REQUIRES_ELECTRON_MAIN"
+	],
+	budget: [
+		"SESSION_BUDGET",
+		"ACTION_BUDGET",
+		"MODEL_BUDGET",
+		"FRAME_LIMIT",
+		"INPUT_LIMIT",
+		"MODEL_OUTPUT_BUDGET",
+		"MODEL_RESPONSE_LIMIT"
+	],
+	no_progress: ["NO_PROGRESS"],
+	cancelled: [
+		"OPERATION_ABORTED",
+		"AUTHORIZATION_TIMEOUT",
+		"EVALUATION_ABORTED"
+	],
+	harness: [
+		"EVALUATION_PROCESS_FAILED",
+		"EVALUATION_TIMEOUT",
+		"EVALUATION_OUTPUT_LIMIT",
+		"EVALUATION_INVALID_JSON",
+		"EVALUATION_INVALID_RESULT"
+	]
+})) for (const code of codes) categories[`COMPUTER_${code}`] = category;
+/** Unknown exception prose and arbitrary code-like strings never become report data. */
+function classifyComputerFailure(error, phase, dispatch = "notStarted", aborted = false) {
+	const diagnostic = computerDiagnostic(error);
+	let errorCode = diagnostic?.errorCode ?? (error instanceof Error ? error.message : "");
+	if (aborted && !categories[errorCode] && !diagnostic) errorCode = "COMPUTER_OPERATION_ABORTED";
+	let category = categories[errorCode];
+	if (/^COMPUTER_MODEL_HTTP_[1-5]\d\d$/.test(errorCode)) category = "model";
+	if (/^COMPUTER_FRAME_UPLOAD_(HTTP_[1-5]\d\d|INVALID_GRANT|TOO_LARGE|TIMEOUT|NETWORK|INVALID_IMAGE|BUSY|INVALID_RESPONSE)$/.test(errorCode)) category = "transport";
+	if (/^COMPUTER_DRIVER_(CLICK|SET_VALUE|TYPE_TEXT|DRAG|BRING_TO_FRONT|LAUNCH_APP)_REFUSED$/.test(errorCode) || /^COMPUTER_DRIVER_SETUP_(START|BINARY|SDK|IDENTITY|PERMISSIONS)_FAILED$/.test(errorCode)) category = "native";
+	if (!category) {
+		category = "unknown";
+		errorCode = "COMPUTER_OPERATION_FAILED";
+	}
+	return {
+		category,
+		errorCode,
+		phase: diagnostic?.phase === "frame_upload" ? "frame_upload" : phase,
+		dispatch,
+		...diagnostic ? {
+			diagnosticId: diagnostic.diagnosticId,
+			httpStatus: diagnostic.httpStatus,
+			requestId: diagnostic.requestId,
+			validationReason: diagnostic.validationReason,
+			serviceErrorCode: diagnostic.serviceErrorCode
+		} : {}
+	};
+}
+const Count = z.number().int().nonnegative();
+const CountersSchema = z.object({
+	observations: Count,
+	predictionAttempts: Count,
+	modelRequests: Count,
+	proposedInputs: Count,
+	completedInputs: Count,
+	unknownDispatches: Count,
+	unchangedInputs: Count,
+	observationChanges: Count,
+	rescueAttempts: Count,
+	rescueExhaustions: Count,
+	takeovers: Count,
+	successClaims: Count,
+	verifiedConditions: Count
+}).strict();
+const ComputerSessionReportSchema = z.object({
+	version: z.literal(1),
+	reportId: z.uuid(),
+	sessionId: z.uuid().optional(),
+	status: z.enum([
+		"active",
+		"released",
+		"release_unconfirmed"
+	]),
+	startedAt: Count,
+	durationMs: z.number().finite().nonnegative(),
+	counters: CountersSchema,
+	phaseMs: z.object({
+		open: Count,
+		observe: Count,
+		model: Count,
+		dispatch: Count,
+		release: Count
+	}).strict(),
+	failure: ComputerFailureSchema.optional(),
+	recentActions: z.array(z.object({
+		kind: z.enum([
+			"activate",
+			"showMenu",
+			"click",
+			"drag",
+			"setValue",
+			"typeText",
+			"pressKeys",
+			"scroll",
+			"wait"
+		]),
+		dispatch: z.enum([
+			"notStarted",
+			"started",
+			"completed",
+			"unknown"
+		]),
+		outcome: z.enum([
+			"applied",
+			"notApplied",
+			"unknown"
+		]),
+		unchanged: z.boolean(),
+		condition: z.enum([
+			"satisfied",
+			"not_met",
+			"unavailable"
+		]).optional()
+	}).strict()).max(12)
+}).strict();
+/** A bounded metadata-only companion to task history; it never retains action arguments or pixels. */
+var ComputerSessionDiagnostics = class {
+	data;
+	receipts = /* @__PURE__ */ new Set();
+	pending;
+	endedAt;
+	phase = "open";
+	constructor(now = Date.now) {
+		this.now = now;
+		this.data = {
+			version: 1,
+			reportId: randomUUID(),
+			status: "active",
+			startedAt: now(),
+			durationMs: 0,
+			counters: {
+				observations: 0,
+				predictionAttempts: 0,
+				modelRequests: 0,
+				proposedInputs: 0,
+				completedInputs: 0,
+				unknownDispatches: 0,
+				unchangedInputs: 0,
+				observationChanges: 0,
+				rescueAttempts: 0,
+				rescueExhaustions: 0,
+				takeovers: 0,
+				successClaims: 0,
+				verifiedConditions: 0
+			},
+			phaseMs: {
+				open: 0,
+				observe: 0,
+				model: 0,
+				dispatch: 0,
+				release: 0
+			},
+			recentActions: []
+		};
+	}
+	bind(sessionId) {
+		this.data.sessionId = sessionId;
+	}
+	count(key) {
+		this.data.counters[key]++;
+	}
+	async measure(phase, fn) {
+		this.phase = phase;
+		const start = this.now();
+		try {
+			return await fn();
+		} finally {
+			this.data.phaseMs[phase] += Math.max(0, Math.round(this.now() - start));
+		}
+	}
+	propose(id, kind) {
+		this.pending = {
+			id,
+			kind
+		};
+		if (kind !== "wait") this.count("proposedInputs");
+	}
+	discard() {
+		this.pending = void 0;
+		this.count("observationChanges");
+	}
+	record(receipt, before, after, verification) {
+		if (!this.pending || this.pending.id !== receipt.actionId || this.receipts.has(receipt.actionId)) return;
+		this.receipts.add(receipt.actionId);
+		const kind = this.pending.kind;
+		const unchanged = kind !== "wait" && receipt.dispatch === "completed" && !!after && before?.stateDigest === after.stateDigest;
+		if (kind !== "wait" && receipt.dispatch === "completed") this.count("completedInputs");
+		if (receipt.dispatch === "unknown" || receipt.dispatch === "started") this.count("unknownDispatches");
+		if (unchanged) this.count("unchangedInputs");
+		this.verify(verification);
+		this.data.recentActions.push({
+			kind,
+			dispatch: receipt.dispatch,
+			outcome: receipt.outcome,
+			unchanged,
+			...verification ? { condition: verification.status } : {}
+		});
+		if (this.data.recentActions.length > 12) this.data.recentActions.shift();
+		this.pending = void 0;
+	}
+	verify(verification) {
+		if (verification?.status === "satisfied" && !verification.preexisting) this.count("verifiedConditions");
+	}
+	fail(error, phase = this.phase, dispatch, aborted = false) {
+		if (this.data.failure) return;
+		if (this.pending && dispatch === void 0) this.count("unknownDispatches");
+		this.data.failure = classifyComputerFailure(error, phase, dispatch ?? (this.pending ? "unknown" : "notStarted"), aborted);
+	}
+	finish(released) {
+		this.data.status = released ? "released" : "release_unconfirmed";
+		if (released) this.endedAt ??= this.now();
+	}
+	snapshot() {
+		return ComputerSessionReportSchema.parse({
+			...this.data,
+			durationMs: Math.max(0, (this.endedAt ?? this.now()) - this.data.startedAt)
+		});
+	}
+};
+//#endregion
+export { ComputerFailureCategorySchema, ComputerFailurePhaseSchema, ComputerFailureSchema, ComputerSessionDiagnostics, ComputerSessionReportSchema, classifyComputerFailure };

package/dist/src/computer/errors.d.ts

@@ -3,8 +3,8 @@ import { z } from 'zod';
 export declare const ComputerDiagnosticSchema: z.ZodObject<{
     errorCode: z.ZodString;
     phase: z.ZodEnum<{
-        observe: "observe";
         model: "model";
+        observe: "observe";
         dispatch: "dispatch";
         frame_upload: "frame_upload";
     }>;

package/dist/src/computer/errors.js

@@ -54,8 +54,15 @@ var ComputerTargetError = class extends Error {
 };
 /** Recovery instructions are deterministic; never replay an input with unknown delivery. */
 function computerRecovery(code) {
+	if (code === "COMPUTER_RECEIPT_MISMATCH") return "The receipt could not be matched to the dispatched action, so its outcome is uncertain. Inspect the application locally; never automatically retry or replay the input. Wait for confirmed release before switching tools.";
+	if (code === "COMPUTER_FLOW_NOT_FOUND" || code === "COMPUTER_FLOW_TARGET_MISMATCH") return "The saved flow is unavailable or belongs to another application/device. Do not replay it or switch targets automatically. List flows and inspect the authorized target before planning again.";
+	if (code === "COMPUTER_FLOW_NOT_VERIFIED" || code === "COMPUTER_FLOW_SAVE_FAILED") return "Control was released. No reusable flow was confirmed saved. Saving requires verified native navigation, non-sensitive labels and working local storage; never repeat desktop input merely to save a flow.";
 	if (code.startsWith("COMPUTER_FRAME_UPLOAD_")) return "Screenshot upload to the Gateway failed. No automatic retry. Report the diagnosticId and HTTP status; do not change model providers or bypass desktop controls.";
 	switch (code) {
+		case "COMPUTER_ELEMENT_REF_REQUIRED":
+		case "COMPUTER_ELEMENT_TARGET_CHANGED":
+		case "COMPUTER_SEMANTIC_ACTION_UNSUPPORTED": return "The native element reference or action is unavailable for this window. No automatic coordinate fallback. Reopen and observe fresh evidence before choosing a different action; never reuse an old reference or replay an uncertain input.";
+		case "COMPUTER_SEMANTIC_ACTION_UNCONFIRMED": return "The native action returned uncertain execution evidence. Inspect the application before continuing. Do not repeat it or fall back to coordinates; its effect may already have occurred.";
 		case "COMPUTER_INVALID_MODEL_OUTPUT":
 		case "COMPUTER_EXPECTED_SINGLE_ACTION": return "The GUI model returned an invalid action after bounded format correction. No input from this prediction was dispatched. Report validationReason and diagnosticId; do not guess coordinates, replay the action or change providers.";
 		case "COMPUTER_MODEL_HTTP_400": return "The configured model service rejected the request. No input was dispatched from this model request. Report serviceErrorCode, requestId and diagnosticId; check the model request format and input/output limits before reopening. Do not automatically retry or change providers.";
@@ -63,7 +70,7 @@ function computerRecovery(code) {
 		case "COMPUTER_MODEL_HTTP_429": return "The configured model service is rate-limited. No input was dispatched from this model request. Check the service quota and retry only after it resets; do not automatically change providers.";
 		case "COMPUTER_MODEL_HTTP_409": return "The pinned model deployment changed. No input was dispatched from this model request. Refresh the model catalog and reopen after reviewing the configured screenshot recipient.";
 		case "COMPUTER_OBSERVATION_CHANGED": return "No input was dispatched. Observe the changed window and re-plan with fresh evidence; the old proposed action was discarded.";
-		case "COMPUTER_UI_UNSTABLE": return "No input was dispatched by the unstable attempts. The window changed repeatedly during prediction. Wait for a local state change, then discover/open again; never replay old coordinates.";
+		case "COMPUTER_UI_UNSTABLE": return "No input was dispatched by the unstable attempts. The window changed during prediction and the session rescue allowance is unavailable or exhausted. Wait for a local state change, then discover/open again; never replay old coordinates.";
 		case "COMPUTER_NO_PROGRESS": return "Repeated inputs produced no observed progress. Inspect the actual outcome and change the plan; do not keep clicking or repeat a potentially submitted action.";
 		case "COMPUTER_INVALID_INPUT": return "Read tool_manual(computer_use) and use only the fields documented for this operation. Start with discover; open requires appRef, mode and prepare.";
 		case "COMPUTER_APP_INSTANCE_AMBIGUOUS": return "Multiple processes for this app are running. Ask the user to keep the intended app instance open; do not guess a process.";