@awak-app/simy-cli 0.7.9 → 0.7.11

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

@@ -0,0 +1,84 @@
+// Display-only state. Tracking/auto-continue consent is never evidence of execution.
+export const WORK_STATE_TTL_MS = 45_000;
+const freshObservation = (checkedAt, now) => Number.isFinite(checkedAt) && checkedAt <= now && now - checkedAt <= WORK_STATE_TTL_MS;
+export function sessionWorkState(candidate, run, { now = Date.now(), provider } = {}) {
+  const checkedAt = candidate.observation?.observedAt ?? null;
+  const stale = !freshObservation(checkedAt, now);
+  const fetchFailed = provider?.discovery === 'unavailable';
+  const freshness = { checkedAt, stale, fetchFailed };
+  const result = (state, label, reason, nextAction = null, needsAttention = false) =>
+    ({ state, label, reason, nextAction, needsAttention, ...freshness });
+  if (candidate.archived || candidate.localHidden) return result('archived', 'アーカイブ済み', candidate.localHidden ? 'この一覧だけで非表示にしています。' : '元の会話がアーカイブされています。', 'restore');
+  let nativeRuntimeUnknown = false;
+  if (Object.hasOwn(candidate.observation || {}, 'activeFlags')) {
+    const flags = candidate.observation.activeFlags;
+    nativeRuntimeUnknown = stale || fetchFailed || !Array.isArray(flags) || flags.some(flag => !['waitingOnApproval', 'waitingOnUserInput'].includes(flag));
+    if (!nativeRuntimeUnknown && flags.includes('waitingOnApproval')) return result('approval', '承認待ち', '元のAIが操作の承認を待っています。', 'review_approval', true);
+    if (!nativeRuntimeUnknown && flags.includes('waitingOnUserInput')) return result('question', '回答待ち', '元のAIが回答を待っています。', 'answer', true);
+  }
+  // Never display a cached active flag as a live observation after a sleep/outage.
+  if (!nativeRuntimeUnknown && !stale && !fetchFailed && candidate.isRunning === true) return result('running', 'AIが対応中', '元のAIが実行中です。');
+  const approval = run?.pendingApproval || run?.managed?.pendingApproval;
+  const question = run?.understandingQuestion || run?.managed?.understandingQuestion || run?.managed?.userQuestion;
+  const phase = run?.phase || run?.managed?.phase;
+  const stopped = run?.state === 'stopped' || run?.stopReason?.actor === 'user' ||
+    run?.state === 'paused' && /^(Paused by user\.|Automatic continuation paused by user\.|User interrupted the provider\.|Stopped by user\.)$/.test(run.reason || '');
+  if (stopped) return result('stopped', '自分で停止', '停止の指示を維持しています。', 'resume');
+  if (approval && !approval.denied || candidate.decisionRequest?.kind === 'approval')
+    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 ((run?.autoRecovery || run?.managed?.autoRecovery) && ['recovery_required', 'auto_resuming'].includes(run.state)) return result('checking', 'AIが状況確認中', '自動復旧の結果を待っています。');
+  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', '依存条件待ち', '条件が変わるまで待機します。');
+  if (['blocked', 'verification_pending', 'reported_done', 'paused'].includes(run?.state) || candidate.analysis?.state === 'continue' && candidate.autoContinue !== true || candidate.autoContinueStatus === 'needs_user')
+    return result('unfinished', '残りの作業あり', run?.reason || candidate.analysis?.reason || '未完了の作業を再開できます。', 'resume', true);
+  if (nativeRuntimeUnknown) return result('unknown', '実行状態を確認できません', '元のAIの最新の実行状態を確認できません。', 'refresh');
+  const prs = candidate.pullRequests || [];
+  if (prs.some(pr => pr.state === 'OPEN' && pr.reviewDecision === 'CHANGES_REQUESTED')) return result('changes_requested', 'PRの修正要求', '関連PRに修正要求があります。', 'open_pr', true);
+  if (prs.some(pr => pr.state === 'OPEN')) return result('review', 'PRレビュー待ち', '関連PRのレビュー・統合を待っています。', 'open_pr');
+  if (prs.some(pr => pr.state === 'UNKNOWN' || pr.fetchFailed || pr.stale)) return result('pr_unknown', 'PRの状態確認待ち', '関連PRの最新状態を確認できません。', 'refresh');
+  // A merge or no-follow-up recommendation is not task completion. no_action
+  // also covers casual chat, cancellation and optional future improvements.
+  if (run?.state === 'completed' || !run && candidate.providerGoal?.status === 'complete')
+    return result('completed', '完了', '会話の作業完了を確認しました。');
+  if (candidate.isRunning === true && (stale || fetchFailed)) return result('unknown', '実行状態を確認できません', '最終確認後の実行状態は不明です。', 'refresh');
+  if (run && ['active', 'auto_resuming'].includes(run.state) || ['queued', 'analyzing'].includes(candidate.analysis?.state)) return result('checking', 'AIの対応待ち', '次の処理・状態確認を待っています。');
+  return result('idle', '次の依頼待ち', '現在の実行や対応依頼は確認されていません。');
+}
+
+export function compareSessionWork(a, b) {
+  const priority = item => item.workState?.state === 'running' ? 0 : item.workState?.needsAttention ? 1 : 2;
+  return priority(a) - priority(b) || (b.lastActivityAt || 0) - (a.lastActivityAt || 0) || `${a.provider}:${a.session}`.localeCompare(`${b.provider}:${b.session}`);
+}
+
+// Completion belongs to the whole known family. Idle history alone does not
+// create a human task; positively unfinished descendants do prevent completion.
+export function reconcileFamilyCompletion(sessions) {
+  const byKey = new Map(sessions.map(item => [`${item.provider}:${item.session}`, item]));
+  for (const child of sessions) {
+    if (['idle', 'completed', 'archived'].includes(child.workState?.state)) continue;
+    const seen = new Set(); let parent = child.parentSession;
+    while (parent) {
+      const key = `${parent.provider}:${parent.session}`;
+      if (seen.has(key)) break;
+      seen.add(key); const ancestor = byKey.get(key);
+      if (!ancestor) break;
+      if (ancestor.workState?.state === 'completed') ancestor.workState = { ...ancestor.workState,
+        state: 'family_unfinished', label: '子の作業が未完了', reason: '関連する子の作業が残っています。', nextAction: 'review_children', needsAttention: false };
+      parent = ancestor.parentSession;
+    }
+  }
+  return sessions;
+}
+
+// Fast connection heartbeats may carry the previous full projection while a
+// reader is blocked. Expire live labels there too, without losing pending work.
+export function expireSessionWorkState(candidate, now = Date.now()) {
+  const previous = candidate.workState;
+  if (!previous || freshObservation(previous.checkedAt, now)) return candidate;
+  if (previous.state !== 'running') return previous.stale ? candidate : { ...candidate, workState: { ...previous, stale: true } };
+  return { ...candidate, workState: { ...previous, state: 'unknown', label: '実行状態を確認できません',
+    reason: '最終確認後の実行状態は不明です。', nextAction: 'refresh', needsAttention: false, stale: true } };
+}

package/src/sqm/claude-plugin.js

@@ -26,6 +26,7 @@ export async function claudePluginFiles() {
   files.set("skills/delivery-loop/SKILL.md", await readFile(
     new URL("../delivery-hooks/claude-workflow.md", import.meta.url), "utf8"));
   files.set("hooks/delivery-loop.mjs", await readFile(path.join(SOURCE, "hooks/delivery-loop.mjs"), "utf8"));
+  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"));
   files.set("hooks/continuation-policy.mjs", await readFile(path.join(SOURCE, "hooks/continuation-policy.mjs"), "utf8"));
@@ -38,6 +39,7 @@ export async function claudePluginFiles() {
   files.set("hooks/completion-binding.mjs", await readFile(path.join(SOURCE, "hooks/completion-binding.mjs"), "utf8"));
   files.set("hooks/consistency-handoff.mjs", await readFile(path.join(SOURCE, "hooks/consistency-handoff.mjs"), "utf8"));
   files.set("hooks/purpose-evidence.mjs", await readFile(path.join(SOURCE, "hooks/purpose-evidence.mjs"), "utf8"));
+  files.set("hooks/scene-reasoning.mjs", await readFile(path.join(SOURCE, "hooks/scene-reasoning.mjs"), "utf8"));
   files.set("hooks/purpose-cycle.mjs", await readFile(path.join(SOURCE, "hooks/purpose-cycle.mjs"), "utf8"));
   files.set("hooks/purpose-rule-policy.mjs", await readFile(path.join(SOURCE, "hooks/purpose-rule-policy.mjs"), "utf8"));
   files.set("hooks/acceptance-policy.mjs", await readFile(path.join(SOURCE, "hooks/acceptance-policy.mjs"), "utf8"));

package/src/sqm/local-tests.js

@@ -8,6 +8,7 @@ import path from 'node:path';
 // This catalog is shipped with the CLI; a repository cannot supply shell commands.
 const profiles = {
   'delivery-loop': [
+    { id: 'autonomous-recovery', files: ['test/autonomous-recovery.test.js', 'test/scene-reasoning.test.js', 'test/supervisor-watchdog.test.js'] },
     { id: 'perspective-memory', files: ['test/perspective-memory.test.js'] },
     { id: 'optional-reasoning', files: ['test/purpose-selective-rules.test.js', 'test/purpose-evidence.test.js', 'test/purpose-rule-review.test.js'] },
     // This connected controller group now contains over 200 cases. Keep a

package/src/sqm/review-worker.js

@@ -1,3 +1,4 @@
+import { withSceneReasoning } from '../codex-plugins/simy/hooks/scene-reasoning.mjs';
 import { requireProviderSubscription } from './subscription-auth.js';
 import { signalExecutorProcess } from "../runner.js";
 import spawn from "cross-spawn";
@@ -398,6 +399,8 @@ export function runStructuredCodexReview(request, options) {
 }
 
 export async function runStructuredProviderReview(provider, request, options = {}) {
+  // Keep malformed requests invalid; the reasoning policy must not fill missing authority or inputs.
+  if (typeof request?.system === 'string' && request.system.trim()) request = { ...request, system: withSceneReasoning(request.system) };
   const fallbackProviders = options.enableEngineFallback === true && options.providerReportingSupported === true && options.readOnlyAnalysis !== false && Array.isArray(options.allowedFallbackProviders)
     ? [...new Set(options.allowedFallbackProviders.filter(candidate => ["codex", "claude"].includes(candidate) && candidate !== provider))] : [];
   if (!fallbackProviders.length) return runSingleProviderReview(provider, request, options);