sneakoscope 0.6.70 → 0.6.72

package/README.md

@@ -44,11 +44,12 @@ sks selftest --mock
 | Area | What it does |
 | --- | --- |
 | CLI runtime | `sks`, `sks cmux`, and `sks --mad` open Codex CLI in a cmux workspace. |
-| Codex App commands | Installs generated skills so `$Team`, `$DFix`, `$QA-LOOP`, `$Ralph`, `$DB`, `$Wiki`, `$Help`, and related routes are visible in prompt workflows. |
+| Codex App commands | Installs generated skills so `$Team`, `$From-Chat-IMG`, `$DFix`, `$QA-LOOP`, `$Ralph`, `$DB`, `$Wiki`, `$Help`, and related routes are visible in prompt workflows. |
 | Team orchestration | Runs substantial work through ambiguity handling, scouts, TriWiki refresh, debate, runtime task graphs, worker inboxes, implementation, review, cleanup, reflection, and Honest Mode. |
+| From-Chat-IMG | Turns chat screenshots plus original attachments into source-bound work orders, then requires scoped QA evidence before completion. |
 | QA loop | Dogfoods UI/API behavior with safety gates, Browser/Computer evidence, safe fixes, and rechecks. |
 | Ralph | Clarifies once, seals a decision contract, then continues without repeatedly asking the user. |
-| TriWiki | Maintains `.sneakoscope/wiki/context-pack.json` as the context SSOT with `attention.use_first` and `attention.hydrate_first`. |
+| TriWiki voxels | Maintains `.sneakoscope/wiki/context-pack.json` as the context SSOT with coordinate anchors, voxel metadata, `attention.use_first`, and `attention.hydrate_first`. |
 | Context7 | Requires current docs for external packages, APIs, MCPs, SDKs, and framework/runtime behavior when correctness depends on current guidance. |
 | DB safety | Treats SQL, migrations, Supabase, RLS, and destructive operations as high risk. |
 | Release hygiene | Checks versioning, changelog, package contents, tarball size, syntax, selftests, and dry-run publishing. |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.6.70",
+  "version": "0.6.72",
   "description": "Sneakoscope Codex: database-safe Codex CLI/App harness with Team, Ralph, AutoResearch, TriWiki, and Honest Mode.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",

package/src/cli/main.mjs

@@ -30,7 +30,7 @@ import { context7Evidence, evaluateStop, recordContext7Evidence, recordSubagentE
 import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, validateTeamRuntimeArtifacts, writeTeamRuntimeArtifacts } from '../core/team-dag.mjs';
 import { appendTeamEvent, formatRoleCounts, initTeamLive, normalizeTeamSpec, parseTeamSpecArgs, parseTeamSpecText, readTeamDashboard, readTeamLive, readTeamTranscriptTail, renderTeamAgentLane } from '../core/team-live.mjs';
 import { CODEX_APP_DOCS_URL, codexAppIntegrationStatus, formatCodexAppStatus } from '../core/codex-app.mjs';
-import { CMUX_BREW_COMMAND, CMUX_BREW_UPGRADE_COMMAND, buildCmuxLaunchPlan, buildCmuxNewWorkspaceArgs, cmuxWorkspaceRef, defaultCmuxWorkspaceName, ensureCmuxInstalled, formatCmuxBanner, launchCmuxTeamView, launchCmuxUi, matchingCmuxWorkspaces, parseCmuxWorkspaceList, platformCmuxInstallHint, runCmuxStatus, sanitizeCmuxWorkspaceName, cmuxAvailable } from '../core/cmux-ui.mjs';
+import { CMUX_BREW_COMMAND, CMUX_BREW_UPGRADE_COMMAND, buildCmuxLaunchPlan, buildCmuxNewWorkspaceArgs, cmuxWorkspaceRef, cmuxWorkspaceRefFromText, defaultCmuxWorkspaceName, ensureCmuxInstalled, formatCmuxBanner, launchCmuxTeamView, launchCmuxUi, matchingCmuxWorkspaces, parseCmuxWorkspaceList, platformCmuxInstallHint, readCmuxWorkspaceRecord, runCmuxStatus, sanitizeCmuxWorkspaceName, cmuxAvailable, writeCmuxWorkspaceRecord } from '../core/cmux-ui.mjs';
 import { autoReviewProfileName, autoReviewStatus, autoReviewSummary, enableAutoReview, disableAutoReview, enableMadHighProfile, madHighProfileName } from '../core/auto-review.mjs';
 
 const flag = (args, name) => args.includes(name);
@@ -2378,6 +2378,10 @@ async function selftest() {
   ] }));
   const workspaceMatches = matchingCmuxWorkspaces(workspaceList, workspacePlan);
   if (workspaceMatches.length !== 1 || cmuxWorkspaceRef(workspaceMatches[0]) !== 'workspace:1') throw new Error('selftest failed: MAD cmux workspace reuse matching did not select the stable workspace');
+  if (cmuxWorkspaceRefFromText('OK workspace:3') !== 'workspace:3') throw new Error('selftest failed: cmux workspace ref parser did not read cmux OK output');
+  await writeCmuxWorkspaceRecord(workspacePlan, { ref: 'workspace:7', name: 'sks-mad-selftest', cwd: tmp });
+  const workspaceRecord = await readCmuxWorkspaceRecord(workspacePlan);
+  if (workspaceRecord?.ref !== 'workspace:7' || workspaceRecord.workspace !== 'sks-mad-selftest') throw new Error('selftest failed: MAD cmux workspace record was not persisted for stable reuse');
   const guardBlocked = await checkHarnessModification(tmp, { tool_name: 'apply_patch', command: '*** Update File: .agents/skills/team/SKILL.md\n+tamper\n' });
   if (guardBlocked.action !== 'block') throw new Error('selftest failed: harness guard allowed skill tampering');
   const setupBlocked = await checkHarnessModification(tmp, { command: 'sks setup --force' });
@@ -2665,6 +2669,10 @@ async function selftest() {
   if (honestMissingSummaryResult.code !== 0) throw new Error(`selftest failed: missing-summary honest hook exited ${honestMissingSummaryResult.code}: ${honestMissingSummaryResult.stderr}`);
   const honestMissingSummaryJson = JSON.parse(honestMissingSummaryResult.stdout);
   if (honestMissingSummaryJson.decision !== 'block' || !String(honestMissingSummaryJson.reason || '').includes('completion summary')) throw new Error('selftest failed: Honest Mode without completion summary was accepted');
+  const honestMissingSummaryRepeatResult = await runProcess(process.execPath, [hookBin, 'hook', 'stop'], { cwd: honestLoopTmp, input: JSON.stringify({ cwd: honestLoopTmp, last_assistant_message: '**솔직모드**\n검증: selftest 통과\n남은 gap: 없음' }), env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 128 * 1024 });
+  if (honestMissingSummaryRepeatResult.code !== 0) throw new Error(`selftest failed: repeated missing-summary honest hook exited ${honestMissingSummaryRepeatResult.code}: ${honestMissingSummaryRepeatResult.stderr}`);
+  const honestMissingSummaryRepeatJson = JSON.parse(honestMissingSummaryRepeatResult.stdout);
+  if (honestMissingSummaryRepeatJson.decision === 'block' || !String(honestMissingSummaryRepeatJson.systemMessage || '').includes('repeat guard')) throw new Error('selftest failed: repeated completion-summary stop prompt was not suppressed');
   const honestBlockedAsExpectedResult = await runProcess(process.execPath, [hookBin, 'hook', 'stop'], { cwd: honestLoopTmp, input: JSON.stringify({ cwd: honestLoopTmp, last_assistant_message: '**작업 요약**\nlegacy QA report 차단 확인을 검증했습니다.\n**솔직모드**\n검증: selftest 통과, legacy `qa-report.md` 차단 확인\n제약: registry publish excluded' }), env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 128 * 1024 });
   if (honestBlockedAsExpectedResult.code !== 0) throw new Error(`selftest failed: blocked-as-expected honest hook exited ${honestBlockedAsExpectedResult.code}: ${honestBlockedAsExpectedResult.stderr}`);
   const honestBlockedAsExpectedJson = JSON.parse(honestBlockedAsExpectedResult.stdout);

package/src/core/cmux-ui.mjs

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import fsp from 'node:fs/promises';
 import { spawnSync } from 'node:child_process';
-import { exists, packageRoot, runProcess, sha256, sksRoot, which } from './fsx.mjs';
+import { exists, nowIso, packageRoot, readJson, runProcess, sha256, sksRoot, which, writeJsonAtomic } from './fsx.mjs';
 import { getCodexInfo } from './codex-adapter.mjs';
 import { codexAppIntegrationStatus, formatCodexAppStatus } from './codex-app.mjs';
 
@@ -74,6 +74,64 @@ export function cmuxWorkspaceRef(workspace = {}) {
   return String(workspace.ref || workspace.workspace_ref || workspace.handle || workspace.id || workspace.workspace_id || workspace.uuid || '').trim();
 }
 
+export function cmuxWorkspaceRefFromText(text = '') {
+  return String(text || '').match(/\bworkspace:\d+\b/i)?.[0] || String(text || '').match(/[0-9a-f]{8}-[0-9a-f-]{27,}/i)?.[0] || '';
+}
+
+export function cmuxWorkspaceStatePath(plan = {}) {
+  return path.join(path.resolve(plan.root || process.cwd()), '.sneakoscope', 'state', 'cmux-workspaces.json');
+}
+
+export function cmuxWorkspaceStateKey(plan = {}) {
+  const root = path.resolve(plan.root || process.cwd());
+  const workspace = sanitizeCmuxWorkspaceName(plan.workspace || defaultCmuxWorkspaceName(root));
+  const profile = codexProfileFromArgs(plan.codexArgs);
+  return sha256(`${root}\n${workspace}\n${profile || 'default'}`).slice(0, 16);
+}
+
+export async function readCmuxWorkspaceRecord(plan = {}) {
+  const state = await readJson(cmuxWorkspaceStatePath(plan), {}).catch(() => ({}));
+  const record = state.workspaces?.[cmuxWorkspaceStateKey(plan)] || null;
+  return record && typeof record === 'object' ? record : null;
+}
+
+export async function writeCmuxWorkspaceRecord(plan = {}, workspace = {}) {
+  const statePath = cmuxWorkspaceStatePath(plan);
+  const state = await readJson(statePath, {}).catch(() => ({}));
+  const root = path.resolve(plan.root || process.cwd());
+  const name = workspaceName(workspace) || sanitizeCmuxWorkspaceName(plan.workspace || defaultCmuxWorkspaceName(root));
+  const record = {
+    workspace: name,
+    root,
+    ref: cmuxWorkspaceRef(workspace),
+    description: workspaceDescription(workspace) || cmuxWorkspaceDescription(plan),
+    cwd: workspaceCwd(workspace) || root,
+    profile: codexProfileFromArgs(plan.codexArgs) || 'default',
+    updated_at: nowIso()
+  };
+  if (!record.ref) return null;
+  const next = {
+    schema_version: 1,
+    updated_at: record.updated_at,
+    workspaces: {
+      ...(state.workspaces && typeof state.workspaces === 'object' ? state.workspaces : {}),
+      [cmuxWorkspaceStateKey(plan)]: record
+    }
+  };
+  await writeJsonAtomic(statePath, next);
+  return record;
+}
+
+async function forgetCmuxWorkspaceRecord(plan = {}) {
+  const statePath = cmuxWorkspaceStatePath(plan);
+  const state = await readJson(statePath, null).catch(() => null);
+  if (!state?.workspaces || typeof state.workspaces !== 'object') return;
+  const key = cmuxWorkspaceStateKey(plan);
+  if (!(key in state.workspaces)) return;
+  delete state.workspaces[key];
+  await writeJsonAtomic(statePath, { ...state, updated_at: nowIso(), workspaces: state.workspaces });
+}
+
 export function shellEscape(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
@@ -280,12 +338,18 @@ export async function launchCmuxUi(args = [], opts = {}) {
       return { plan, workspace_reuse: reuse };
     }
   }
-  const created = spawnSync(plan.cmux.bin, buildCmuxNewWorkspaceArgs(plan, command), { encoding: 'utf8', stdio: args.includes('--quiet') ? 'pipe' : 'inherit' });
+  const created = spawnSync(plan.cmux.bin, buildCmuxNewWorkspaceArgs(plan, command), { encoding: 'utf8', stdio: 'pipe' });
+  if (!args.includes('--quiet')) {
+    if (created.stdout) process.stdout.write(created.stdout);
+    if (created.stderr) process.stderr.write(created.stderr);
+  }
   if (created.status !== 0) {
     process.exitCode = created.status || 1;
-    if (created.stderr) process.stderr.write(created.stderr);
+    if (args.includes('--quiet') && created.stderr) process.stderr.write(created.stderr);
     return { plan };
   }
+  const createdRef = cmuxWorkspaceRefFromText(`${created.stdout || ''}\n${created.stderr || ''}`);
+  if (createdRef) await writeCmuxWorkspaceRecord(plan, { ref: createdRef, name: plan.workspace, description: cmuxWorkspaceDescription(plan), cwd: plan.root }).catch(() => null);
   if (args.includes('--no-open')) {
     console.log(`SKS cmux workspace requested: ${plan.workspace}`);
   }
@@ -293,6 +357,8 @@ export async function launchCmuxUi(args = [], opts = {}) {
 }
 
 async function reuseExistingCmuxWorkspace(plan = {}, opts = {}) {
+  const remembered = await reuseRecordedCmuxWorkspace(plan);
+  if (remembered.reused) return remembered;
   const listed = await listCmuxWorkspaces(plan.cmux?.bin);
   if (!listed.ok) return listed;
   const matches = matchingCmuxWorkspaces(listed.workspaces, plan);
@@ -311,9 +377,22 @@ async function reuseExistingCmuxWorkspace(plan = {}, opts = {}) {
       if (close.code === 0) closed += 1;
     }
   }
+  await writeCmuxWorkspaceRecord(plan, keep).catch(() => null);
   return { ok: true, reused: true, workspace: keep, workspace_ref: ref, closed_duplicates: closed, total_matches: matches.length };
 }
 
+async function reuseRecordedCmuxWorkspace(plan = {}) {
+  const record = await readCmuxWorkspaceRecord(plan);
+  const ref = cmuxWorkspaceRef(record || {});
+  if (!ref) return { ok: true, reused: false };
+  const selected = await runProcess(plan.cmux.bin, ['select-workspace', '--workspace', ref], { timeoutMs: 5000, maxOutputBytes: 16 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
+  if (selected.code === 0) return { ok: true, reused: true, workspace: record, workspace_ref: ref, remembered: true, closed_duplicates: 0 };
+  const error = `${selected.stderr || selected.stdout || 'cmux select-workspace failed'}`.trim();
+  if (isRecoverableCmuxSocketError(error)) return { ok: false, error, stale_ref: ref };
+  await forgetCmuxWorkspaceRecord(plan).catch(() => null);
+  return { ok: true, reused: false, stale_ref: ref, stale_error: error };
+}
+
 async function listCmuxWorkspaces(bin) {
   if (!bin) return { ok: false, error: 'cmux CLI not found' };
   const run = await runProcess(bin, ['list-workspaces', '--json'], { timeoutMs: 5000, maxOutputBytes: 128 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));

package/src/core/fsx.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 
-export const PACKAGE_VERSION = '0.6.70';
+export const PACKAGE_VERSION = '0.6.72';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 

package/src/core/hooks-runtime.mjs

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { projectRoot, readJson, readText, writeJsonAtomic, appendJsonl, readStdin, nowIso, runProcess, which, PACKAGE_VERSION } from './fsx.mjs';
+import { projectRoot, readJson, readText, writeJsonAtomic, appendJsonl, readStdin, nowIso, runProcess, which, PACKAGE_VERSION, sha256 } from './fsx.mjs';
 import { looksInteractiveCommand, interactiveCommandReason } from './no-question-guard.mjs';
 import { missionDir, setCurrent, stateFile } from './mission.mjs';
 import { checkDbOperation, dbBlockReason, handleMadSksUserConfirmation } from './db-safety.mjs';
@@ -10,6 +10,10 @@ const TEAM_DIGEST_MAX_EVENTS = 4;
 const TEAM_DIGEST_MESSAGE_CHARS = 180;
 const TEAM_DIGEST_CONTEXT_CHARS = 1600;
 const TEAM_DIGEST_SYSTEM_CHARS = 260;
+const STOP_REPEAT_GUARD_ARTIFACT = 'stop-hook-repeat-guard.json';
+const STOP_REPEAT_GUARD_WINDOW_MS = 10 * 60 * 1000;
+const STOP_REPEAT_GUARD_MAX_ENTRIES = 25;
+const DEFAULT_STOP_REPEAT_GUARD_LIMIT = 2;
 
 async function loadHookPayload() {
   const raw = await readStdin();
@@ -188,15 +192,19 @@ async function hookStop(root, state, payload, noQuestion) {
   if (!noQuestion) {
     const last = extractLastMessage(payload);
     if (!hasHonestMode(last)) {
-      return {
+      const reason = 'SKS Honest Mode is required before finishing. Re-check the actual goal, verify evidence/tests, state gaps honestly, and only then provide the final answer. Include a short "SKS Honest Mode" or "솔직모드" section.';
+      const repeatDecision = await finalizationRepeatDecision(root, state, payload, reason, 'honest_mode_missing');
+      return repeatDecision || {
         decision: 'block',
-        reason: 'SKS Honest Mode is required before finishing. Re-check the actual goal, verify evidence/tests, state gaps honestly, and only then provide the final answer. Include a short "SKS Honest Mode" or "솔직모드" section.'
+        reason
       };
     }
     if (!hasCompletionSummary(last)) {
-      return {
+      const reason = 'SKS final completion summary is required before finishing. Explain what was done, what changed for the user/repo, what was verified, and any remaining gaps before or alongside SKS Honest Mode.';
+      const repeatDecision = await finalizationRepeatDecision(root, state, payload, reason, 'completion_summary_missing');
+      return repeatDecision || {
         decision: 'block',
-        reason: 'SKS final completion summary is required before finishing. Explain what was done, what changed for the user/repo, what was verified, and any remaining gaps before or alongside SKS Honest Mode.'
+        reason
       };
     }
     if (shouldLoopBackAfterHonestMode(state) && hasHonestModeUnresolvedGap(last)) {
@@ -215,6 +223,76 @@ async function hookStop(root, state, payload, noQuestion) {
   };
 }
 
+async function finalizationRepeatDecision(root, state = {}, payload = {}, reason = '', kind = 'finalization') {
+  const now = nowIso();
+  const guardPath = path.join(root, '.sneakoscope', 'state', STOP_REPEAT_GUARD_ARTIFACT);
+  const previous = await readJson(guardPath, {}).catch(() => ({}));
+  const limit = stopRepeatGuardLimit();
+  const entries = pruneStopRepeatEntries(previous.entries || {}, now);
+  const key = stopRepeatKey(state, payload, reason, kind);
+  const prior = entries[key] || {};
+  const repeatCount = stopRepeatInWindow(prior, now)
+    ? Number(prior.repeat_count || 0) + 1
+    : 1;
+  const record = {
+    schema_version: 1,
+    updated_at: now,
+    window_ms: STOP_REPEAT_GUARD_WINDOW_MS,
+    limit,
+    entries: {
+      ...entries,
+      [key]: {
+        kind,
+        route: state.route_command || state.route || state.mode || null,
+        mission_id: state.mission_id || null,
+        conversation_id: conversationId(payload),
+        first_seen: stopRepeatInWindow(prior, now) ? (prior.first_seen || now) : now,
+        last_seen: now,
+        repeat_count: repeatCount,
+        tripped: repeatCount >= limit,
+        reason
+      }
+    }
+  };
+  await writeJsonAtomic(guardPath, record).catch(() => null);
+  if (repeatCount < limit) return null;
+  return {
+    continue: true,
+    systemMessage: `SKS stop hook repeat guard suppressed repeated ${kind} prompt after ${repeatCount} identical block(s). No completion success is claimed by the hook.`
+  };
+}
+
+function stopRepeatKey(state = {}, payload = {}, reason = '', kind = '') {
+  return sha256(JSON.stringify({
+    kind,
+    reason,
+    conversation_id: conversationId(payload),
+    mission_id: state.mission_id || null,
+    route: state.route_command || state.route || state.mode || null,
+    gate: state.stop_gate || null
+  })).slice(0, 24);
+}
+
+function stopRepeatGuardLimit() {
+  const raw = Number.parseInt(process.env.SKS_STOP_REPEAT_GUARD_LIMIT || '', 10);
+  if (!Number.isFinite(raw)) return DEFAULT_STOP_REPEAT_GUARD_LIMIT;
+  return Math.max(1, Math.min(20, raw));
+}
+
+function stopRepeatInWindow(entry = {}, now = nowIso()) {
+  const last = Date.parse(entry.last_seen || '');
+  const current = Date.parse(now);
+  if (!Number.isFinite(last) || !Number.isFinite(current)) return false;
+  return current - last <= STOP_REPEAT_GUARD_WINDOW_MS;
+}
+
+function pruneStopRepeatEntries(entries = {}, now = nowIso()) {
+  return Object.fromEntries(Object.entries(entries)
+    .filter(([, entry]) => stopRepeatInWindow(entry, now))
+    .sort((a, b) => Date.parse(b[1]?.last_seen || '') - Date.parse(a[1]?.last_seen || ''))
+    .slice(0, STOP_REPEAT_GUARD_MAX_ENTRIES));
+}
+
 async function updateCheckContext(root, payload, prompt) {
   if (process.env.SKS_DISABLE_UPDATE_CHECK === '1') return '';
   const statePath = path.join(root, '.sneakoscope', 'state', 'update-check.json');