@awak-app/simy-cli 0.7.25 → 0.7.27

package/src/session-supervision/remote-managed-delivery.js

@@ -0,0 +1,94 @@
+import { mkdir, readFile, writeFile, rename, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+
+const sessionId = value => typeof value === 'string' && /^[a-f0-9-]{36}$/.test(value);
+const actions = new Set(['delivery_resume', 'delivery_pause', 'delivery_stop']);
+
+// A host-local adapter, not an execution controller. Supply the installed
+// runtime's resumeSession/controlDelivery, record reader and status projection.
+// The existing managed supervisor remains the only owner of claims/dispatches.
+export async function createRemoteManagedDelivery({ root, stateRoot, scope, authorize, select,
+  readRecord, listRecords, resumeSession, controlDelivery, deliveryHookStatus }) {
+  const automaticRoot = join(stateRoot, 'targets');
+  const manualRoot = join(stateRoot, 'manual-targets');
+  await mkdir(automaticRoot, { recursive: true, mode: 0o700 });
+  await mkdir(manualRoot, { recursive: true, mode: 0o700 });
+  async function target(directory, session) {
+    if (!sessionId(session)) throw new Error('Select a known conversation');
+    try { return JSON.parse(await readFile(join(directory, session + '.json'), 'utf8')); }
+    catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  }
+  const read = (provider, session) => readRecord(root, provider, session);
+  const matches = (binding, record) => binding && record?.run?.id === binding.runId &&
+    record.run.managed?.taskId === binding.taskId;
+  async function guard(candidate) {
+    if (candidate?.provider !== 'codex' || !sessionId(candidate.session)) throw new Error('Select a known conversation');
+    const automatic = await target(automaticRoot, candidate.session);
+    const record = await read('codex', candidate.session);
+    if (automatic) {
+      await authorize(automatic.scope);
+      if (!record?.autoContinue || record.autoContinueEpoch !== automatic.epoch) throw new Error('Continuation consent changed');
+      return automatic;
+    }
+    const manual = await target(manualRoot, candidate.session);
+    if (!matches(manual, record)) throw new Error('Conversation not selected');
+    await authorize(manual.scope);
+    return manual;
+  }
+  async function records() {
+    const selectedScope = scope();
+    if (!selectedScope) return [];
+    const rows = new Map();
+    for (const [directory, automatic] of [[automaticRoot, true], [manualRoot, false]]) {
+      for (const file of await readdir(directory)) {
+        if (!file.endsWith('.json') || !sessionId(file.slice(0, -5))) continue;
+        const session = file.slice(0, -5), binding = await target(directory, session);
+        if (!binding || !isDeepStrictEqual(binding.scope, selectedScope)) continue;
+        const record = await read('codex', session);
+        if (automatic ? record?.autoContinue && record.autoContinueEpoch === binding.epoch : matches(binding, record))
+          rows.set(session, record);
+      }
+    }
+    return [...rows.values()];
+  }
+  async function control(command) {
+    if (!actions.has(command?.action) || command.provider !== 'codex' || !sessionId(command.session) ||
+        typeof command.taskId !== 'string' || !command.taskId) throw new Error('Unsupported remote command');
+    const selectedScope = await authorize();
+    const candidate = await select(command);
+    if (candidate?.provider !== command.provider || candidate.session !== command.session) throw new Error('Select a known conversation');
+    const automatic = await target(automaticRoot, command.session);
+    if (automatic || command.action !== 'delivery_resume') await guard(command);
+    const record = await read(command.provider, command.session);
+    if (record?.run?.managed?.taskId !== command.taskId ||
+        command.expectedRunId !== undefined && record.run.id !== command.expectedRunId)
+      throw new Error('Task changed; refresh before operating');
+    await authorize(selectedScope);
+    // Forward only the native control contract. A command cannot provide an
+    // admission, resume observation, permission override, or dispatch receipt.
+    await (command.action === 'delivery_resume' ? resumeSession : controlDelivery)({
+      root, provider: command.provider, session: command.session, taskId: command.taskId,
+      expectedRunId: command.expectedRunId ?? record.run.id, expectedRevision: command.expectedRevision,
+      action: command.action.slice('delivery_'.length),
+    });
+    if (!automatic && command.action === 'delivery_resume') {
+      await authorize(selectedScope);
+      if (!matches({ runId: record.run.id, taskId: command.taskId }, await read(command.provider, command.session)))
+        throw new Error('Task changed; refresh before operating');
+      const file = join(manualRoot, command.session + '.json');
+      const temporary = file + '.' + randomUUID() + '.tmp';
+      await writeFile(temporary, JSON.stringify({ scope: selectedScope, runId: record.run.id, taskId: command.taskId }) + '\n', { mode: 0o600 });
+      await rename(temporary, file);
+    }
+  }
+  async function status() {
+    const selectedScope = await authorize();
+    // Supplying records is essential: display must not reconcile/mutate runs.
+    const result = await deliveryHookStatus({ root, records: await listRecords(root) });
+    await authorize(selectedScope);
+    return result;
+  }
+  return { control, guard, records, status, readCurrentRecord: read };
+}

package/src/session-supervision/remote-session-list.js

@@ -6,7 +6,7 @@ import { readHosts } from './remote-hosts.js';
 // This read-only command never boots a remote desktop host or supervisor.
 export async function readRemoteSessionLists({ root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy'),
   providers, includeArchived = false, signal, spawnImpl = spawn, timeoutMs = 30_000 } = {}) {
-  const hosts = await readHosts(root);
+  const hosts = (await readHosts(root)).filter(host => host.enabled !== false);
   return Promise.all(hosts.map(async host => {
     try {
       signal?.throwIfAborted();

package/src/session-supervision/statistics.js

@@ -61,7 +61,13 @@ class StatisticsAccumulator {
     if (!row || typeof row !== 'object' || Array.isArray(row)) { this.missing = true; return; }
     if (this.provider === 'codex' && row.type === 'session_meta') {
       if (row.payload?.id !== this.session) this.wrongSession = true;
-      else this.matched = true;
+      else {
+        this.matched = true;
+        // Creation can precede the first usage/activity record. Forked history
+        // can also contain older events belonging to the parent conversation.
+        const created = Date.parse(row.payload?.timestamp ?? row.timestamp);
+        if (Number.isFinite(created)) this.startedAt = created;
+      }
     }
     if (this.provider === 'claude') {
       if (row.sessionId !== this.session || row.isSidechain === true) return;
@@ -104,9 +110,10 @@ class StatisticsAccumulator {
     }
   }
   *finishSteps(now, incomplete = false, coverage = {}) {
-    if (!this.matched || this.wrongSession || this.earliest > now) return unavailableStatistics();
+    const first = this.startedAt ?? this.earliest;
+    if (!this.matched || this.wrongSession || first > now) return unavailableStatistics();
     const missing = this.missing || incomplete;
-    const start = Math.max(this.earliest, now - WINDOW_MS), end = now;
+    const start = Math.max(first, now - WINDOW_MS), end = now;
     const hours = new Map();
     for (let at = Math.floor(start / HOUR) * HOUR; at <= end; at += HOUR) hours.set(at, { at, tokens: null });
     let batch = 0;

package/src/session-supervision/stop-notifications.js

@@ -1,15 +1,20 @@
 import { createHash } from 'node:crypto';
 import { deliveryStop } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 
+const pendingManualChecks = run => (run.managed.acceptanceCriteria || []).filter(item =>
+  item.check?.type === 'manual' && !Object.hasOwn(run.managed.verified || {}, item.id));
+
 // Auto-continue works while nobody is watching, so a person must learn when it
 // stops. Map a stopped run to a notification kind; the native window owns copy.
 export function stopNotificationKind(run, now = Date.now()) {
   if (!run?.managed?.autoContinueEpoch && !run?.managed?.repairRequest) return null;
+  if (run.stopReason?.actor === 'user') return null;
   // The clock keeps aging while paused; the persisted human decision takes
   // precedence over a threshold that was reached only after that decision.
-  if (run.state === 'paused') return run.reason === 'Paused by user.' ? null : deliveryStop(run, now) ? 'paused' : null;
+  if (run.state === 'paused') return /^(Paused by user\.|Automatic continuation paused by user\.|User interrupted the provider\.|Stopped by user\.)$/.test(run.reason || '') ? null : deliveryStop(run, now) ? 'paused' : null;
   if (run.state === 'auto_resuming' && !run.managed.resumeLease?.owner) return 'needs_decision';
-  if (run.state === 'blocked' || run.state === 'verification_pending' || run.state === 'reported_done') return 'needs_decision';
+  if (run.state === 'blocked') return run.blocker === 'external_dependency' || run.managed.dependencyWait ? null : 'needs_decision';
+  if (run.state === 'verification_pending') return pendingManualChecks(run).length ? 'needs_decision' : null;
   if (run.state === 'recovery_required' && run.managed.autoRecovery !== true) return 'needs_decision';
   if (run.state === 'failed' || run.state === 'budget_exhausted') return 'failed';
   if (run.state === 'completed') return 'finished';
@@ -19,24 +24,35 @@ export function stopNotificationKind(run, now = Date.now()) {
 // The first observation is a baseline: restarting SIMY must not replay alerts
 // for runs that stopped earlier. Each distinct stop is announced once.
 export function createStopNotifier({ emit, now = Date.now } = {}) {
-  // Retain one stop fingerprint per currently observed task, rather than an
-  // event cache whose eviction could replay the entire historical baseline.
+  // Retain one stop fingerprint per task for this process. A temporarily empty
+  // discovery result must not turn the same historical stop into a new alert.
   const seen = new Map();
   let baseline = true;
   return {
     observe(records) {
       for (const record of records) {
-        const run = record?.run, kind = stopNotificationKind(run, now());
+        if (record.providerArchived || record.localHidden) continue;
+        const run = record?.run;
+        const kind = stopNotificationKind(run, now());
         const key = JSON.stringify([record.provider, record.session, run?.managed?.taskId]);
-        if (!kind) continue;
-        const id = createHash('sha256').update(JSON.stringify([record.provider, record.session, run.managed.taskId, run.id, kind, run.blocker, run.reason])).digest('hex').slice(0, 32);
+        if (!kind) {
+          if (run?.state === 'active' || run?.state === 'auto_resuming') seen.delete(key);
+          continue;
+        }
+        // Revisions and generated summaries change during maintenance without
+        // creating a new human task. Only a different stop/explicit request does.
+        const request = run.managed.pendingApproval || run.managed.understandingQuestion;
+        const id = createHash('sha256').update(JSON.stringify([record.provider, record.session, run.managed.taskId,
+          run.id, run.managed.autoContinueEpoch, kind, run.blocker || null, request?.id || null,
+          run.managed.userQuestion || null])).digest('hex').slice(0, 32);
         if (seen.get(key) === id) continue;
         seen.set(key, id);
+        const detail = request?.text || request?.summary || run.managed.userQuestion ||
+          (run.state === 'verification_pending' ? pendingManualChecks(run).map(item => item.description).filter(Boolean).join('; ') : null);
         if (!baseline) emit({ type: 'notify', id, kind, provider: record.provider, session: record.session,
-          objective: String(run.objective || '').slice(0, 200) });
+          objective: String(run.objective || '').slice(0, 200),
+          ...(detail ? { detail: String(detail).slice(0, 500) } : {}) });
       }
-      // Temporary provider absence or a diagnostic pass is not a new stop.
-      // Retain fingerprints until a materially different outcome is observed.
       baseline = false;
     },
   };

package/src/session-supervision/work-state.js

@@ -28,7 +28,12 @@ export function sessionWorkState(candidate, run, { now = Date.now(), provider }
     return result('approval', '承認待ち', candidate.decisionRequest?.context || '実行する操作の確認が必要です。', 'review_approval', true);
   if (question || phase === 'needs_clarification' || candidate.analysis?.state === 'needs_user' || candidate.decisionRequest?.kind === 'question')
     return result('question', '回答待ち', candidate.decisionRequest?.question || '続けるために回答が必要です。', 'answer', true);
+  if (candidate.autoContinue === true && ['starting', 'recovering'].includes(candidate.autoContinueStatus))
+    return result(candidate.autoContinueStatus, candidate.autoContinueStatus === 'starting' ? '自動継続を準備中' : '自動復旧中',
+      candidate.autoContinueReason || '自動継続はオンで保存されています。');
   if ((run?.autoRecovery || run?.managed?.autoRecovery) && ['recovery_required', 'auto_resuming'].includes(run.state)) return result('checking', 'AIが状況確認中', '自動復旧の結果を待っています。');
+  if (candidate.autoContinue === true && candidate.autoContinueStatus === 'supervising' && run?.state === 'verification_pending')
+    return result('checking', '結果を確認中', '作業の結果を自動で確認しています。');
   if (['failed', 'recovery_required', 'budget_exhausted'].includes(run?.state) || candidate.analysis?.state === 'failed' || candidate.autoContinueStatus === 'error')
     return result('error', '対応が必要', run?.reason || '作業が中断されています。', run?.canResume || run?.canReplan ? 'resume' : 'open_original', true);
   if (run?.dependencyWait || run?.managed?.dependencyWait) return result('waiting', '依存条件待ち', '条件が変わるまで待機します。');

package/src/sqm/claude-plugin.js

@@ -28,7 +28,14 @@ export async function claudePluginFiles() {
   for (const name of ["loop-kernel.mjs", "loop-kernel/index.mjs", "loop-kernel/policy.json", "loop-kernel/pin.json", "loop-kernel/outcome-review.mjs", "loop-kernel/work-frontier.mjs", "loop-kernel/task-pool.mjs"]) {
     files.set(`hooks/${name}`, await readFile(path.join(SOURCE, "hooks", name), "utf8"));
   }
-  files.set("hooks/delivery-loop.mjs", await readFile(path.join(SOURCE, "hooks/delivery-loop.mjs"), "utf8"));
+  const collector = await readFile(new URL("../cli-observability.js", import.meta.url), "utf8");
+  files.set("hooks/cli-observability.mjs", collector.replace("./web-api.js", "./web-api.mjs"));
+  files.set("hooks/web-api.mjs", await readFile(new URL("../web-api.js", import.meta.url), "utf8"));
+  const deliveryLoop = await readFile(path.join(SOURCE, "hooks/delivery-loop.mjs"), "utf8");
+  files.set("hooks/delivery-loop.mjs", deliveryLoop.replace(
+    "const observeDeliveryRecord = (...args) => import('../../../cli-observability.js')\n  .then(({ observeDeliveryRecord: observe }) => observe(...args)).catch(() => false);",
+    "import { observeDeliveryRecord } from './cli-observability.mjs';",
+  ));
   files.set("hooks/recovery-incident.mjs", await readFile(path.join(SOURCE, "hooks/recovery-incident.mjs"), "utf8"));
   files.set("hooks/minimal-sufficient.mjs", await readFile(path.join(SOURCE, "hooks/minimal-sufficient.mjs"), "utf8"));
   files.set("hooks/outcome-progress.mjs", await readFile(path.join(SOURCE, "hooks/outcome-progress.mjs"), "utf8"));