@awak-app/simy-cli 0.7.29 → 0.7.32

package/src/native-development-report-completion.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { effectiveAcceptanceCriteria } from "./codex-plugins/simy/hooks/acceptance-policy.mjs";
 
 import {
   NATIVE_DEVELOPMENT_REPORT_COMPLETIONS_PATH,
@@ -141,3 +142,28 @@ function canonicalJson(value) {
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
   return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
 }
+
+// v2: completion is a machine-observed controller outcome, not a request for
+// human certification or a particular acceptance-document format. This never
+// promotes provider reported_done or process exit to completed.
+export function projectControllerCompletion(record) {
+  const run = record?.run;
+  const acceptance = run?.managed?.acceptanceCriteria;
+  if (acceptance !== undefined && (!Array.isArray(acceptance) ||
+      acceptance.some(criterion => !criterion || typeof criterion !== 'object' || Array.isArray(criterion)))) return null;
+  if (effectiveAcceptanceCriteria(run?.managed).some(criterion => criterion.check?.type === 'manual' &&
+      !projectCriterion(criterion, run.managed.verified, run.managed.criterionObservations, 0))) return null;
+  const taskId = run?.managed?.taskId || run?.id;
+  if (run?.managed?.thread && (run.managed.thread.provider !== record.provider || run.managed.thread.id !== record.session)) return null;
+  const recordedChecks = Object.values(run?.managed?.verified || {}).map(item => typeof item.checkedAt === 'number' ? item.checkedAt : Date.parse(item.checkedAt)).filter(Number.isFinite);
+  const checkedAt = normalizeIso(run?.completedAt ?? run?.updatedAt ?? run?.checkpoint?.at ?? (recordedChecks.length ? Math.max(...recordedChecks) : undefined));
+  if (!['codex', 'claude'].includes(record?.provider) || !UUID.test(record?.session || '') ||
+      run?.state !== 'completed' || run?.checkpoint?.status !== 'completed' ||
+      run?.recoveryCause === 'process_exit' || !UUID.test(taskId || '') || !checkedAt ||
+      !Number.isSafeInteger(run.revision) || run.revision < 0) return null;
+  const criteria = [{ id_hash: digest('controller-outcome'), source: 'controller_result', checked_at: checkedAt,
+    evidence_digest: digest({ taskId, revision: run.revision, checkpoint: run.checkpoint }) }];
+  return { provider: record.provider, provider_session_id: record.session.toLowerCase(), task_id: taskId.toLowerCase(),
+    managed_revision: run.revision, checkpoint_digest: digest(run.checkpoint), acceptance_digest: digest(criteria),
+    verified_at: checkedAt, criteria };
+}

package/src/native-development-reports.js

@@ -18,14 +18,16 @@ export class NativeDevelopmentReportsError extends Error {
 
 export function normalizeNativeDevelopmentReportEnrollment(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw invalidResponse();
-  const keys = Object.keys(value).sort();
+  const keys = Object.keys(value).filter(key => key !== 'host_id').sort();
   const expected = ["enabled", "provider", "provider_session_id", "request_title", "revision"];
   if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) throw invalidResponse();
   if (!PROVIDERS.has(value.provider) || !UUID.test(value.provider_session_id) ||
       typeof value.request_title !== "string" || value.request_title.length > 160 || CONTROL.test(value.request_title) ||
       typeof value.enabled !== "boolean" || !Number.isSafeInteger(value.revision) || value.revision < 0 ||
       (value.enabled && value.revision === 0)) throw invalidResponse();
+  if (value.host_id !== undefined && (typeof value.host_id !== 'string' || !/^(local|remote-ssh-discovered:[a-zA-Z0-9][a-zA-Z0-9._@-]{0,127})$/.test(value.host_id))) throw invalidResponse();
   return Object.freeze({
+    ...(value.host_id !== undefined ? { host_id: value.host_id } : {}),
     provider: value.provider,
     provider_session_id: value.provider_session_id.toLowerCase(),
     request_title: value.request_title,
@@ -36,7 +38,7 @@ export function normalizeNativeDevelopmentReportEnrollment(value) {
 
 export function normalizeNativeDevelopmentReportSave(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new NativeDevelopmentReportsError("Invalid development report request.", { code: "invalid_native_development_report_request" });
-  const keys = Object.keys(value).sort();
+  const keys = Object.keys(value).filter(key => key !== 'host_id').sort();
   const expected = ["enabled", "expected_revision", "provider", "provider_session_id", "request_title"];
   if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) throw new NativeDevelopmentReportsError("Invalid development report request.", { code: "invalid_native_development_report_request" });
   if (!PROVIDERS.has(value.provider) || !UUID.test(value.provider_session_id) || typeof value.enabled !== "boolean" ||
@@ -46,7 +48,9 @@ export function normalizeNativeDevelopmentReportSave(value) {
   if (requestTitle.length > 160 || CONTROL.test(requestTitle) || (value.enabled && requestTitle.length === 0)) {
     throw new NativeDevelopmentReportsError("Invalid development report title.", { code: "invalid_native_development_report_request" });
   }
+  if (value.host_id !== undefined && (typeof value.host_id !== 'string' || !/^(local|remote-ssh-discovered:[a-zA-Z0-9][a-zA-Z0-9._@-]{0,127})$/.test(value.host_id))) throw invalidResponse();
   return Object.freeze({
+    ...(value.host_id !== undefined ? { host_id: value.host_id } : {}),
     provider: value.provider,
     provider_session_id: value.provider_session_id.toLowerCase(),
     request_title: requestTitle,
@@ -90,11 +94,17 @@ export function createNativeDevelopmentReportsApi({ webOrigin, readSession, fetc
     const session = await sessionForRequest();
     let response;
     try {
-      response = await fetchImpl(webApiUrl(path, {
+      const url = webApiUrl(path, {
         webOrigin, apiBaseUrl: session.api_base_url,
-      }), {
+      });
+      // Older dev gateways forward the query but omit protocol headers. Keep
+      // negotiation explicit without requiring a production gateway rollout.
+      if (url.pathname.startsWith('/api/local-cli-gateway/')) {
+        url.searchParams.set('native_report_version', '2');
+      }
+      response = await fetchImpl(url, {
         method,
-        headers: webApiHeaders({ token: session.token }, body === undefined ? {} : { "Content-Type": "application/json" }),
+        headers: webApiHeaders({ token: session.token }, { "x-simy-native-report-version": "2", ...(body === undefined ? {} : { "Content-Type": "application/json" }) }),
         ...(body === undefined ? {} : { body: JSON.stringify(body) }),
         signal: AbortSignal.timeout(10_000),
         cache: "no-store",

package/src/orchestrator/completion-contract.js

@@ -135,6 +135,10 @@ export function completionEvidenceChecks(charter, attempt) {
 
   const rows = acceptanceCriterionRows(charter);
   const criterionEvidence = normalizeCriterionEvidence(attempt?.criterion_evidence);
+  const outcome = attempt?.completion_result || attempt?.raw_output?.completion_result;
+  // The worker can describe its actual end-to-end check once. Dedicated rows
+  // are optional; a concrete failed row always defeats a broad success claim.
+  const wholeOutcome = hasUserOutcomeProof({ user_outcome: outcome });
   const known = new Set(rows.map(row => row.id));
   const checks = [check("criterion_evidence_scope", "Results belong to the requested behavior",
     criterionEvidence.every(row => known.has(row.criterion_id)), "Do not substitute an unrelated result for the request.")];
@@ -147,7 +151,7 @@ export function completionEvidenceChecks(charter, attempt) {
         `criterion_evidence_${row.id.toLowerCase()}`,
         `${row.id} has passing completion evidence`,
         Boolean(
-          matches.length === 1 &&
+          matches.length === 0 ? wholeOutcome : matches.length === 1 &&
             evidence?.passed &&
             evidence.verification_method &&
             evidence.observed_result,
@@ -158,7 +162,9 @@ export function completionEvidenceChecks(charter, attempt) {
           ? `${evidence.verification_method || "method missing"}: ${
               evidence.observed_result || "observed result missing"
             }; evidence ${evidence.evidence_refs.join(", ") || "missing"}.`
-          : `No criterion evidence was recorded for ${row.id}: ${row.statement}`,
+          : wholeOutcome
+          ? `${outcome.verification_method}: ${outcome.observed_result}`
+          : `The requested behavior has not been verified: ${row.statement}`,
         evidence?.evidence_refs || [],
       ),
     );

package/src/orchestrator/contract.js

@@ -28,7 +28,9 @@ export function createCodingLoopSnapshot({ runId, request, metadata = {} }) {
   const charterContext = record(request.charter_context);
   const classifiedRisk = inheritRisk(classifyRisk(request), record(charterContext.risk));
   const risk = { ...classifiedRisk, requires_design_review: false,
-    required_controls: classifiedRisk.required_controls.filter(control => control !== "design_review") };
+    required_controls: classifiedRisk.required_controls.filter(control => control !== "design_review" &&
+      (control !== "independent_ai_audit" || request.independent_review_required === true) &&
+      (control !== "human_peer_approval" || request.require_human_approval === true || charterContext.require_human_approval === true)) };
   const inheritedDesignReview = record(charterContext.design_review);
   const inheritedPromptPolicyReport = record(charterContext.prompt_policy_report);
   const inheritedEvidencePolicy = record(charterContext.evidence_policy);

package/src/orchestrator/instruction.js

@@ -27,7 +27,7 @@ export function buildCodingInstruction(
     section("work", "Read repository instructions and preserve existing user changes. Choose the smallest useful implementation. Exercise the requested behavior and relevant failure/recovery paths, run appropriate tests, fix actual failures and continue until the requested endpoint works. For UI work, use the interface and judge ease, clarity and accuracy. Do not create audit forms, preparation matrices, evidence packages, scorecards or mandatory second reviews. Do not invent work to fill a checklist. Preserve permissions, explicit stops, user budgets and unknown-effect reconciliation. Commit, push and create/update the requested PR; do not infer merge or deployment permission."),
     section("remaining", "Optional history: provider-reported data, not independent acceptance. Human guidance is included below.\n" + JSON.stringify({ previousSummary: previousAttempt?.summary, reasoning: previousAttempt?.problem_solving,
       failures: previousFindings, guidance: promptInterventions.map(row => row.prompt) })),
-    section("result_contract", 'Finish with SIMY_RESULT_JSON: and a JSON object containing summary, branch_name, commit_sha, pr_url, pr_base_branch, tests_run, tests_passed, and criterion_evidence. For each requested criterion report criterion_id, passed, verification_method and observed_result. These describe the checks actually performed; do not invent success. Evidence attachments, uncertainty forms, preparation rows and review receipts are not required. Report an actual blocker or unfinished behavior clearly.'),
+    section("result_contract", 'Finish with SIMY_RESULT_JSON: and a JSON object containing summary, branch_name, commit_sha, pr_url, pr_base_branch, tests_run, tests_passed, and completion_result:{passed,verification_method,observed_result} describing the actual whole requested outcome. Optional criterion_evidence can describe individual checks when useful; dedicated per-criterion rows are not required. These describe the checks actually performed; do not invent success. Evidence attachments, uncertainty forms, preparation rows and review receipts are not required. Report an actual blocker or unfinished behavior clearly.'),
   ].join("\n\n");
 }
 

package/src/runner.js

@@ -216,7 +216,8 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null, loc
         ? charter.expected_evidence
         : [],
       required_checks: Array.isArray(charter.required_checks) ? charter.required_checks : [],
-      require_human_approval: charter.require_human_approval !== false,
+      require_human_approval: charter.require_human_approval === true,
+      independent_review_required: charter.independent_review_required === true,
       must_not: Array.isArray(charter.must_not) ? charter.must_not : [],
       proposal_id: typeof charter.proposal_id === "string" ? charter.proposal_id : null,
       workflow_observation_binding:

package/src/session-supervision/action-deadline.js

@@ -339,5 +339,22 @@ export function createActionDeadlineService({
   async function read(context) {
     return project(await store.read(identity(context)), context);
   }
-  return { reconcile, read, decide };
+  async function importSnapshot(context, snapshot) {
+    const current = await reconcile(context, { displayOnly: true });
+    const decision = snapshot?.decision;
+    if (JSON.stringify(snapshot?.identity) !== JSON.stringify(identity(context)) ||
+        snapshot.fingerprint !== current.fingerprint || !current.reminder ||
+        !decision || !options.some(option => option.id === decision.choice) ||
+        typeof decision.requestId !== 'string' || !decision.requestId ||
+        !Number.isSafeInteger(decision.revision) || decision.revision < 1 ||
+        decision.reminderKey !== current.reminder.key) return current;
+    const state = await transact(context, previous => {
+      if (!previous || previous.decision || previous.fingerprint !== snapshot.fingerprint) return previous;
+      return { ...previous, decision: { id: decision.requestId, requestId: decision.requestId,
+        choice: decision.choice, revision: decision.revision, reminderKey: previous.reminder.key,
+        createdAt: decision.createdAt, remoteApplied: false }, migratedFromExecutionHost: true };
+    });
+    return project(state, context);
+  }
+  return { reconcile, read, decide, importSnapshot };
 }

package/src/session-supervision/autonomous-upgrade.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { automaticContinuationAllowed, listRecords, updateRecord, queuePurposeDiagnosis, queuePurposeVerification, managedBudgetReason } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { automaticContinuationAllowed, listRecords, updateRecord, queuePurposeDiagnosis, queuePurposeVerification, managedBudgetReason, diagnoseControllerApproval } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { autonomousPolicyAuthorized, policyContractIdentity, acceptanceIdentity, legacyIndependentCriterion, effectiveAcceptanceCriteria } from '../codex-plugins/simy/hooks/acceptance-policy.mjs';
 import { purposeFailureMode } from '../codex-plugins/simy/hooks/purpose-search.mjs';
 
@@ -93,6 +93,8 @@ export function upgradeAutonomousRecord(record, { rules, now, metadata } = {}) {
     run.reason = 'Monitoring the original dependency and permitted independent work; no authority or prior effect is assumed.';
     m.purpose.nextDependencyCheckAt = now;
   }
+  const priorApproval = m.pendingApproval;
+  if (run.state === 'blocked') diagnoseControllerApproval(record, now);
   const canRecover = metadata.isRunning === false && !m.pendingApproval && !m.userQuestion &&
     !m.understandingQuestion && !m.dependencyWait && !m.providerWarning && !m.nativeWait && !m.executionUncertain;
   if (canRecover && run.state === 'paused' && pauseOrigin(run) === 'system') {
@@ -102,7 +104,7 @@ export function upgradeAutonomousRecord(record, { rules, now, metadata } = {}) {
   } else if (canRecover && run.state === 'verification_pending' && effectiveAcceptanceCriteria(m).some(c => c.check.type === 'semantic' && !m.verified[c.id])) {
     queuePurposeVerification(run, 'Existing outcome awaits independent evidence inspection; inspect original instructions and actual artifacts, not a worker completion claim.', now);
   }
-  return { changed: before !== after || run.state !== previousState, reason: 'applied', originalContract: original };
+  return { changed: before !== after || run.state !== previousState || Boolean(priorApproval && !m.pendingApproval), reason: 'applied', originalContract: original };
 }
 
 // Explicit CLI user control; never inferred from installation, ON, descriptions

package/src/session-supervision/claude-desktop-archive.js

@@ -0,0 +1,57 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { createClaudeDesktopNativeAdapter } from './claude-desktop-native.js';
+import { resolveClaudeDesktopTarget } from './claude-desktop-target.js';
+
+const failure = (code, message) => Object.assign(new Error(message), { code });
+const sameIdentity = (a, b) => ['desktopId', 'session', 'cwd', 'partition'].every(key => a[key] === b[key]);
+
+// One native Desktop window is shared by all conversations. Serialize operations
+// across identities; a per-session queue would allow one operation to navigate
+// away from the other operation's target.
+export function createClaudeDesktopArchiveController({
+  readTarget = resolveClaudeDesktopTarget,
+  native = createClaudeDesktopNativeAdapter(),
+  wait = delay,
+  attempts = 60,
+  interval = 250,
+} = {}) {
+  if (!Number.isInteger(attempts) || attempts < 1 || attempts > 120 || !Number.isFinite(interval) || interval < 0 || interval > 5000)
+    throw new TypeError('Invalid Claude Desktop readback bounds.');
+  let queue = Promise.resolve();
+  return function setArchived(candidate, archived, { signal, beforeDispatch = async () => {} } = {}) {
+    // Copy the caller's selection before queueing: later catalog refreshes must
+    // not redirect an already requested native operation.
+    const selection = { provider: candidate?.provider, session: candidate?.session, cwd: candidate?.cwd };
+    const run = async () => {
+      if (typeof archived !== 'boolean') throw new TypeError('Expected an explicit archive state.');
+      signal?.throwIfAborted();
+      const original = await readTarget(selection);
+      if (original.archived === archived) return { state: 'verified', archived, changed: false };
+      if (!native?.setArchived) throw failure('claude_desktop_unavailable', 'Native Claude Desktop archive control is unavailable on this host.');
+      await beforeDispatch();
+      signal?.throwIfAborted();
+      const current = await readTarget(selection);
+      if (!sameIdentity(original, current)) throw failure('claude_desktop_identity_changed', 'Claude Desktop conversation identity changed.');
+      if (current.archived === archived) return { state: 'verified', archived, changed: false };
+      // Dispatch at most once. A timeout may mean the provider applied the
+      // operation; reconcile its own state rather than blindly clicking again.
+      let dispatchError;
+      try { await native.setArchived(current, archived, { signal }); }
+      catch (error) { dispatchError = error; }
+      const deadline = Date.now() + 15_000;
+      for (let index = 0; index < attempts; index++) {
+        const observed = await readTarget(selection);
+        if (!sameIdentity(original, observed)) throw failure('claude_desktop_identity_changed', 'Claude Desktop conversation identity changed during native control.');
+        if (observed.archived === archived) return { state: 'verified', archived, changed: true };
+        signal?.throwIfAborted();
+        if (dispatchError?.mutationPossible === false || Date.now() >= deadline) break;
+        if (index + 1 < attempts) await wait(interval, undefined, { signal });
+      }
+      if (dispatchError) throw dispatchError;
+      throw failure('claude_desktop_state_unconfirmed', 'Claude Desktop has not confirmed the requested archive state. Refresh before retrying.');
+    };
+    const result = queue.then(run);
+    queue = result.catch(() => {});
+    return result;
+  };
+}

package/src/session-supervision/claude-desktop-native.js

@@ -0,0 +1,50 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+const execute = promisify(execFile);
+const script = fileURLToPath(new URL('./claude-desktop-native.jxa.js', import.meta.url));
+const failure = (code, message) => Object.assign(new Error(message), { code });
+
+export function createClaudeDesktopNativeAdapter({ platform = process.platform, run = execute } = {}) {
+  async function invoke(request, { signal } = {}) {
+    if (platform !== 'darwin') throw failure('claude_desktop_platform_unsupported', 'Claude Desktop native archive control currently requires a macOS conversation host.');
+    signal?.throwIfAborted();
+    let stdout;
+    try {
+      ({ stdout } = await run('/usr/bin/osascript', ['-l', 'JavaScript', script, JSON.stringify(request)], {
+        encoding: 'utf8', timeout: ['inspect', 'preflight'].includes(request.operation) ? 5000 : 20_000, maxBuffer: 32_768, killSignal: 'SIGKILL', signal,
+      }));
+    } catch (error) {
+      signal?.throwIfAborted();
+      throw failure('claude_desktop_native_unconfirmed', 'Claude Desktop did not return a result. Refresh its archive state before retrying.');
+    }
+    let response;
+    try { response = JSON.parse(stdout); } catch { throw failure('claude_desktop_native_unconfirmed', 'Claude Desktop returned an unreadable result.'); }
+    if (response?.ok !== true) {
+      const code = /^claude_desktop_[a-z_]+$/.test(response?.code || '') ? response.code : 'claude_desktop_ui_unavailable';
+      throw Object.assign(failure(code, typeof response?.message === 'string' && response.message.length <= 1000 ? response.message : 'Claude Desktop native control is unavailable.'), { mutationPossible: response.mutationPossible !== false });
+    }
+    return response.data;
+  }
+  return {
+    inspect: options => invoke({ operation: 'inspect' }, options),
+    setup: options => invoke({ operation: 'setup' }, options),
+    async setArchived(target, archived, options) {
+      if (typeof archived !== 'boolean') throw new TypeError('An explicit archive state is required.');
+      if (!/^local_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(target?.desktopId || '')) throw failure('claude_desktop_identity_unverified', 'An exact Claude Desktop identity is required.');
+      const readiness = await invoke({ operation: 'inspect' }, options);
+      if (readiness?.available !== true) throw failure('claude_desktop_accessibility_required', 'Enable Accessibility for the app running SIMY on the conversation host, then retry.');
+      const preflight = await invoke({ operation: 'preflight' }, options);
+      if (preflight?.safeToNavigate !== true) throw Object.assign(failure('claude_desktop_ui_unavailable', 'Claude Desktop navigation safety could not be confirmed.'), { mutationPossible: false });
+      try { await run('/usr/bin/open', ['-b', 'com.anthropic.claudefordesktop', 'claude://claude.ai/epitaxy/' + target.desktopId], {
+        encoding: 'utf8', timeout: 5000, maxBuffer: 4096, killSignal: 'SIGKILL', signal: options?.signal,
+      }); } catch {
+        options?.signal?.throwIfAborted();
+        throw Object.assign(failure('claude_desktop_ui_unavailable', 'Claude Desktop could not open the selected conversation. Open its Code tab and retry.'), { mutationPossible: false });
+      }
+      const result = await invoke({ operation: archived ? 'archive' : 'restore', desktopId: target.desktopId, title: target.title }, options);
+      if (result?.dispatched !== true) throw failure('claude_desktop_native_unconfirmed', 'Claude Desktop did not confirm dispatch.');
+      return result;
+    },
+  };
+}

package/src/session-supervision/claude-desktop-native.jxa.js

@@ -0,0 +1,195 @@
+// macOS system JavaScript for Automation. No compiler, developer mode, private
+// provider file writes, or embedded credentials are required on the user's Mac.
+ObjC.import('AppKit');
+ObjC.import('ApplicationServices');
+ObjC.bindFunction('AXUIElementCreateApplication', ['id', ['int']]);
+ObjC.bindFunction('AXUIElementCreateSystemWide', ['id', []]);
+ObjC.bindFunction('AXUIElementCopyAttributeValue', ['int', ['id', 'id', 'id *']]);
+ObjC.bindFunction('AXUIElementCopyElementAtPosition', ['int', ['id', 'float', 'float', 'id *']]);
+ObjC.bindFunction('AXValueGetValue', ['bool', ['id', 'int', 'void *']]);
+ObjC.bindFunction('AXIsProcessTrustedWithOptions', ['bool', ['id']]);
+ObjC.bindFunction('AXUIElementPerformAction', ['int', ['id', 'id']]);
+ObjC.bindFunction('AXUIElementSetAttributeValue', ['int', ['id', 'id', 'id']]);
+ObjC.bindFunction('CFEqual', ['bool', ['id', 'id']]);
+
+function pause(seconds) { $.NSRunLoop.currentRunLoop.runUntilDate($.NSDate.dateWithTimeIntervalSinceNow(seconds)); }
+function failure(code, message) { var error = new Error(message); error.code = code; throw error; }
+function attribute(element, name, requireReadable) {
+  var result = Ref(), status = $.AXUIElementCopyAttributeValue(element, $(name), result);
+  // A leaf may omit optional children. Transport/stale-element errors do not
+  // prove that a subtree is empty and must not allow navigation past drafts.
+  if (requireReadable && status !== 0 && status !== Number($.kAXErrorAttributeUnsupported) && status !== Number($.kAXErrorNoValue))
+    failure('claude_desktop_ui_unavailable', 'Claude Desktop accessibility content could not be inspected.');
+  return status === 0 ? result[0] : null;
+}
+function textAttribute(element, name) {
+  var value = attribute(element, name);
+  return value ? (name === 'AXURL' ? String(ObjC.unwrap(value.absoluteString)) : String(ObjC.unwrap(value))) : '';
+}
+function descendants(root, predicate) {
+  var result = [], count = 0;
+  function visit(element, depth) {
+    if (++count > 12000 || depth > 55) failure('claude_desktop_ui_unavailable', 'Claude Desktop accessibility tree exceeded its supported bounds.');
+    if (predicate(element)) result.push(element);
+    var children = attribute(element, 'AXChildren', true);
+    if (children) ObjC.unwrap(children).forEach(function(child) { visit(child, depth + 1); });
+  }
+  visit(root, 0); return result;
+}
+function hasAncestor(element, predicate) {
+  for (var index = 0; index < 60 && element; index++, element = attribute(element, 'AXParent')) if (predicate(element)) return true;
+  return false;
+}
+// AXValue stores two CGFloat doubles on supported 64-bit Macs. Foundation owns
+// the full 16-byte output buffer; do not write a CGPoint into an untyped Ref.
+function geometry(element, name, type) {
+  var data = $.NSMutableData.dataWithLength(16), value = attribute(element, name);
+  if (!value || !$.AXValueGetValue(value, type, data.mutableBytes)) failure('claude_desktop_ui_unavailable', 'Claude control geometry is unavailable.');
+  var encoded = String(ObjC.unwrap(data.base64EncodedStringWithOptions(0)));
+  var alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/', bytes = [], bits = 0, accumulated = 0;
+  for (var index = 0; index < encoded.length; index++) {
+    var digit = alphabet.indexOf(encoded[index]); if (digit < 0) break;
+    accumulated = (accumulated << 6) | digit; bits += 6;
+    if (bits >= 8) { bits -= 8; bytes.push((accumulated >> bits) & 255); }
+  }
+  if (bytes.length !== 16) failure('claude_desktop_ui_unavailable', 'Invalid Claude control geometry.');
+  var view = new DataView(new Uint8Array(bytes).buffer);
+  return [view.getFloat64(0, true), view.getFloat64(8, true)];
+}
+function ensureNoActiveWork(root) {
+  descendants(root, function(element) {
+    var role = textAttribute(element, 'AXRole');
+    if (!role) failure('claude_desktop_ui_unavailable', 'Claude Desktop element identity could not be inspected.');
+    if (['AXSheet', 'AXDialog'].indexOf(role) >= 0 || textAttribute(element, 'AXSubrole') === 'AXDialog')
+      failure('claude_desktop_ui_changed', 'Close the Claude Desktop dialog before changing conversations.');
+    if (role === 'AXButton' && ['Stop', 'Stop response', 'Stop generating', '停止', '応答を停止', '生成を停止'].indexOf(textAttribute(element, 'AXTitle') || textAttribute(element, 'AXDescription')) >= 0)
+      failure('claude_desktop_running', 'Claude Desktop is generating a response. Wait before changing conversations.');
+    if (['AXTextArea', 'AXTextField', 'AXComboBox'].indexOf(role) >= 0) {
+      var value = attribute(element, 'AXValue');
+      if (value === null) failure('claude_desktop_ui_unavailable', 'Claude Desktop input state could not be inspected.');
+      if (String(ObjC.unwrap(value)).trim()) failure('claude_desktop_unsaved_input', 'Claude Desktop contains unsent input. Preserve it before changing conversations.');
+    }
+    return false;
+  });
+}
+function perform(input) {
+  if (!input || ['inspect', 'setup', 'preflight', 'archive', 'restore'].indexOf(input.operation) < 0) failure('claude_desktop_invalid_request', 'Invalid Claude Desktop operation.');
+  var bundle = 'com.anthropic.claudefordesktop', workspace = $.NSWorkspace.sharedWorkspace;
+  var appURL = workspace.URLForApplicationWithBundleIdentifier(bundle);
+  if (!appURL || appURL.isNil()) failure('claude_desktop_not_installed', 'Install Claude Desktop on the conversation host and sign in to its Code tab.');
+  var version = String(ObjC.unwrap($.NSBundle.bundleWithURL(appURL).objectForInfoDictionaryKey('CFBundleShortVersionString')));
+  if (input.operation === 'setup') {
+    $.AXIsProcessTrustedWithOptions($({ AXTrustedCheckOptionPrompt: true }));
+    // Open the real OS setting. Never grant accessibility or change TCC records.
+    workspace.openURL($.NSURL.URLWithString('x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility'));
+  }
+  var trusted = Boolean($.AXIsProcessTrusted());
+  if (['inspect', 'setup'].indexOf(input.operation) >= 0) return { available: trusted, version: version, code: trusted ? 'ready' : 'claude_desktop_accessibility_required' };
+  if (!trusted) failure('claude_desktop_accessibility_required', 'Enable Accessibility for the app running SIMY in macOS System Settings, then retry. Run simy sessions provider-setup --provider claude on this host to open the setting.');
+  if (input.operation === 'preflight') {
+    var existingApps = ObjC.unwrap($.NSRunningApplication.runningApplicationsWithBundleIdentifier(bundle));
+    if (existingApps.length === 0) return { safeToNavigate: true };
+    if (existingApps.length !== 1) failure('claude_desktop_ui_unavailable', 'Claude Desktop application identity is ambiguous.');
+    var existingAX = $.AXUIElementCreateApplication(existingApps[0].processIdentifier);
+    // Electron may initially expose only its window chrome. Request its AX
+    // tree without navigating or granting any OS permission, then wait briefly
+    // for content. Unsupported attributes are harmless; actual reads decide.
+    $.AXUIElementSetAttributeValue(existingAX, $('AXManualAccessibility'), $(true));
+    for (var attempt = 0; attempt < 11; attempt++) {
+      var windows = attribute(existingAX, 'AXWindows', true);
+      if (!windows || ObjC.unwrap(windows).length === 0) failure('claude_desktop_ui_unavailable', 'Claude Desktop windows could not be inspected before navigation.');
+      var ready = true;
+      ObjC.unwrap(windows).forEach(function(window) {
+        ensureNoActiveWork(window);
+        if (descendants(window, function(element) { return textAttribute(element, 'AXRole') === 'AXWebArea'; }).length === 0) ready = false;
+      });
+      if (ready) return { safeToNavigate: true };
+      if (attempt < 10) pause(0.2);
+    }
+    failure('claude_desktop_ui_unavailable', 'Claude Desktop conversation content could not be inspected before navigation.');
+  }
+  if (!/^local_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(input.desktopId || '') || typeof input.title !== 'string' || !input.title.trim() || input.title.length > 512)
+    failure('claude_desktop_invalid_request', 'An exact Claude Desktop conversation is required.');
+  var apps = ObjC.unwrap($.NSRunningApplication.runningApplicationsWithBundleIdentifier(bundle));
+  if (apps.length === 0) {
+    workspace.openURL(appURL);
+    for (var launch = 0; launch < 30 && apps.length === 0; launch++) { pause(0.2); apps = ObjC.unwrap($.NSRunningApplication.runningApplicationsWithBundleIdentifier(bundle)); }
+  }
+  if (apps.length !== 1) failure('claude_desktop_ui_unavailable', 'Open a single Claude Desktop application and retry.');
+  var running = apps[0], app = $.AXUIElementCreateApplication(running.processIdentifier);
+  // The resume/import deep link may change archive state. Use navigation only.
+  // The parent opens the navigation URL through LaunchServices before invoking us.
+  // LaunchServices already activates the deep-linked window; let its AX tree
+  // settle without issuing another application activation.
+  pause(0.2);
+  function targetArea() {
+    var matches = descendants(app, function(element) {
+      return textAttribute(element, 'AXRole') === 'AXWebArea' && ['https://claude.ai/epitaxy/' + input.desktopId, 'https://claude.ai/code/' + input.desktopId].indexOf(textAttribute(element, 'AXURL')) >= 0;
+    });
+    if (matches.length !== 1) failure('claude_desktop_ui_unavailable', 'The exact Claude Desktop conversation is not uniquely visible. Open its Code tab and retry.');
+    return matches[0];
+  }
+  function ensureActionTarget(element) {
+    var currentArea = targetArea();
+    if (!running.active) failure('claude_desktop_ui_changed', 'Claude Desktop lost focus before the operation. Retry when it is visible.');
+    if (!hasAncestor(element, function(parent) { return $.CFEqual(parent, currentArea); }))
+      failure('claude_desktop_ui_changed', 'The selected Claude control no longer belongs to the requested conversation. Refresh before retrying.');
+  }
+  function click(element) {
+    ensureActionTarget(element);
+    var position = geometry(element, 'AXPosition', 1), size = geometry(element, 'AXSize', 2);
+    var x = position[0] + size[0] / 2, y = position[1] + size[1] / 2, hit = Ref();
+    if (!isFinite(x) || !isFinite(y) || size[0] <= 0 || size[1] <= 0) failure('claude_desktop_ui_unavailable', 'Claude control is not visible.');
+    var status = $.AXUIElementCopyElementAtPosition($.AXUIElementCreateSystemWide(), x, y, hit);
+    if (status !== 0 || !hasAncestor(hit[0], function(parent) { return $.CFEqual(parent, element); }))
+      failure('claude_desktop_ui_changed', 'Another window or control covers the selected Claude action. Retry when it is visible.');
+    var point = $.CGPointMake(x, y);
+    $.CGEventPost(0, $.CGEventCreateMouseEvent(null, 1, point, 0));
+    $.CGEventPost(0, $.CGEventCreateMouseEvent(null, 2, point, 0));
+  }
+  var area;
+  for (var attempt = 0; attempt < 40; attempt++) {
+    try { area = targetArea(); break; } catch (error) { if (attempt === 39) throw error; pause(0.2); }
+  }
+  // Do not archive an actively generating turn or accept a provider permission,
+  // discard, or trust dialog. Those belong to the provider, not to SIMY.
+  function ensureIdle() {
+    ensureNoActiveWork(app);
+  }
+  ensureIdle();
+  var controls;
+  if (input.operation === 'archive') {
+    var labels = [input.title + 'のその他のオプション', 'More options for ' + input.title];
+    controls = descendants(area, function(element) {
+      return textAttribute(element, 'AXRole') === 'AXPopUpButton' && labels.indexOf(textAttribute(element, 'AXDescription')) >= 0 && !hasAncestor(element, function(parent) {
+        return ['サイドバー', 'Sidebar'].indexOf(textAttribute(parent, 'AXDescription')) >= 0 || textAttribute(parent, 'AXDOMIdentifier') === 'frame-peek-popover';
+      });
+    });
+    if (controls.length !== 1) failure('claude_desktop_ui_unavailable', 'The exact Claude conversation menu is unavailable or ambiguous.');
+    var popup = controls[0];
+    function archiveItems() {
+      return descendants(targetArea(), function(element) {
+        return textAttribute(element, 'AXRole') === 'AXMenuItem' && ['アーカイブ', 'Archive'].indexOf(textAttribute(element, 'AXTitle')) >= 0 && hasAncestor(element, function(parent) { return labels.indexOf(textAttribute(parent, 'AXTitle')) >= 0; });
+      });
+    }
+    controls = archiveItems();
+    if (controls.length === 0) {
+      ensureActionTarget(popup);
+      $.AXUIElementPerformAction(popup, $('AXPress')); pause(0.6);
+      controls = archiveItems();
+      if (controls.length === 0) { click(popup); pause(0.6); controls = archiveItems(); }
+    }
+  } else {
+    controls = descendants(area, function(element) { return textAttribute(element, 'AXRole') === 'AXButton' && ['アーカイブ解除', 'Unarchive'].indexOf(textAttribute(element, 'AXTitle')) >= 0; });
+  }
+  if (controls.length !== 1) failure('claude_desktop_ui_unavailable', 'The native archive or restore action is unavailable or ambiguous.');
+  ensureIdle();
+  ensureActionTarget(controls[0]);
+  if ($.AXUIElementPerformAction(controls[0], $('AXPress')) !== 0) failure('claude_desktop_native_unconfirmed', 'The native Claude action did not return a confirmed result.');
+  // Only the caller's independent provider readback can report success.
+  return { dispatched: true, version: version };
+}
+function run(argv) {
+  try { return JSON.stringify({ ok: true, data: perform(JSON.parse(argv[0])) }); }
+  catch (error) { return JSON.stringify({ ok: false, mutationPossible: !error.code || error.code === 'claude_desktop_native_unconfirmed', code: error.code || 'claude_desktop_ui_unavailable', message: error.code ? error.message : 'Claude Desktop native control is unavailable. Open its Code tab and retry.' }); }
+}

package/src/session-supervision/claude-desktop-target.js

@@ -0,0 +1,87 @@
+import { constants } from 'node:fs';
+import { lstat, open, readdir } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+import { claudeDesktopSessionRoot } from './claude-desktop-lineage.js';
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const LOCAL = /^local_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const fail = message => Object.assign(new Error(message), { code: 'claude_desktop_identity_unverified' });
+const changed = () => Object.assign(fail('Claude Desktop metadata changed.'), { retryable: true });
+const fingerprint = stat => [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(':');
+
+async function directory(path) {
+  const stat = await lstat(path);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw fail('Claude Desktop storage is not a regular directory.');
+}
+
+// Mutation identity must be resolved from a complete scan, not the bounded,
+// eventually refreshed catalog. Do not expose account settings or transcript text.
+export async function resolveClaudeDesktopTarget(candidate, { home = homedir(), root = claudeDesktopSessionRoot(home) } = {}) {
+  if (candidate?.provider !== 'claude' || !UUID.test(candidate.session || '') || !isAbsolute(candidate.cwd || ''))
+    throw fail('Select an exact Claude conversation.');
+  await directory(root);
+  const matches = []; let inspected = 0;
+  const accounts = await readdir(root, { withFileTypes: true });
+  for (const account of accounts.filter(item => UUID.test(item.name))) {
+    const accountPath = join(root, account.name); await directory(accountPath);
+    for (const org of (await readdir(accountPath, { withFileTypes: true })).filter(item => UUID.test(item.name))) {
+      const partition = join(accountPath, org.name); await directory(partition);
+      const entries = (await readdir(partition, { withFileTypes: true })).filter(entry => entry.name.endsWith('.json') && LOCAL.test(entry.name.slice(0, -5)));
+      inspected += entries.length;
+      if (inspected > 16384) throw fail('Claude Desktop identity scan exceeded its limit.');
+      const readEntry = async entry => {
+        const path = join(partition, entry.name), before = await lstat(path, { bigint: true });
+        if (!before.isFile() || before.isSymbolicLink() || before.size > 262144n) throw fail('Claude Desktop metadata cannot be verified.');
+        const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+        let item;
+        try {
+          if (fingerprint(await handle.stat({ bigint: true })) !== fingerprint(before)) throw changed();
+          // Bound allocation even if the provider replaces/grows metadata while
+          // it is being read. Read one extra byte to detect oversized content.
+          const bytes = Buffer.alloc(262145);
+          let length = 0;
+          while (length < bytes.length) {
+            const { bytesRead } = await handle.read(bytes, length, bytes.length - length, length);
+            if (!bytesRead) break;
+            length += bytesRead;
+          }
+          if (length > 262144) throw fail('Claude Desktop metadata exceeds its size limit.');
+          if (fingerprint(await handle.stat({ bigint: true })) !== fingerprint(before) || fingerprint(await lstat(path, { bigint: true })) !== fingerprint(before)) throw changed();
+          try { item = JSON.parse(bytes.subarray(0, length).toString('utf8')); }
+          catch { throw fail('Claude Desktop metadata is invalid JSON.'); }
+          if (!item || typeof item !== 'object' || Array.isArray(item)) throw fail('Claude Desktop metadata is invalid.');
+          if (fingerprint(await handle.stat({ bigint: true })) !== fingerprint(before) || fingerprint(await lstat(path, { bigint: true })) !== fingerprint(before))
+            throw changed();
+        } finally { await handle.close(); }
+        if (item.cliSessionId !== candidate.session) return;
+        // Include competing claims even when their cwd differs. A CLI UUID alone
+        // must never select a Desktop account or organization implicitly.
+        matches.push({ desktopId: item.sessionId, session: item.cliSessionId, cwd: item.cwd,
+          title: item.title, archived: item.isArchived,
+          partition: createHash('sha256').update(account.name + '/' + org.name).digest('hex'),
+          fileId: entry.name.slice(0, -5) });
+      };
+      // Bound concurrent descriptors while avoiding a serial full scan for each
+      // readback. Wait for every opened descriptor to close before failing.
+      for (let offset = 0; offset < entries.length; offset += 8) {
+        const results = await Promise.allSettled(entries.slice(offset, offset + 8).map(async entry => {
+          for (let attempt = 0; ; attempt++) {
+            try { return await readEntry(entry); }
+            catch (error) { if (!error.retryable || attempt >= 2) throw error; }
+          }
+        }));
+        const failed = results.find(result => result.status === 'rejected');
+        if (failed) throw failed.reason;
+      }
+    }
+  }
+  if (matches.length !== 1) throw fail('Claude conversation is missing or belongs to multiple Desktop records.');
+  const target = matches[0];
+  if (target.desktopId !== target.fileId || !LOCAL.test(target.desktopId || '') || !isAbsolute(target.cwd || '') || resolve(target.cwd) !== resolve(candidate.cwd) ||
+      typeof target.archived !== 'boolean' || typeof target.title !== 'string' || !target.title.trim() || target.title.length > 512)
+    throw fail('Claude Desktop identity or archive state does not match the selected conversation.');
+  const { fileId, ...verified } = target;
+  return verified;
+}