@skrr-ai/cli 0.1.119 → 0.1.120

package/dist/lib/task-operation-watch.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Read-only waiting for a server-authoritative Task Operation.
+ *
+ * A Task status is intentionally not used as a completion signal here. One
+ * Task can have several sequential or competing operations, so only the
+ * operation's immutable id and server projection may settle this wait.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTaskOperationWatchDuration = parseTaskOperationWatchDuration;
+exports.classifyTaskOperation = classifyTaskOperation;
+exports.watchTaskOperation = watchTaskOperation;
+exports.taskOperationCheckpointLine = taskOperationCheckpointLine;
+// These are operation outcomes, not Task-execution outcomes. A start can be
+// successfully accepted and a retry successfully admitted while its execution
+// Run is still active; waiting on the Operation must stop successfully at that
+// durable boundary rather than misreporting it as an unknown terminal state.
+const SUCCESS_STATES = new Set(['succeeded', 'completed', 'accepted', 'admitted']);
+const FAILED_STATES = new Set(['failed', 'cancelled', 'canceled', 'abandoned', 'rejected', 'refused']);
+/** Parse the same bounded duration grammar used by `tasks watch`. */
+function parseTaskOperationWatchDuration(value) {
+    if (!value)
+        return null;
+    const match = value.trim().match(/^(\d+)(ms|s|m|h)?$/i);
+    if (!match)
+        throw new Error(`Invalid --timeout value: ${value}`);
+    const amount = Number(match[1]);
+    if (!Number.isSafeInteger(amount) || amount < 0) {
+        throw new Error(`Invalid --timeout value: ${value}`);
+    }
+    const unit = (match[2] || 's').toLowerCase();
+    if (unit === 'ms')
+        return amount;
+    if (unit === 's')
+        return amount * 1000;
+    if (unit === 'm')
+        return amount * 60 * 1000;
+    if (unit === 'h')
+        return amount * 60 * 60 * 1000;
+    throw new Error(`Invalid --timeout value: ${value}`);
+}
+/**
+ * Classify only server-declared terminal status or the narrow, stable terminal
+ * vocabulary. An absent/malformed/unknown projection never becomes success by
+ * inference, and neither does a Task's own workflow status.
+ */
+function classifyTaskOperation(operation) {
+    if (!operation || typeof operation !== 'object') {
+        return { terminal: false, result: 'unknown' };
+    }
+    const state = typeof operation.state === 'string' ? operation.state.trim().toLowerCase() : '';
+    const outcome = typeof operation.outcome === 'string' ? operation.outcome.trim().toLowerCase() : '';
+    if (SUCCESS_STATES.has(state) || SUCCESS_STATES.has(outcome)) {
+        return { terminal: true, result: 'succeeded' };
+    }
+    if (FAILED_STATES.has(state) || FAILED_STATES.has(outcome)) {
+        return { terminal: true, result: 'failed' };
+    }
+    if (operation.terminal === true) {
+        // A terminal projection without a known outcome is intentionally not
+        // recast as success. The caller sees `unknown` and must inspect its
+        // immutable recovery/receipt fields instead of issuing a new mutation.
+        return { terminal: true, result: 'unknown' };
+    }
+    return { terminal: false, result: state === 'unknown' ? 'unknown' : 'pending' };
+}
+function operationSignature(operation) {
+    if (!operation)
+        return 'null';
+    return JSON.stringify({
+        state: operation.state,
+        phase: operation.phase,
+        terminal: operation.terminal,
+        outcome: operation.outcome,
+        updatedAt: operation.updatedAt,
+        recovery: operation.recovery,
+    });
+}
+function defaultSleep(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+/**
+ * Poll one immutable operation until it reaches an authoritative terminal
+ * result. Every read is emitted as a checkpoint so JSON consumers can prove
+ * liveness even where a server does not yet offer an event stream.
+ */
+async function watchTaskOperation(options) {
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? defaultSleep;
+    const startedAt = now();
+    let lastSignature = null;
+    while (true) {
+        const operation = await options.read(options.taskId, options.operationId);
+        const classification = classifyTaskOperation(operation);
+        const signature = operationSignature(operation);
+        const changed = signature !== lastSignature;
+        lastSignature = signature;
+        await options.onCheckpoint({
+            object: 'task_operation_watch_checkpoint',
+            schemaVersion: 1,
+            observedAt: new Date(now()).toISOString(),
+            taskId: options.taskId,
+            operationId: options.operationId,
+            observation: 'observed',
+            changed,
+            terminal: classification.terminal,
+            result: classification.result,
+            operation,
+        });
+        if (classification.terminal) {
+            if (classification.result === 'succeeded' || classification.result === 'failed') {
+                return { terminal: true, result: classification.result, operation };
+            }
+            // A terminal-but-unclassified operation is a server truth that requires
+            // an explicit user inspection, not an accidental green result.
+            const error = Object.assign(new Error('Task operation reached an unknown terminal state.'), {
+                code: 'TASK_OPERATION_TERMINAL_UNKNOWN',
+                operation,
+            });
+            throw error;
+        }
+        if (options.timeoutMs !== null && now() - startedAt >= options.timeoutMs) {
+            await options.onCheckpoint({
+                object: 'task_operation_watch_checkpoint',
+                schemaVersion: 1,
+                observedAt: new Date(now()).toISOString(),
+                taskId: options.taskId,
+                operationId: options.operationId,
+                observation: 'timeout',
+                changed: false,
+                terminal: false,
+                result: classification.result,
+                operation,
+            });
+            const error = Object.assign(new Error(`Timed out waiting for task operation ${options.operationId}.`), {
+                code: 'TASK_OPERATION_WAIT_TIMEOUT',
+                exitCode: 124,
+                operation,
+            });
+            throw error;
+        }
+        await sleep(options.intervalMs);
+    }
+}
+function taskOperationCheckpointLine(checkpoint) {
+    if (checkpoint.observation === 'timeout') {
+        return `[${checkpoint.observedAt}] operation ${checkpoint.operationId}: timeout; last state ${operationLabel(checkpoint.operation)}`;
+    }
+    const suffix = checkpoint.changed ? '' : ' (unchanged)';
+    return `[${checkpoint.observedAt}] operation ${checkpoint.operationId}: ${operationLabel(checkpoint.operation)}${suffix}`;
+}
+function operationLabel(operation) {
+    if (!operation)
+        return 'unknown';
+    const state = typeof operation.state === 'string' && operation.state ? operation.state : 'unknown';
+    const phase = typeof operation.phase === 'string' && operation.phase ? ` / ${operation.phase}` : '';
+    const intent = typeof operation.intent === 'string' && operation.intent ? ` (${operation.intent})` : '';
+    return `${state}${phase}${intent}`;
+}

package/dist/lib/task-resolver.d.ts

@@ -26,7 +26,7 @@ export declare function resolveTaskIdentity({ positionalId, flagTask, jsonBody,
  * The same resolution `resolveTaskIdentity` performs, without the throw.
  * Read-only surfaces that REPORT task context (`skrr context`) need the
  * identical answer an id-less task command would act on — runtime binding
- * first, then the `oversky/task/<REF>` git branch — but "no task anywhere"
+ * first, then the canonical task git branch — but "no task anywhere"
  * is a fact to print, not an error to fail on.
  */
 export declare function tryResolveTaskIdentity(options?: Parameters<typeof resolveTaskIdentity>[0]): TaskIdentity | null;

package/dist/lib/task-resolver.js

@@ -65,8 +65,9 @@ function resolveTaskIdentity({ positionalId, flagTask, jsonBody, jsonKeys = ['ta
             identifierFallback: true,
         };
     }
-    // Human-side task work has no daemon runtime context. A canonical
-    // `oversky/task/OSK-123` branch is therefore the final, local-only default.
+    // Human-side task work has no daemon runtime context. A branch in the
+    // canonical task namespace (TASK_BRANCH_PREFIX) is therefore the final,
+    // local-only default.
     // Keep it after all trusted session coordinates: a daemon-bound task must
     // not silently become whichever branch happens to be checked out.
     const branchTaskRef = gitTaskReference()?.trim();
@@ -90,7 +91,7 @@ function resolveTaskIdentity({ positionalId, flagTask, jsonBody, jsonKeys = ['ta
  * The same resolution `resolveTaskIdentity` performs, without the throw.
  * Read-only surfaces that REPORT task context (`skrr context`) need the
  * identical answer an id-less task command would act on — runtime binding
- * first, then the `oversky/task/<REF>` git branch — but "no task anywhere"
+ * first, then the canonical task git branch — but "no task anywhere"
  * is a fact to print, not an error to fail on.
  */
 function tryResolveTaskIdentity(options = {}) {

package/dist/lib/task-work.d.ts

@@ -1,4 +1,4 @@
-import type { TaskExecutionSnapshot, TaskConversationInputBody, TaskConversationInputReceipt, TaskInputPurpose } from '@skrr-ai/data-provider';
+import type { TaskConversationInputBody, TaskConversationInputReceipt, TaskExecutionSnapshot, TaskInputPurpose } from '@skrr-ai/data-provider';
 /** Observation time is not evidence that a worker just sent a heartbeat. */
 export declare function describeExecutionState(state: TaskExecutionSnapshot): string[];
 export declare function buildTaskContinuationBody(input: {

package/dist/lib/task-work.js

@@ -6,10 +6,44 @@ exports.describeTaskContinuation = describeTaskContinuation;
 const node_crypto_1 = require("node:crypto");
 /** Observation time is not evidence that a worker just sent a heartbeat. */
 function describeExecutionState(state) {
+    const execution = state.execution;
+    const attempt = execution.attemptKey
+        ? `Attempt: ${execution.attemptKey}`
+        : 'Attempt: not claimed by an executor';
+    const terminal = execution.executorTerminal
+        ? `Executor terminal: observed for this attempt; canonical Run is ${execution.runStatus ?? 'not observed'}`
+        : null;
+    const finalization = execution.finalizationPending
+        ? 'Finalization: pending; the canonical terminal is recorded but Task workflow projection is still reconciling'
+        : null;
+    const coverage = execution.workCoverage
+        ? `Work coverage: ${execution.workCoverage.applicability}${execution.workCoverage.reason ? `; ${execution.workCoverage.reason}` : ''}`
+        : null;
+    const failure = execution.failure
+        ? `Execution failure: ${[execution.failure.code, execution.failure.class]
+            .filter(Boolean)
+            .join(' · ')}${execution.failure.message
+            ? `${execution.failure.code || execution.failure.class ? '; ' : ''}${execution.failure.message}`
+            : ''}`
+        : null;
+    const resources = state.resources
+        ? [
+            `Execution resources: ${state.resources.state}; ${state.resources.reason}`,
+            ...state.resources.items.map((resource) => `Resource: ${resource.kind} ${resource.state}; ${resource.reason}${resource.attempt
+                ? `; attempt ${resource.attempt.kind}:${resource.attempt.runId}:${resource.attempt.attempt}:${resource.attempt.generation}`
+                : ''}; evidence ${resource.evidence?.source ?? 'unavailable'}${resource.evidence?.observedAt ? ` ${resource.evidence.observedAt}` : ''}${resource.requestedAt ? `; requested ${resource.requestedAt}` : ''}${resource.transportRequestedAt ? `; transport requested ${resource.transportRequestedAt}` : ''}${resource.acknowledgedAt ? `; acknowledged ${resource.acknowledgedAt}` : ''}${resource.releasedAt ? `; released ${resource.releasedAt}` : ''}${resource.unknownAt ? `; release unverifiable ${resource.unknownAt}` : ''}${resource.recoveryAttempts !== undefined ? `; recovery attempts ${resource.recoveryAttempts}` : ''}`),
+        ]
+        : ['Execution resources: unavailable; this server did not return a resource projection'];
     return [
         `Task: ${state.taskId}`,
         `Workflow: ${state.workflowStatus} (generation ${state.workflowGeneration})`,
-        `Execution: ${state.execution.runStatus ?? 'not observed'}${state.execution.runId ? `; Run ${state.execution.runId}` : ''}`,
+        `Execution: ${execution.runStatus ?? 'not observed'}${execution.runId ? `; Run ${execution.runId}` : ''}`,
+        attempt,
+        ...(terminal ? [terminal] : []),
+        ...(finalization ? [finalization] : []),
+        ...(coverage ? [coverage] : []),
+        ...(failure ? [failure] : []),
+        ...resources,
         `Liveness: ${state.liveness.state}; last runtime signal ${state.liveness.lastRuntimeSignalAt ?? 'unavailable'}`,
         `Health: ${state.health.condition}; ${state.health.reason}`,
         ...(state.waiting ? [`Waiting: ${state.waiting.kind}; ${state.waiting.referenceId}`] : []),

package/dist/lib/task-write-attribution.d.ts

@@ -1,4 +1,18 @@
 import { readRuntimeContext } from './runtime-context';
+export type UnboundRuntimeSetupStep = {
+    kind: 'inspect_local_harnesses' | 'inspect_local_code_agent' | 'start_assigned_task';
+    command: string;
+    description: string;
+};
+/**
+ * An unbound shell is normal for a person starting the CLI by hand. The useful
+ * answer is not an invitation to forge an environment variable; it is the
+ * smallest truthful route to learn which local engines are registered, choose
+ * a local Code identity, or enter an assigned task's authenticated runtime.
+ */
+export declare function unboundRuntimeSetup(bin?: string): UnboundRuntimeSetupStep[];
+export declare function agentBindingGuidance(bin?: string): string;
+/** Compatibility for receipts and surfaces that do not know the invoked bin name. */
 export declare const AGENT_BINDING_GUIDANCE: string;
 export declare const ACCOUNT_ATTRIBUTION_NOTICE: string;
 type Principal = {

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

@@ -1,11 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ACCOUNT_ATTRIBUTION_NOTICE = exports.AGENT_BINDING_GUIDANCE = void 0;
+exports.unboundRuntimeSetup = unboundRuntimeSetup;
+exports.agentBindingGuidance = agentBindingGuidance;
 exports.taskWriteAttribution = taskWriteAttribution;
 exports.attributionLines = attributionLines;
 exports.runtimeWriteAttribution = runtimeWriteAttribution;
-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.';
+/**
+ * An unbound shell is normal for a person starting the CLI by hand. The useful
+ * answer is not an invitation to forge an environment variable; it is the
+ * smallest truthful route to learn which local engines are registered, choose
+ * a local Code identity, or enter an assigned task's authenticated runtime.
+ */
+function unboundRuntimeSetup(bin = 'skrr') {
+    return [
+        {
+            kind: 'inspect_local_harnesses',
+            command: `${bin} harnesses list --all`,
+            description: 'List the local provider harnesses this account has registered, including offline rows.',
+        },
+        {
+            kind: 'inspect_local_code_agent',
+            command: `${bin} code skrr-agent`,
+            description: 'Show which Agent a locally started managed skrr Code session would use; it does not start work.',
+        },
+        {
+            kind: 'start_assigned_task',
+            command: `${bin} tasks start <task>`,
+            description: 'For an assigned Task, enter its authenticated Agent runtime and execute that Task.',
+        },
+    ];
+}
+function agentBindingGuidance(bin = 'skrr') {
+    const [harnesses, codeAgent, task] = unboundRuntimeSetup(bin);
+    return (`This shell is not an authenticated Agent runtime. Inspect registered local engines with \`${harnesses.command}\`; ` +
+        `inspect the local managed Code identity with \`${codeAgent.command}\`; and for an assigned Task, start it with \`${task.command}\`. ` +
+        'An --agent flag or an environment Agent id cannot establish authenticated authorship.');
+}
+/** Compatibility for receipts and surfaces that do not know the invoked bin name. */
+exports.AGENT_BINDING_GUIDANCE = agentBindingGuidance();
 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.';
 /** Use the persisted server receipt, never the process's claimed Agent identity. */

package/dist/lib/triggers.d.ts

@@ -126,6 +126,17 @@ export interface TriggerDefinition {
      * to disagree with the route that does the refusing.
      */
     producerOwned?: boolean;
+    /**
+     * The Space loop this trigger was converted into (`skrr spaces loops
+     * migrate`, OSK-18009/OSK-18011). `pending`: read-only and still firing until
+     * the loop is active; `retired`: replaced by the loop, read-only, does not run.
+     */
+    supersededBy?: {
+        commitmentId?: string;
+        state?: string;
+        recordedAt?: string;
+        retiredAt?: string;
+    };
     createdAt?: string;
     updatedAt?: string;
 }

package/dist/lib/triggers.js

@@ -1294,6 +1294,13 @@ function renderTriggerSummary(trigger, log, options = {}) {
     if (trigger.producerOwned === true) {
         log('Managed:  by the platform — not editable here; change the object that owns it');
     }
+    // A trigger converted into a Space loop is read-only, and says where its turn went.
+    const loop = trigger.supersededBy;
+    if (loop?.commitmentId) {
+        log(loop.state === 'retired'
+            ? `Loop:     replaced by Space loop ${loop.commitmentId}; read-only and does not run (skrr commitments show ${loop.commitmentId})`
+            : `Loop:     being converted into Space loop ${loop.commitmentId}; read-only, and keeps firing until the loop is active`);
+    }
     if (trigger.label)
         log(`Label:    ${trigger.label}`);
     if (trigger.execution?.mode)

package/dist/lib/wiki-update.d.ts

@@ -4,6 +4,7 @@ export type WikiPageUpdateInput = {
     icon?: string;
     clearIcon?: boolean;
     order?: number;
+    kind?: string;
 };
 export type WikiPageUpdateResult = {
     ok: true;

package/dist/lib/wiki-update.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildWikiPageUpdate = buildWikiPageUpdate;
+const data_provider_1 = require("@skrr-ai/data-provider");
 /**
  * Build the PATCH body for `skrr wiki update`.
  *
@@ -39,10 +40,18 @@ function buildWikiPageUpdate(input) {
         }
         data.order = input.order;
     }
+    // oclif already limits the flag to these values; this is the same check for
+    // a caller of the builder that is not the flag parser.
+    if (input.kind !== undefined) {
+        if (!(0, data_provider_1.isWikiPageKind)(input.kind)) {
+            return { ok: false, error: `--kind must be one of: ${data_provider_1.WIKI_PAGE_KINDS.join(', ')}.` };
+        }
+        data.kind = input.kind;
+    }
     if (Object.keys(data).length === 0) {
         return {
             ok: false,
-            error: 'Nothing to update. Pass --title, --icon, --clear-icon, or --order.',
+            error: 'Nothing to update. Pass --title, --icon, --clear-icon, --order, or --kind.',
         };
     }
     return { ok: true, data };

package/dist/lib/wiki.js

@@ -68,7 +68,10 @@ function decorate(node) {
     // name has drifted from its slug is worth seeing.
     const slug = node.slug || node.name;
     const title = node.name && node.name !== slug ? `  [${node.name}]` : '';
-    return `${slug}${title}`;
+    // An ordinary page says nothing; any other kind is named, so the charter and
+    // journal entries can be told apart from docs at a glance (OSK-17985).
+    const kind = node.kind && node.kind !== 'doc' ? `  (${node.kind})` : '';
+    return `${slug}${title}${kind}`;
 }
 function sortNodes(nodes) {
     return [...nodes].sort((a, b) => {

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

@@ -185,6 +185,14 @@ export type DaemonComputerEventKey = keyof typeof DAEMON_COMPUTER_EVENTS;
 export type DaemonComputerEventName = (typeof DAEMON_COMPUTER_EVENTS)[DaemonComputerEventKey];
 export declare const COMPUTER_EVENT_NAMES: readonly ComputerEventName[];
 export declare const DAEMON_COMPUTER_EVENT_NAMES: readonly DaemonComputerEventName[];
+/**
+ * API → daemon: an authorized person observes, configures, stops or recovers
+ * the machine's Computer Use provider. Answered with `daemon:computer:ack`. It
+ * is deliberately outside `DAEMON_COMPUTER_EVENTS`, which lists the events the
+ * attachment protocol itself speaks, so the registry parity over that table
+ * does not move.
+ */
+export declare const DAEMON_COMPUTER_USE_CONTROL_EVENT: "daemon:computer:use-control";
 /** The daemon → API events; every other `daemon:computer:*` event flows API → daemon. */
 export declare const DAEMON_COMPUTER_REPORT_EVENT_KEYS: readonly ["ack", "manifest", "data", "activity", "detached", "filesChanged", "diagnostics"];
 /** The API → client events; every other `computer:*` event flows client → API. */
@@ -362,7 +370,7 @@ export declare const COMPUTER_CAPABILITY_VALUES: [ComputerCapability, ...Compute
  * Every refusal and limit the computer protocol can answer with. Callers branch
  * on the code; a message beside it is free text and may change.
  */
-export declare const COMPUTER_REFUSAL_CODES: readonly ["human_control", "stale_epoch", "stale_generation", "file_changed", "capability_missing", "unauthorized", "control_denied", "not_holder", "attachment_limit", "observer_limit", "watch_limit", "grant_limit", "browser_limit", "rate_limited", "not_found", "surface_ended", "machine_unavailable", "daemon_unreachable", "relay_error", "timeout", "invalid_request", "consent_missing", "path_withheld", "too_large", "service_limit"];
+export declare const COMPUTER_REFUSAL_CODES: readonly ["human_control", "stale_epoch", "stale_generation", "file_changed", "capability_missing", "unauthorized", "control_denied", "not_holder", "attachment_limit", "observer_limit", "watch_limit", "grant_limit", "browser_limit", "rate_limited", "not_found", "surface_ended", "machine_unavailable", "daemon_unreachable", "relay_error", "timeout", "invalid_request", "consent_missing", "path_withheld", "too_large", "service_limit", "maintenance_hold"];
 export type ComputerRefusalCode = (typeof COMPUTER_REFUSAL_CODES)[number];
 /**
  * The code when it is a computer refusal, else `null`. There is one spelling

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

@@ -131,6 +131,7 @@ __export(computerWire_exports, {
   DAEMON_COMPUTER_EVENTS: () => DAEMON_COMPUTER_EVENTS,
   DAEMON_COMPUTER_EVENT_NAMES: () => DAEMON_COMPUTER_EVENT_NAMES,
   DAEMON_COMPUTER_REPORT_EVENT_KEYS: () => DAEMON_COMPUTER_REPORT_EVENT_KEYS,
+  DAEMON_COMPUTER_USE_CONTROL_EVENT: () => DAEMON_COMPUTER_USE_CONTROL_EVENT,
   browserActivityOriginAllowed: () => browserActivityOriginAllowed,
   clampComputerBrowserViewport: () => clampComputerBrowserViewport,
   computerAccessOperations: () => computerAccessOperations,
@@ -301,6 +302,7 @@ const DAEMON_COMPUTER_EVENTS = {
 };
 const COMPUTER_EVENT_NAMES = Object.values(COMPUTER_EVENTS);
 const DAEMON_COMPUTER_EVENT_NAMES = Object.values(DAEMON_COMPUTER_EVENTS);
+const DAEMON_COMPUTER_USE_CONTROL_EVENT = "daemon:computer:use-control";
 const DAEMON_COMPUTER_REPORT_EVENT_KEYS = [
   "ack",
   "manifest",
@@ -516,7 +518,15 @@ const COMPUTER_REFUSAL_CODES = [
   /** The file is over the size the editor or the read accepts. */
   "too_large",
   /** The machine has as many declared services as it allows (`COMPUTER_DECLARED_SERVICES_MAX`). */
-  "service_limit"
+  "service_limit",
+  /**
+   * The machine's owner paused NEW work on it (OSK-19107). Refuses an `open` only:
+   * watching, reading files and controlling a surface that already exists keep
+   * working, and nothing running is touched. The refusal carries the hold's facts
+   * (`maintenance`), and it is not `machine_unavailable`, which says the machine is
+   * down: a paused machine is up.
+   */
+  "maintenance_hold"
 ];
 function normalizeComputerRefusalCode(code) {
   if (typeof code !== "string") {
@@ -1020,21 +1030,26 @@ function normalizeBrowserActivityOriginPolicy(input) {
   const origins = (items, required) => {
     if (!Array.isArray(items) || items.length > 20 || required && !items.length)
       throw new Error("Choose from one to twenty allowed origins and up to twenty excluded origins");
-    return [...new Set(items.map((item) => {
-      if (typeof item !== "string" || item.length > 500)
-        throw new Error("Use an exact http or https origin without a path, credentials, query or fragment");
-      let url;
-      try {
-        url = new URL(item);
-      } catch {
-        throw new Error("Use an exact http or https origin");
-      }
-      if (!["http:", "https:"].includes(url.protocol) || url.hostname.includes("*") || url.username || url.password || item !== url.origin)
-        throw new Error("Use an exact http or https origin without a path, credentials, query or fragment");
-      return url.origin;
-    }))].sort();
+    return [
+      ...new Set(items.map((item) => {
+        if (typeof item !== "string" || item.length > 500)
+          throw new Error("Use an exact http or https origin without a path, credentials, query or fragment");
+        let url;
+        try {
+          url = new URL(item);
+        } catch {
+          throw new Error("Use an exact http or https origin");
+        }
+        if (!["http:", "https:"].includes(url.protocol) || url.hostname.includes("*") || url.username || url.password || item !== url.origin)
+          throw new Error("Use an exact http or https origin without a path, credentials, query or fragment");
+        return url.origin;
+      }))
+    ].sort();
+  };
+  return {
+    allowOrigins: origins(value.allowOrigins, true),
+    excludeOrigins: origins(value.excludeOrigins, false)
   };
-  return { allowOrigins: origins(value.allowOrigins, true), excludeOrigins: origins(value.excludeOrigins, false) };
 }
 function browserActivityOriginAllowed(policy, url) {
   if (typeof url !== "string")
@@ -1161,6 +1176,7 @@ function browserActivityOriginAllowed(policy, url) {
   DAEMON_COMPUTER_EVENTS,
   DAEMON_COMPUTER_EVENT_NAMES,
   DAEMON_COMPUTER_REPORT_EVENT_KEYS,
+  DAEMON_COMPUTER_USE_CONTROL_EVENT,
   browserActivityOriginAllowed,
   clampComputerBrowserViewport,
   computerAccessOperations,

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

@@ -51,6 +51,7 @@ function categoryForDaemonTool(toolName) {
     case "filelist":
     case "filestat":
     case "filereadtagged":
+    case "personaldata":
       return "read";
     case "write":
     case "edit":

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

@@ -239,18 +239,18 @@ const TOOLS = [
     capability: TOOL_RESPONSE_OUTBOX
   }),
   toDaemon("daemon:tool:cancel", "Abandon a running tool call."),
-  toDaemon("daemon:computer:use-control", "An authorized person observes, configures, stops or recovers the machine Computer Use provider.", {
+  toDaemon(import_computerWire.DAEMON_COMPUTER_USE_CONTROL_EVENT, "An authorized person observes, configures, stops or recovers the machine Computer Use provider.", {
     stability: "experimental",
     capability: "computer_use_mcp_v1",
     delivery: "acked",
-    answeredBy: "daemon:computer:ack",
+    answeredBy: import_computerWire.DAEMON_COMPUTER_EVENTS.ack,
     payload: { kind: "zod", schema: "daemonComputerUseControlSchema" }
   }),
   toDaemon("daemon:computer-use:rotate-credential", "The approved hosted-desktop owner requests credential rotation for this exact active machine lease generation.", {
     stability: "experimental",
     capability: "computer_use_mcp_v1",
     delivery: "acked",
-    answeredBy: "daemon:computer:ack",
+    answeredBy: import_computerWire.DAEMON_COMPUTER_EVENTS.ack,
     payload: { kind: "zod", schema: "daemonComputerUseRotateCredentialSchema" }
   }),
   toDaemon("daemon:computer-use:revoke", "Revoke cloud Computer Use bindings after owner machine authority was removed.", {
@@ -262,15 +262,21 @@ const TOOLS = [
     stability: "experimental",
     capability: import_desktopWire.COMPUTER_DESKTOP_CAPABILITY,
     delivery: "acked",
-    answeredBy: "daemon:computer:ack",
-    payload: { kind: "zod", schema: `daemonComputerDesktop${operation[0].toUpperCase()}${operation.slice(1)}Schema` }
+    answeredBy: import_computerWire.DAEMON_COMPUTER_EVENTS.ack,
+    payload: {
+      kind: "zod",
+      schema: `daemonComputerDesktop${operation[0].toUpperCase()}${operation.slice(1)}Schema`
+    }
   })),
   ...["control", "input"].map((operation) => toDaemon(import_desktopWire.DAEMON_COMPUTER_DESKTOP_EVENTS[operation], `Human-only typed desktop ${operation}; exact authenticated attachment, stream and generation.`, {
     stability: "experimental",
     capability: import_desktopWire.COMPUTER_DESKTOP_CONTROL_CAPABILITY,
     delivery: "acked",
-    answeredBy: "daemon:computer:ack",
-    payload: { kind: "zod", schema: `daemonComputerDesktop${operation[0].toUpperCase()}${operation.slice(1)}Schema` }
+    answeredBy: import_computerWire.DAEMON_COMPUTER_EVENTS.ack,
+    payload: {
+      kind: "zod",
+      schema: `daemonComputerDesktop${operation[0].toUpperCase()}${operation.slice(1)}Schema`
+    }
   })),
   toServer(import_desktopWire.DAEMON_COMPUTER_DESKTOP_EVENTS.controlChanged, "Private desktop holder and input revocation fact; never carries a control token.", {
     stability: "experimental",