@awak-app/simy-cli 0.7.28 → 0.7.31

package/src/session-supervision/controller-store.js

@@ -0,0 +1,48 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export const conversationKey = ({ hostId = 'local', provider, session }) => JSON.stringify([hostId, provider, session]);
+export const controllerScope = status => status?.auth?.userId && status?.access?.organizationId
+  ? JSON.stringify([status.auth.userId, status.access.organizationId]) : null;
+const digest = value => createHash('sha256').update(value).digest('hex');
+
+// User preferences belong to the controlling device, never to an SSH target.
+// Each account/organization has a separate file. All mutations serialize and
+// publish only after an atomic durable write; failed writes preserve memory.
+export function createControllerStore(root) {
+  let queue = Promise.resolve();
+  const states = new Map();
+  const file = scope => join(root, 'controller', `${digest(scope)}.json`);
+  async function load(scope) {
+    if (!scope) throw new Error('Controller identity unavailable.');
+    if (states.has(scope)) return states.get(scope);
+    let state;
+    try { state = JSON.parse(await readFile(file(scope), 'utf8')); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; state = { version: 1, conversations: {}, events: {} }; }
+    if (state.version !== 1 || !state.conversations || !state.events) throw new Error('Invalid controller settings.');
+    states.set(scope, state); return state;
+  }
+  function change(scope, mutate) {
+    const work = queue.catch(() => {}).then(async () => {
+      const next = structuredClone(await load(scope));
+      const result = await mutate(next);
+      await mkdir(join(root, 'controller'), { recursive: true, mode: 0o700 });
+      const path = file(scope), temp = `${path}.${randomUUID()}.tmp`;
+      try { await writeFile(temp, JSON.stringify(next) + '\n', { mode: 0o600 }); await rename(temp, path); }
+      finally { await rm(temp, { force: true }); }
+      states.set(scope, next); return result;
+    });
+    queue = work; return work;
+  }
+  return { load, change, peek: scope => states.get(scope),
+    get(scope, target) { return states.get(scope)?.conversations[conversationKey(target)] || {}; },
+    async set(scope, target, values) {
+      return change(scope, state => { const key = conversationKey(target); state.conversations[key] = { ...state.conversations[key], ...values }; });
+    },
+    async event(scope, id) {
+      return change(scope, state => { if (state.events[id]) return false; state.events[id] = Date.now(); return true; });
+    },
+    async close() { await queue.catch(() => {}); },
+  };
+}

package/src/session-supervision/conversation-presentation.js

@@ -0,0 +1,241 @@
+import { sessionWorkState, sessionWorkOwnership } from './work-state.js';
+import { deliveryDecisionRevision } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { pauseOrigin } from './autonomous-upgrade.js';
+import { continuationAnalysisRevision } from './analysis-manager.js';
+import { CONTINUATION_ANALYSIS_VERSION, CONTINUATION_ANALYSIS_STATES } from './continuation-analysis.js';
+
+const text = (value, max = 600) => typeof value === 'string' && value.trim() ? value.slice(0, max) : null;
+const identifier = (value, max = 256) => typeof value === 'string' && value.trim() && value.length <= max ? value : null;
+const count = value => Number.isSafeInteger(value) && value >= 0 ? value : null;
+const time = value => Number.isFinite(value) && value >= 0 ? value : null;
+const object = value => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+const source = (value, path, max) => text(value, max) === null ? null : { text: text(value, max), source: path, truncated: value.length > (max || 600) };
+const action = (id, label) => ({ id, label });
+const detailHost = row => {
+  const remote = row.remoteHost != null || row.teamRemote === true;
+  const host = identifier(row.hostId);
+  if (host && !/[\u0000-\u001f\u007f]/.test(host) && (host !== 'local' || !remote)) return host;
+  return row.hostId == null && !remote ? 'local' : null;
+};
+
+const RECOVERY = {
+  update_recovery_required: ['The last update didn\'t finish', 'open_update_recovery', 'Open update recovery'],
+  writer_reconnect_required: ['This conversation needs to reconnect', 'open_original', 'Send one message in the original conversation'],
+  dispatch_history_quarantined: ['Earlier unconfirmed work was set aside', 'open_original', 'Open original conversation'],
+  task_admission_blocked: ['Fresh provider permissions are required', 'open_original', 'Continue once in the original conversation'],
+};
+
+function currentAnalysisPlan(candidate, fresh, now) {
+  const analysis = object(candidate.analysis), steps = analysis.outcomePlan?.steps;
+  if (fresh && CONTINUATION_ANALYSIS_STATES.includes(analysis.state) && analysis.analysisVersion === CONTINUATION_ANALYSIS_VERSION &&
+        analysis.revision === continuationAnalysisRevision(candidate) && !analysis.previousAnalysis && analysis.awaitingTurn === false &&
+        Number.isFinite(analysis.analyzedAt) && analysis.analyzedAt > 0 && analysis.analyzedAt <= now &&
+        analysis.stale !== true && analysis.fetchFailed !== true && Array.isArray(steps) && steps.length > 0 && steps.length <= 12 &&
+        steps.every(step => identifier(step?.id, 60) && text(step.title) && ['planned', 'current', 'reported'].includes(step.state)) &&
+        new Set(steps.map(step => step.id)).size === steps.length) {
+    const current = steps.map((step, index) => ({ step, index })).filter(({ step }) => step.state === 'current');
+    if (analysis.state === 'continue' ? current.length === 1 : current.length === 0) return { current: current[0] ?? null, steps };
+  }
+  return null;
+}
+
+// Additive, read-only native presentation. Actions are identifiers for existing
+// routes, never grants of permission, executable commands or provider receipts.
+export function conversationPresentation(candidate = {}, projectedRun, { rawRecord, now = Date.now() } = {}) {
+  const identity = { provider: identifier(candidate.provider, 32), session: identifier(candidate.session), hostId: detailHost(candidate) };
+  const projected = object(projectedRun);
+  // Unknown remote or malformed host provenance must never borrow a local run.
+  const matches = row => row && identity.hostId !== null && row.provider === candidate.provider && row.session === candidate.session &&
+    detailHost(row) === identity.hostId;
+  const view = matches(projected) ? projected : {};
+  const raw = matches(rawRecord) ? object(rawRecord.run) : {};
+  const rawRevision = deliveryDecisionRevision(raw);
+  // Do not join context from an earlier task/revision into a newer status frame.
+  const sameRaw = !view.runId || raw.id === view.runId &&
+    (!view.taskId || raw.managed?.taskId === view.taskId) &&
+    (view.revision === undefined || view.revision === rawRevision);
+  const recordRun = sameRaw ? raw : {};
+  const managed = object(recordRun.managed);
+  const field = name => view[name] ?? recordRun[name] ?? managed[name];
+  const ref = name => view[name] != null ? `run.${name}` : recordRun[name] != null ? `record.run.${name}` : `record.run.managed.${name}`;
+  const run = { ...recordRun, ...view, ...(Object.keys(managed).length ? { managed } : {}) };
+  const work = candidate.workState || sessionWorkState(candidate, run, { now });
+  const ownership = work.ownership || sessionWorkOwnership(work, candidate, run).ownership;
+  const target = { ...identity, runId: identifier(view.runId ?? recordRun.id),
+    taskId: identifier(view.taskId ?? managed.taskId), revision: count(view.revision ?? rawRevision) };
+  const reason = source(candidate.autoContinueReason, 'candidate.autoContinueReason') || source(field('reason'), ref('reason'));
+  const failures = count(field('failures'));
+  const maxFailures = count(field('maxFailures'));
+  const pause = pauseOrigin(run);
+  const stopCode = text(view.stopCode ?? recordRun.stopReason?.code, 64);
+  const executionObserved = work.state === 'running' && !work.stale && !work.fetchFailed;
+  const readiness = (state, tone, line, nextAction = null) => ({ state, tone, text: line, action: nextAction,
+    reason, source: 'derived', savedOn: candidate.autoContinue === true, providerExecutionConfirmed: executionObserved });
+  let ready;
+  let recovery = null;
+  const blocker = object(candidate.dispatchReadiness);
+  const state = field('state');
+  const stopped = state === 'stopped' || state === 'paused' && pause === 'user' || work.state === 'stopped';
+  const terminal = ['completed', 'reported_done'].includes(state) || ['completed', 'idle', 'archived'].includes(work.state);
+  const control = candidate.provider === 'codex' &&
+    (view.capability === 'codex_app_server' || managed.resumeChannel === 'codex_app_server');
+  const pendingDecision = ['approval', 'question'].includes(work.state) || field('pendingApproval') && !field('pendingApproval').denied ||
+    field('understandingQuestion') || managed.userQuestion;
+  if (candidate.autoContinueStatus === 'save_failed') {
+    ready = readiness('save_failed', 'danger', reason?.text || 'Could not save Auto Continue. Retry.');
+  } else if (candidate.autoContinueStatus === 'saving') {
+    ready = readiness('saving', 'accent', 'Saving On…');
+  } else if (candidate.autoContinue !== true) {
+    ready = readiness('off', 'secondary', "Off. SIMY watches but doesn't send.");
+  } else if (blocker.state === 'blocked' && !terminal) {
+    const code = text(blocker.code, 64) || 'unknown';
+    const [title, id, label] = RECOVERY[code] || ['SIMY cannot send work yet', 'open_original', 'Open original conversation'];
+    const detail = source(blocker.reason, 'candidate.dispatchReadiness.reason') || reason;
+    recovery = { code, title, reason: detail, action: action(id, label),
+      preservation: 'Your goal, history and failure budget are kept.', resendAllowed: false };
+    ready = readiness('blocked', 'attention', `Can't send yet: ${detail?.text || title}`, recovery.action);
+  } else if (stopCode === 'failure_limit' || maxFailures !== null && maxFailures > 0 && failures !== null && failures >= maxFailures) {
+    ready = readiness('budget_exhausted', 'danger', failures === null ? reason?.text || 'Stopped after repeated failed attempts.' : `Stopped after ${failures} failed attempts.`, action('open_original', 'Open original conversation'));
+  } else if (state === 'budget_exhausted' || stopCode === 'purpose_budget') {
+    ready = readiness('budget_exhausted', 'danger', reason?.text || 'The original continuation budget is exhausted.', action('open_original', 'Open original conversation'));
+  } else if (stopped) {
+    ready = readiness('paused_user', 'secondary', field('canResume') === false ? 'Paused by you. Resume is unavailable; check the original conversation.' : 'Paused by you. Resume to continue.',
+      field('canResume') === false ? action('open_original', 'Open original conversation') : action('delivery_resume', 'Resume'));
+  } else if (state === 'paused' && (pause === 'system' || ['no_progress_time', 'no_progress_attempts'].includes(stopCode))) {
+    const minutes = count(view.progressBudget?.minutes ?? managed.maxNoProgressMinutes);
+    ready = readiness('paused_rule', 'attention', `${minutes !== null && stopCode !== 'no_progress_attempts' ? `Paused: no progress for ${minutes} min.` : reason?.text || 'Paused by a progress rule.'} ${field('canResume') === false ? 'Resume is unavailable; check the original conversation.' : 'Resume restarts the progress window; failures are kept.'}`,
+      field('canResume') === false ? action('open_original', 'Open original conversation') : action('delivery_resume', 'Resume'));
+  } else if (work.state === 'running' && !work.stale && !work.fetchFailed) {
+    ready = { ...readiness('provider_running', 'secondary', 'Waiting for the current turn to finish'), providerExecutionConfirmed: true };
+  } else if (pendingDecision) {
+    ready = readiness('decision_required', 'attention', work.state === 'approval' ? 'Waiting for your approval' : 'Waiting for your answer', action('review_decision', 'Review decision'));
+  } else if (work.state === 'family_unfinished') {
+    ready = readiness('family_unfinished', ownership === 'needs_you' ? 'attention' : 'secondary', 'Related conversations have unfinished work.', action('review_children', 'Review related conversations'));
+  } else if (state === 'verification_pending' && ownership === 'needs_you') {
+    ready = readiness('acceptance_required', 'attention', 'Waiting for your check', action('review_result', 'Check result'));
+  } else if (terminal) {
+    ready = readiness('finished', 'secondary', state === 'reported_done' ? 'The AI reported completion; verification is pending.' : 'No current work to continue.');
+  } else if (candidate.provider === 'claude' && candidate.isRunning === false && !['starting', 'recovering'].includes(candidate.autoContinueStatus)) {
+    ready = readiness('original_turn_required', 'attention', 'Send one message in the original conversation. Auto Continue waits for its next verified hook.', action('open_original', 'Open original conversation'));
+  } else if (control && candidate.autoContinueStatus === 'supervising' && ['active', 'verification_pending'].includes(state) &&
+      ownership === 'simy_continues' && blocker.state === 'ready' &&
+      !field('executionUncertain') && !field('providerWarning') && !managed.nativeWait && !managed.purpose?.nativeBoundary) {
+    ready = readiness('ready', 'accent', 'Will continue after this turn');
+  } else if (['starting', 'recovering'].includes(candidate.autoContinueStatus)) {
+    ready = readiness(candidate.autoContinueStatus, 'accent', reason?.text || 'Checking Auto Continue readiness.');
+  } else {
+    ready = readiness('waiting', 'secondary', reason?.text || 'Checking whether the next step can be sent.', action('refresh', 'Refresh status'));
+  }
+
+  const nextValue = field('nextStep');
+  const checkpoint = object(view.reportedCheckpoint ?? recordRun.checkpoint);
+  const pendingManual = Array.isArray(view.pendingAcceptance) ? view.pendingAcceptance : [];
+  const manualIndex = pendingManual.findIndex(item => item?.check === 'manual');
+  const criteria = Array.isArray(managed.acceptanceCriteria) ? managed.acceptanceCriteria : [];
+  const rawManualIndex = criteria.findIndex(item => item?.check?.type === 'manual' && !Object.hasOwn(managed.verified || {}, item.id));
+  const manual = manualIndex >= 0 ? source(pendingManual[manualIndex].description, `run.pendingAcceptance[${manualIndex}].description`) :
+    rawManualIndex >= 0 ? source(criteria[rawManualIndex].description, `record.run.managed.acceptanceCriteria[${rawManualIndex}].description`) : null;
+  const decision = source(candidate.decisionRequest?.question, 'candidate.decisionRequest.question') ||
+    source(field('pendingApproval')?.summary, `${ref('pendingApproval')}.summary`) ||
+    source(field('understandingQuestion')?.text, `${ref('understandingQuestion')}.text`) ||
+    source(managed.userQuestion?.text, 'record.run.managed.userQuestion.text');
+  const next = work.state === 'family_unfinished' ? source(work.reason, 'candidate.workState.reason') :
+    ready.state === 'acceptance_required' ? manual : pendingDecision ? decision :
+      source(nextValue, ref('nextStep'), 600) || source(checkpoint.nextStep, view.reportedCheckpoint ? 'run.reportedCheckpoint.nextStep' : 'record.run.checkpoint.nextStep', 600);
+  const userAction = ready.action && ['blocked', 'paused_user', 'paused_rule', 'budget_exhausted', 'original_turn_required', 'decision_required', 'acceptance_required'].includes(ready.state) ||
+    ready.state === 'family_unfinished' && ownership === 'needs_you';
+  const nextOwner = userAction ? 'you' : ready.state === 'ready' || ['starting', 'recovering'].includes(ready.state) ? 'simy' :
+    ready.state === 'provider_running' ? 'ai' : 'unknown';
+  // Supporting copy never supplies execution authority or invents a plan.
+  // Older/in-flight analyses and unbound decision presentations stay absent.
+  let nextDetail = null;
+  let nextCopy;
+  const knownHost = detailHost(candidate);
+  const detailFresh = knownHost !== null &&
+    work.stale !== true && work.fetchFailed !== true && !['unknown', 'family_unfinished'].includes(work.state);
+  const analysis = object(candidate.analysis);
+  const currentPlan = currentAnalysisPlan(candidate, detailFresh, now);
+  const plan = { current: currentPlan !== null, currentStepId: currentPlan?.current?.step.id ?? null,
+    source: 'candidate.analysis.outcomePlan', analysisRevision: identifier(analysis.revision),
+    analysisVersion: count(analysis.analysisVersion), analyzedAt: time(analysis.analyzedAt), analysisState: text(analysis.state, 32) };
+  if (detailFresh && pendingDecision && next?.source === 'candidate.decisionRequest.question') {
+    const request = object(candidate.decisionRequest);
+    const bindings = [request, object(request.fields), object(request.target), object(request.answerFields),
+      ...(Array.isArray(request.choices) ? request.choices.map(choice => object(choice?.fields)) : [])];
+    const pending = request.kind === 'approval' ? object(field('pendingApproval')) : request.kind === 'question' ? object(field('understandingQuestion') ?? managed.userQuestion) : {};
+    const bound = bindings.filter(binding => binding.provider === identity.provider && binding.session === identity.session &&
+      detailHost(binding) === knownHost && target.runId && target.taskId && target.revision !== null &&
+      binding.expectedRunId === target.runId && binding.taskId === target.taskId && binding.expectedRevision === target.revision && pending.id &&
+      binding[request.kind === 'approval' ? 'approvalId' : 'questionId'] === pending.id);
+    if (bound.length && request.stale !== true && request.fetchFailed !== true) {
+      // Reuse the typed decision's literal locale copy only after its existing
+      // host/run/task/revision/proposal fence. Never translate provider text.
+      const localized = Object.fromEntries(['ja', 'en'].flatMap(locale => {
+        const question = source(request.copy?.[locale]?.question, 'candidate.decisionRequest.copy');
+        return question ? [[locale, { text: question.text }]] : [];
+      }));
+      if (Object.keys(localized).length) nextCopy = localized;
+      nextDetail = source(request.reason, 'candidate.decisionRequest.reason') || source(request.explanation, 'candidate.decisionRequest.explanation');
+      const approval = object(field('pendingApproval'));
+      if (!nextDetail && approval.id && bound.some(binding => binding.approvalId === approval.id)) {
+        nextDetail = source(approval.reason, `${ref('pendingApproval')}.reason`);
+        const assessment = object(field('decision'));
+        if (!nextDetail && assessment.id === approval.id && ['kind', 'scope', 'summary'].every(key =>
+          typeof approval[key] === 'string' && assessment.action?.[key] === approval[key])) nextDetail = source(assessment.reason, `${ref('decision')}.reason`);
+      }
+      if (nextDetail) nextDetail = { kind: 'decision_reason', ...nextDetail };
+    }
+  } else if (detailFresh && !pendingDecision && ready.state !== 'acceptance_required' && next?.text) {
+    if (analysis.state === 'continue' && currentPlan?.current && currentPlan.current.step.title === analysis.nextAction && analysis.nextAction === next.text) {
+      const stepIndex = currentPlan.current.index + 1, stepCount = currentPlan.steps.length;
+      nextDetail = { kind: 'plan_position', text: `Step ${stepIndex} of ${stepCount} in this plan.`,
+        source: 'candidate.analysis.outcomePlan.steps', truncated: false, stepIndex, stepCount };
+    }
+  }
+  const history = Array.isArray(view.reportedWork) ? view.reportedWork : [];
+  const rawHistory = Array.isArray(managed.workHistory) ? managed.workHistory : [];
+  const lastRaw = rawHistory.findLast(item => ['in_progress', 'completed'].includes(item?.status) && item.result?.status === 'observed');
+  const checkpointSource = Object.keys(checkpoint).length ? view.reportedCheckpoint ? 'run.reportedCheckpoint.summary' : 'record.run.checkpoint.summary' : null;
+  const last = source(checkpoint.summary, checkpointSource) || source(history.at(-1), `run.reportedWork[${history.length - 1}]`) ||
+    source(lastRaw?.result?.summary || lastRaw?.summary, 'record.run.managed.workHistory');
+  return { schemaVersion: 1, target,
+    readiness: ready, recovery, plan,
+    now: { state: text(work.state, 64), ownership, label: text(work.label, 200),
+      reason: source(work.reason, 'candidate.workState.reason'), stale: work.stale === true, checkedAt: time(work.checkedAt), ownershipObservedAt: time(work.ownershipObservedAt), providerExecutionConfirmed: executionObserved },
+    next: { ...(next || { text: null, source: null, truncated: false }), ...(nextCopy ? { copy: nextCopy } : {}), owner: nextOwner,
+      executable: ready.state === 'ready' && Boolean(next), action: ready.action, detail: nextDetail },
+    last: { ...(last || { text: null, source: null, truncated: false }), reportedBy: last ? 'ai' : null,
+      verified: false, status: text(checkpoint.status ?? lastRaw?.status, 32), label: last ? 'Reported by AI · not verified' : null,
+      at: last ? time(view.checkpointAt ?? recordRun.checkpoint?.at ?? lastRaw?.at) : null },
+    pause: { origin: stopped ? 'user' : state === 'paused' ? pause : null, stopCode, failures, maxFailures,
+      progressMinutes: count(view.progressBudget?.minutes ?? managed.maxNoProgressMinutes) } };
+}
+
+// Cached heartbeats may outlive the fresh observation they originally carried.
+// Expire only the live claim; retain bounded last/next context and provenance.
+export function expireConversationPresentation(candidate) {
+  let previous = candidate.conversationPresentation;
+  const work = candidate.workState;
+  if ((previous?.next?.detail || previous?.next?.copy || previous?.plan?.current) && (!work || work.stale === true || work.fetchFailed === true || ['unknown', 'family_unfinished'].includes(work.state))) {
+    const next = { ...previous.next, detail: null };
+    delete next.copy;
+    previous = { ...previous, next,
+      ...(previous.plan ? { plan: { ...previous.plan, current: false, currentStepId: null } } : {}) };
+    candidate = { ...candidate, conversationPresentation: previous };
+  }
+  if (previous && work?.state === 'family_unfinished' &&
+      (previous.now.ownership !== work.ownership || previous.now.stale !== (work.stale === true))) {
+    return { ...candidate, conversationPresentation: { ...previous,
+      readiness: { ...previous.readiness, tone: work.ownership === 'needs_you' ? 'attention' : 'secondary', providerExecutionConfirmed: false },
+      now: { ...previous.now, ownership: work.ownership, stale: work.stale === true,
+        ownershipObservedAt: time(work.ownershipObservedAt), providerExecutionConfirmed: false },
+      next: { ...previous.next, owner: work.ownership === 'needs_you' ? 'you' : 'unknown', executable: false } } };
+  }
+  if (!previous || previous.readiness.state !== 'provider_running' || candidate.workState?.state === 'running' && !candidate.workState.stale) return candidate;
+  return { ...candidate, conversationPresentation: { ...previous,
+    readiness: { ...previous.readiness, state: 'waiting', tone: 'secondary', text: 'Checking whether the next step can be sent.',
+      providerExecutionConfirmed: false, action: action('refresh', 'Refresh status') },
+    now: { ...previous.now, state: candidate.workState?.state || 'unknown', ownership: candidate.workState?.ownership || 'waiting',
+      reason: source(candidate.workState?.reason, 'candidate.workState.reason'), stale: true, providerExecutionConfirmed: false },
+    next: { ...previous.next, owner: 'unknown', executable: false } } };
+}

package/src/session-supervision/decision-presentation.js

@@ -1,54 +1,115 @@
 const clean = value => typeof value === 'string' ? value.trim().slice(0, 2000) : '';
+const pair = (ja, en) => ({ ja, en });
+const sameAction = (a, b) => ['kind', 'scope', 'summary'].every(key => typeof a?.[key] === 'string' && a[key] === b?.[key]);
+
+// Only structured, exact-action evidence describes irreversibility. A summary
+// containing "delete" is not a risk assessment, and another action's assessment
+// must never colour the pending proposal or alter its authorization boundary.
+export function approvalEffect(approval, decision) {
+  const assessment = decision?.id === approval?.id && sameAction(approval, decision.action) ? decision.assessment : null;
+  if (approval?.kind === 'destructive' || assessment?.reversibility === 'irreversible') return 'irreversible';
+  if (assessment?.reversibility === 'reversible') return 'reversible';
+  return 'unknown';
+}
+
+// Typed copy is additive for older hosts. Locale changes select these fields;
+// they never translate arbitrary provider text or change a command payload.
+function text(record, copy) {
+  const localized = { ja: {}, en: {} };
+  for (const [key, values] of Object.entries(copy)) {
+    record[key] = values.ja;
+    localized.ja[key] = values.ja; localized.en[key] = values.en;
+  }
+  return { ...record, copy: localized };
+}
 
 // The presentation never invents consent or executes a choice. Commands still
 // validate the exact live proposal, question, run identity and revision.
 export function sessionDecisionPresentation(candidate, run) {
-  if (!candidate || candidate.isRunning || candidate.archived) return null;
+  if (!candidate || candidate.archived) return null;
   const identity = { provider: candidate.provider, session: candidate.session };
   const control = { ...identity, ...(run?.taskId ? { taskId: run.taskId } : {}),
     ...(run?.runId ? { expectedRunId: run.runId, expectedRevision: run.revision } : {}) };
-  const choice = (label, effect, action, fields = {}) => ({ label, effect, action, fields: { ...control, ...fields } });
+  const choice = (label, effect, action, fields = {}, role = 'secondary') => text({ action, role, fields: { ...control, ...fields } }, { label, effect });
+  const model = (kind, copy, fields = {}, presentation = 'decision') => text({ kind, presentation, ...fields }, copy);
   const frozen = typeof run?.runId === 'string' && run.runId.length > 0 && Number.isSafeInteger(run.revision) && run.revision >= 0;
-  const refreshDecision = () => ({ kind: 'unresolved', title: '判断の状態を再確認します',
-    question: '現在の作業と判断の対応を確認できません。最新の状態を取得してから選んでください。',
-    context: 'この確認だけでは操作を許可したり、作業を再開したりしません。',
-    choices: [choice('状況を再確認する', '最新の状態を取得します。許可・停止状態は変更しません。', 'refresh', identity)] });
+  const refreshDecision = () => model('unresolved', {
+    title: pair('判断の状態を再確認します', 'Refresh the decision state'),
+    question: pair('現在の作業と判断の対応を確認できません。最新の状態を取得してから選んでください。', 'This decision cannot be matched to the current work. Refresh before choosing.'),
+    context: pair('この確認だけでは操作を許可したり、作業を再開したりしません。', 'Refreshing does not grant permission or resume work.'),
+  }, { choices: [choice(pair('状況を再確認する', 'Refresh status'), pair('最新の状態を取得します。許可・停止状態は変更しません。', 'Get the latest state without changing permissions or stops.'), 'refresh', identity)] }, 'helper');
+  if (run?.state === 'blocked' && run.providerRequest?.source === 'provider_hook') return model('unresolved', {
+    title: run.providerRequest.kind === 'question'
+      ? pair('元のAIが回答を待っています', 'The original AI is waiting for an answer')
+      : pair('元のAIが権限の確認を待っています', 'The original AI is waiting for a permission decision'),
+    question: pair('元の会話で現在の要求を確認してください。', 'Check the current request in the original conversation.'),
+    context: pair('この画面ではproviderの権限要求を代わりに承認しません。', 'This screen does not approve provider permission requests.'),
+  }, { choices: [choice(pair('元の会話を開く', 'Open original conversation ↗'), pair('現在の要求を元のAIで確認します。', 'Check the current request in the original AI conversation.'), 'open_original')] }, 'helper');
   const approval = run?.pendingApproval;
   if (approval?.id && clean(approval.summary) && !approval.denied && run.canApprove && !frozen) return refreshDecision();
-  if (approval?.id && clean(approval.summary) && !approval.denied && run.canApprove) return {
-    kind: 'approval', title: 'この操作を許可しますか？',
-    question: `実行する操作：${clean(approval.summary)}`, context: `対象：${({ task: 'この依頼の範囲', repository: 'この作業のリポジトリ' })[approval.scope] || clean(approval.scope) || '依頼された操作の範囲'}`,
-    choices: [choice('この操作だけを許可', '表示された対象・操作だけを許可します。AI側で権限確認が必要な場合は別途案内します。', 'delivery_approve', { approvalId: approval.id }),
-      choice('許可しない', run.canReplan ? 'この操作は実行しません。別の方法を調べる場合は「AIに状況確認を任せる」を選んでください。' : 'この操作は実行しません。別の方法が必要な場合は、元のAI会話で確認してください。', 'delivery_reject', { approvalId: approval.id })],
-  };
+  // A separate AI turn may still be running while this exact managed proposal
+  // waits for consent. Only execution/resume choices are suppressed by that turn.
+  if (approval?.id && clean(approval.summary) && !approval.denied && run.canApprove) {
+    const effect = approvalEffect(approval, run.decision);
+    const scope = ({ task: pair('この依頼の範囲', 'this task'), repository: pair('リポジトリ', 'repository') })[approval.scope]
+      || pair(clean(approval.scope) || '依頼された操作の範囲', clean(approval.scope) || 'the requested operation');
+    const effectCopy = ({ irreversible: pair('元に戻せません', 'irreversible'), reversible: pair('元に戻せます', 'reversible'), unknown: pair('復元可能性は未確認', 'reversibility not established') })[effect];
+    const why = clean(approval.reason) || (run.decision?.id === approval.id && sameAction(approval, run.decision?.action) ? clean(run.decision.reason) : '');
+    return model('approval', {
+      title: pair(`承認：${clean(approval.summary)}`, `Approve: ${clean(approval.summary)}`),
+      question: pair(`実行する操作：${clean(approval.summary)}`, `Operation: ${clean(approval.summary)}`),
+      scope: pair(`対象：${scope.ja} · 効果：${effectCopy.ja}`, `Scope: ${scope.en} · Effect: ${effectCopy.en}`),
+      context: pair(why ? `理由：${why}` : '表示された対象・操作だけを許可します。', why ? `Why: ${why}` : 'Permission applies only to the displayed operation and scope.'),
+    }, { effect, choices: [
+      choice(pair('この操作だけを許可', 'Approve'), pair('表示された対象・操作だけを許可します。AI側で権限確認が必要な場合は別途案内します。', 'Allow only this operation and scope. Any provider permission is handled separately.'), 'delivery_approve', { approvalId: approval.id }, effect === 'irreversible' ? 'destructive' : effect === 'reversible' ? 'primary' : 'secondary'),
+      choice(pair('許可しない', 'Do not approve'), pair(run.canReplan ? 'この操作は実行しません。別の方法を調べる場合は「AIに状況確認を任せる」を選んでください。' : 'この操作は実行しません。別の方法が必要な場合は、元のAI会話で確認してください。', run.canReplan ? 'Reject this operation. Ask AI to investigate if you need another approach.' : 'Reject this operation. Discuss another approach in the original conversation.'), 'delivery_reject', { approvalId: approval.id }),
+      choice(pair('元の会話を開く', 'Open original conversation ↗'), pair('会話を開くだけでは承認や再開をしません。', 'Opening the conversation does not approve or resume work.'), 'open_original', {}, 'link'),
+    ] });
+  }
   const question = run?.understandingQuestion;
   if (run?.canAnswer && question?.id && clean(question.text) && !frozen) return refreshDecision();
-  if (run?.canAnswer && question?.id && clean(question.text)) return {
-    kind: 'question', title: '続けるために、この点を教えてください', question: clean(question.text),
-    context: '回答を受け取ってから目的を確認し、許可された作業を続けます。',
-    answerFields: { ...control, taskId: run.taskId, questionId: question.id },
-    choices: [],
-  };
-  if (run?.dependencyWait || run?.autoRecovery && ['recovery_required', 'auto_resuming'].includes(run.state) ||
+  if (run?.canAnswer && question?.id && clean(question.text)) return model('question', {
+    title: pair('続けるために、この点を教えてください', 'Answer to continue'), question: pair(clean(question.text), clean(question.text)),
+    context: pair('回答を受け取ってから目的を確認し、許可された作業を続けます。', 'After your answer, AI checks the goal and continues within the existing permissions.'),
+  }, { answerFields: { ...control, taskId: run.taskId, questionId: question.id }, choices: [] });
+  if (candidate.isRunning || run?.dependencyWait || run?.autoRecovery && ['recovery_required', 'auto_resuming'].includes(run.state) ||
       ['supervising', 'watching', 'waiting', 'starting', 'recovering'].includes(candidate.autoContinueStatus)) return null;
-  if (run && ['recovery_required', 'paused', 'failed', 'blocked'].includes(run.state)) {
+  if (run && (['recovery_required', 'paused', 'failed', 'blocked'].includes(run.state) || run.state === 'verification_pending' && run.canResume)) {
+    const acceptancePending = run.state === 'verification_pending';
     const providerName = candidate.provider === 'claude' ? 'Claude' : candidate.provider === 'codex' ? 'Codex' : 'AI';
-    const context = run.state === 'paused' ? 'この作業は停止中です。停止の指示は自動で解除しません。' : ({ session_end: `元の${providerName}会話が終了し、自動継続が止まっています。`,
-      process_exit: '元のAIが終了したため、自動継続できていません。', provider_error: 'AIの実行でエラーが発生し、作業が止まっています。',
-      shutdown_cancelled: 'SIMYの終了時に作業が中断されました。', hook_owner_mismatch: '元のAI会話の接続が変わりました。' })[run.recoveryCause]
-      || '作業を続けるための条件を確認できていません。';
+    const reasons = {
+      session_end: pair(`元の${providerName}会話が終了し、自動継続が止まっています。`, `The original ${providerName} session ended, stopping Auto Continue.`),
+      process_exit: pair('元のAIが終了したため、自動継続できていません。', 'The original AI process exited. Auto Continue cannot proceed.'),
+      provider_error: pair('AIの実行でエラーが発生し、作業が止まっています。', 'An AI execution error stopped the work.'),
+      shutdown_cancelled: pair('SIMYの終了時に作業が中断されました。', 'Work was interrupted when SIMY exited.'),
+      hook_owner_mismatch: pair('元のAI会話の接続が変わりました。', 'The connection to the original AI session changed.'),
+    };
+    const reason = acceptancePending ? pair('最終確認は未完了ですが、許可済みの残作業を続けられます。再開しても検証済みにはなりません。', 'Acceptance is still pending. Authorized remaining work can continue without marking the result verified.')
+      : run.state === 'paused' ? pair('この作業は停止中です。停止の指示は自動で解除しません。', 'This work is paused. A stop instruction is never cleared automatically.')
+      : reasons[run.recoveryCause] || pair('作業を続けるための条件を確認できていません。', 'The conditions for continuing have not been established.');
     const choices = [];
-    if (run.canReplan && frozen) choices.push(choice('AIに状況確認を任せる', '目的・履歴・制限を維持して原因と安全な次の手順を調べます。操作の許可を追加することはありません。', 'delivery_replan'));
-    if (run.canResume && frozen) choices.push(choice('再開を依頼する', '保存した目的と履歴を引き継ぎます。接続や権限が不足する場合は、その内容を案内します。', 'delivery_resume'));
-    choices.push(choice(`元の${candidate.provider === 'claude' ? 'Claude' : 'Codex'}会話を開く`, '接続や権限の確認が必要な場合、元のAI会話で確認できます。会話を開くだけでは作業を再開しません。', 'open_original'));
-    if (candidate.autoContinue === true) choices.push(choice('自動継続をオフにする', '今後の自動継続をオフにします。作業の履歴は残ります。', 'session_set_auto_continue', { ...identity, enabled: false }));
-    return { kind: 'recovery', title: '作業が止まっています。対応を選んでください', question: frozen && (run.canReplan || run.canResume) ? (run.canReplan ? '選ぶこと：AIに状況確認を任せるか、元の会話を確認するか。' : '選ぶこと：再開を依頼するか、元の会話を確認するか。') : 'この画面からの再開には対応していません。元のAI会話で状態を確認できます。', context: `理由：${context}`, choices };
+    if (run.canReplan && frozen) choices.push(choice(pair('AIに状況確認を任せる', 'Ask AI to investigate'), pair('目的・履歴・制限を維持して原因と安全な次の手順を調べます。操作の許可を追加することはありません。', 'Investigate the cause and next steps while keeping the goal, history and limits. No new permission is granted.'), 'delivery_replan', {}, 'primary'));
+    if (run.canResume && frozen) choices.push(choice(pair(acceptancePending ? '未完了の作業を続ける' : '再開を依頼する', acceptancePending ? 'Continue remaining work' : 'Request resume'), pair(acceptancePending ? '元の目的・履歴・制限を維持して残作業を確認します。最終確認を済ませたことにはしません。' : '保存した目的と履歴を引き継ぎます。接続や権限が不足する場合は、その内容を案内します。', acceptancePending ? 'Keep the goal, history and limits while checking what remains. This does not accept the result.' : 'Keep the saved goal and history. Any missing connection or permission will be shown.'), 'delivery_resume', {}, choices.length ? 'secondary' : 'primary'));
+    choices.push(choice(pair(`元の${providerName}会話を開く`, 'Open original conversation ↗'), pair('接続や権限の確認が必要な場合、元のAI会話で確認できます。会話を開くだけでは作業を再開しません。', 'Check the original conversation. Opening it does not resume work.'), 'open_original', {}, 'link'));
+    if (candidate.autoContinue === true) choices.push(choice(pair('自動継続をオフにする', 'Turn off Auto Continue'), pair('今後の自動継続をオフにします。作業の履歴は残ります。', 'Turn off future automatic continuation and retain the history.'), 'session_set_auto_continue', { ...identity, enabled: false }));
+    const actionable = frozen && (run.canReplan || run.canResume);
+    return model('recovery', {
+      title: pair(acceptancePending ? '最終確認を待ちながら、残作業を続けられます' : '作業が止まっています。対応を選んでください', acceptancePending ? 'Continue work while acceptance is pending' : 'Work stopped. Choose how to proceed'),
+      question: pair(actionable ? run.canReplan ? '選ぶこと：AIに状況確認を任せるか、元の会話を確認するか。' : '選ぶこと：再開を依頼するか、元の会話を確認するか。' : 'この画面からの再開には対応していません。元のAI会話で状態を確認できます。', actionable ? 'Choose a recovery action or check the original conversation.' : 'This screen cannot resume the work. Check the original conversation.'),
+      context: pair(`理由：${reason.ja}`, `Reason: ${reason.en}`),
+    }, { choices }, !acceptancePending && actionable ? 'decision' : 'helper');
   }
-  if (candidate.autoContinueStatus === 'needs_user' || candidate.analysis?.state === 'needs_user') return {
-    kind: 'unresolved', title: '必要な判断内容を確認します',
-    question: '判断していただく内容をまだ特定できていません。具体的な内容が分かるまで、操作の許可は求めません。',
-    context: 'まず会話と最新の状態を確認します。元のAIが権限の確認を求めている場合は、その会話で確認が必要です。',
-    choices: [choice('状況を再確認する', '最新の状態を取得します。許可・停止状態は変更しません。', 'refresh', identity)],
-  };
+  if (candidate.autoContinue === false && candidate.analysis?.state === 'continue' &&
+      candidate.capabilities?.canAutoContinue === true && candidate.autoContinueAvailability?.canEnable !== false) return model('continue', {
+    title: pair('続けますか？', 'Continue?'),
+    question: pair(clean(candidate.analysis.reason) || '許可済みの残作業があります。', clean(candidate.analysis.reason) || 'Authorized work remains.'),
+    context: pair('自動継続はオフです。オンにすると、元の目的と権限の範囲で残作業を確認します。結果を受け入れる操作ではありません。', 'Auto Continue is off. Turning it on checks remaining work within the original goal and permissions. It does not accept the result.'),
+  }, { choices: [choice(pair('自動継続をオンにする', 'Turn on Auto Continue'), pair('自動継続の設定を保存します。作業の開始や完了を証明するものではありません。', 'Save consent for Auto Continue. This does not confirm that work started or finished.'), 'session_set_auto_continue', { ...identity, enabled: true }, 'primary'),
+    choice(pair('元の会話を開く', 'Open original conversation ↗'), pair('会話を開くだけでは作業を再開しません。', 'Opening the conversation does not resume work.'), 'open_original', {}, 'link')] });
+  if (candidate.autoContinueStatus === 'needs_user' || candidate.analysis?.state === 'needs_user') return model('unresolved', {
+    title: pair('必要な判断内容を確認します', 'Check what needs a decision'),
+    question: pair('判断していただく内容をまだ特定できていません。具体的な内容が分かるまで、操作の許可は求めません。', 'The required decision has not been identified. No approval is requested until it is clear.'),
+    context: pair('まず会話と最新の状態を確認します。元のAIが権限の確認を求めている場合は、その会話で確認が必要です。', 'Check the conversation and latest state. Any provider permission must be handled in the original conversation.'),
+  }, { choices: [choice(pair('状況を再確認する', 'Refresh status'), pair('最新の状態を取得します。許可・停止状態は変更しません。', 'Get the latest state without changing permissions or stops.'), 'refresh', identity)] }, 'helper');
   return null;
 }

package/src/session-supervision/execution-context.js

@@ -0,0 +1,39 @@
+import { updateRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+// Controller choices are context, never permission to change scope or execute
+// a proposed deadline extension. The source needs no Web credentials to use it.
+export function controllerExecutionContext(candidate) {
+  const binding = candidate.actionAssociation?.binding;
+  const action = binding?.action;
+  const deadline = candidate.actionDeadline;
+  return {
+    executionTaskId: candidate.executionTaskId || null,
+    actionTaskId: candidate.taskId || null,
+    bindingRevision: binding?.revision ?? null,
+    action: action ? { id: action.id, title: String(action.title || '').slice(0, 120), revision: action.revision ?? null,
+      bindingRevision: binding.revision ?? null, dueAt: action.dueAt ?? null, timeZone: action.timeZone ?? null } : null,
+    deadlineChoice: deadline?.decision ? { choice: deadline.decision.choice, revision: deadline.decision.revision,
+      requestId: deadline.decision.requestId, remoteApplied: false } : null,
+  };
+}
+export async function applyControllerExecutionContext({ root, provider, session, context, cwd, authorize = async () => {} }) {
+  if (!context || typeof context !== 'object' || Array.isArray(context) || JSON.stringify(context).length > 4096 ||
+      ![context.executionTaskId, context.actionTaskId].every(value => value === null || typeof value === 'string' && value.length <= 128) ||
+      context.action !== null && (typeof context.action?.id !== 'string' || typeof context.action?.title !== 'string') ||
+      context.deadlineChoice !== null && (typeof context.deadlineChoice?.choice !== 'string' || context.deadlineChoice?.remoteApplied !== false)) throw new Error('Invalid controller execution context.');
+  await updateRecord(root, provider, session, async record => {
+    await authorize();
+    if (!record && context.executionTaskId === null && typeof cwd === 'string' && cwd) record = {schemaVersion:1,provider,session,cwd,run:null};
+    if (!record || record.schemaVersion !== 1 || record.provider !== provider || record.session !== session || (record.run?.managed?.taskId || null) !== context.executionTaskId) throw Object.assign(new Error('The execution task changed; refresh its context.'), { code: 'conflict' });
+    const previous = record.controllerExecutionContext;
+    if (previous?.actionTaskId === context.actionTaskId && Number.isSafeInteger(previous.bindingRevision) &&
+        (!Number.isSafeInteger(context.bindingRevision) || previous.bindingRevision > context.bindingRevision)) throw Object.assign(new Error('A newer Action choice has already reached this task.'), { code: 'conflict' });
+    if (previous?.actionTaskId === context.actionTaskId && previous.bindingRevision === context.bindingRevision &&
+        previous.action?.id === context.action?.id && previous.action?.revision === context.action?.revision &&
+        Number.isSafeInteger(previous.deadlineChoice?.revision) && Number.isSafeInteger(context.deadlineChoice?.revision) &&
+        previous.deadlineChoice.revision > context.deadlineChoice.revision) throw Object.assign(new Error('A newer deadline choice has already reached this task.'), { code: 'conflict' });
+    record.controllerExecutionContext = structuredClone(context);
+    if (record.run?.managed) record.run.managed.controllerExecutionContext = structuredClone(context);
+    return record;
+  });
+}