sneakoscope 0.6.77 → 0.6.79

package/README.md

@@ -47,7 +47,7 @@ sks selftest --mock
 | Codex App commands | Installs generated skills so `$Team`, `$From-Chat-IMG`, `$DFix`, `$QA-LOOP`, `$Goal`, `$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. |
+| QA loop | Dogfoods UI/API behavior with safety gates, Codex Computer Use-only UI evidence, safe fixes, and rechecks. |
 | Goal | Bridges SKS pipeline state to Codex native persisted `/goal` create, pause, resume, and clear workflows. |
 | 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. |
@@ -216,6 +216,7 @@ sks db scan --json
 sks wiki refresh
 sks wiki sweep latest --json
 sks wiki validate .sneakoscope/wiki/context-pack.json
+sks harness fixture --json
 sks gx init homepage
 sks gx render homepage --format html
 sks validate-artifacts latest --json
@@ -261,7 +262,7 @@ Generated app files include:
 
 Use `sks dollar-commands` to confirm that terminal discovery and Codex App prompt commands agree.
 
-TriWiki is intentionally sparse: `sks wiki sweep` records demote, soft-forget, archive, delete, promote-to-skill, and promote-to-rule candidates instead of injecting every old claim into future prompts. `sks code-structure scan` flags handwritten files above 1000/2000/3000-line thresholds so new logic can be extracted before command files become harder to maintain.
+TriWiki is intentionally sparse: `sks wiki sweep` records demote, soft-forget, archive, delete, promote-to-skill, and promote-to-rule candidates instead of injecting every old claim into future prompts. `sks harness fixture` validates the broader Harness Growth Factory contract: deliberate forgetting fixtures, skill card metadata, experiment schema, tool-error taxonomy, permission profiles, MultiAgentV2 defaults, and Cmux cockpit view coverage. `sks code-structure scan` flags handwritten files above 1000/2000/3000-line thresholds so new logic can be extracted before command files become harder to maintain.
 
 ## Prompt `$` Commands
 
@@ -327,7 +328,7 @@ sks qa-loop run latest --max-cycles 2
 sks qa-loop status latest
 ```
 
-Use `$QA-LOOP` in Codex App when Browser Use or Computer Use evidence should be part of the workflow.
+Use `$QA-LOOP` in Codex App when UI-level E2E needs verification. UI verification must use Codex Computer Use evidence only; Chrome MCP, Browser Use, Playwright, and other browser automation do not satisfy UI-level E2E verification.
 
 ### Refresh Context Before Risky Work
 

package/package.json

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

package/src/cli/main.mjs

@@ -35,6 +35,7 @@ import { createWorkOrderLedger } from '../core/work-order-ledger.mjs';
 import { buildFromChatImgVisualMap } from '../core/from-chat-img-forensics.mjs';
 import { classifyDogfoodFinding, createDogfoodReport, writeDogfoodReport } from '../core/dogfood-loop.mjs';
 import { createSkillCandidate, decideSkillInjection, writeSkillCandidate, writeSkillForgeReport, writeSkillInjectionDecision } from '../core/skill-forge.mjs';
+import { classifyToolError, harnessGrowthReport } from '../core/evaluation.mjs';
 import { recordMistake, writeMistakeMemoryReport } from '../core/mistake-memory.mjs';
 import { buildPromptContext } from '../core/prompt-context-builder.mjs';
 import { renderTeamDashboardState, writeTeamDashboardState } from '../core/team-dashboard-renderer.mjs';
@@ -42,7 +43,7 @@ import { GOAL_WORKFLOW_ARTIFACT } from '../core/goal-workflow.mjs';
 import { CODEX_APP_DOCS_URL, codexAppIntegrationStatus, formatCodexAppStatus } from '../core/codex-app.mjs';
 import { CMUX_BREW_COMMAND, CMUX_BREW_UPGRADE_COMMAND, buildCmuxLaunchPlan, buildCmuxNewWorkspaceArgs, cmuxSurfaceRefFromText, cmuxWorkspaceRef, cmuxWorkspaceRefFromText, cmuxReadiness, cmuxStatusKind, defaultCmuxWorkspaceName, ensureCmuxInstalled, formatCmuxBanner, launchCmuxTeamView, launchCmuxUi, matchingCmuxWorkspaces, parseCmuxWorkspaceList, platformCmuxInstallHint, readCmuxWorkspaceRecord, runCmuxStatus, sanitizeCmuxWorkspaceName, teamLaneStyle, writeCmuxWorkspaceRecord } from '../core/cmux-ui.mjs';
 import { autoReviewProfileName, autoReviewStatus, autoReviewSummary, enableAutoReview, disableAutoReview, enableMadHighProfile, madHighProfileName } from '../core/auto-review.mjs';
-import { buildTeamPlan, codeStructureCommand, defaultBeta, defaultVGraph, evalCommand, gcCommand, goalCommand, gxCommand, hproofCommand, memoryCommand, migrateWikiContextPack, parseTeamCreateArgs, perfCommand, profileCommand, projectWikiClaims, qaLoopCommand, researchCommand, statsCommand, team, teamWorkflowMarkdown, validateArtifactsCommand, wikiCommand, wikiVoxelRowCount, writeWikiContextPack } from './maintenance-commands.mjs';
+import { buildTeamPlan, codeStructureCommand, defaultBeta, defaultVGraph, evalCommand, gcCommand, goalCommand, gxCommand, harnessCommand, hproofCommand, memoryCommand, migrateWikiContextPack, parseTeamCreateArgs, perfCommand, profileCommand, projectWikiClaims, qaLoopCommand, researchCommand, statsCommand, team, teamWorkflowMarkdown, validateArtifactsCommand, wikiCommand, wikiVoxelRowCount, writeWikiContextPack } from './maintenance-commands.mjs';
 
 const flag = (args, name) => args.includes(name);
 const promptOf = (args) => args.filter((x) => !String(x).startsWith('--')).join(' ').trim();
@@ -107,6 +108,7 @@ export async function main(args) {
   if (cmd === 'team') return team(tail);
   if (cmd === 'db') return db(sub, rest);
   if (cmd === 'eval') return evalCommand(sub, rest);
+  if (cmd === 'harness') return harnessCommand(sub, rest);
   if (cmd === 'wiki') return wikiCommand(sub, rest);
   if (cmd === 'gc') return gcCommand(tail);
   if (cmd === 'stats') return statsCommand(tail);
@@ -175,6 +177,7 @@ Usage:
   sks eval run [--json] [--out report.json]
   sks eval compare --baseline old.json --candidate new.json [--json]
   sks perf run [--json]
+  sks harness fixture [--json]
   sks code-structure scan [--json]
   sks wiki coords --rgba 12,34,56,255
   sks wiki pack [--json] [--role worker|verifier] [--max-anchors N]
@@ -1477,6 +1480,7 @@ function usage(args = []) {
     'codex-app': ['Codex App', '', '  sks bootstrap', '  sks codex-app check', '  sks dollar-commands', '  cat .codex/SNEAKOSCOPE.md'],
     dollar: ['Dollar Commands', '', formatDollarCommandsCompact('  '), '', 'Terminal: sks dollar-commands [--json]'],
     wiki: ['TriWiki', '', '  sks wiki pack', '  sks wiki refresh [--prune]', '  sks wiki sweep latest --json', '  sks wiki validate .sneakoscope/wiki/context-pack.json', '  sks wiki prune --dry-run --json', '', 'Packs include attention.use_first and attention.hydrate_first for compact recall plus source hydration. Sweep records intentional forgetting and promotion candidates.'],
+    harness: ['Harness Growth', '', '  sks harness fixture --json', '  sks harness review --json', '', 'Runs deterministic fixtures for deliberate forgetting, skill cards, harness experiments, tool error taxonomy, permission profiles, MultiAgentV2, and Cmux cockpit views.'],
     'code-structure': ['Code Structure', '', '  sks code-structure scan', '  sks code-structure scan --json', '', 'Flags handwritten source files above 1000/2000/3000-line thresholds and records split-review exceptions.'],
     gx: ['GX', '', '  sks gx init architecture-atlas', '  sks gx render architecture-atlas --format all', '  sks gx validate architecture-atlas']
   };
@@ -2293,7 +2297,7 @@ async function selftest() {
   if (hookTeamPendingState.mission_id !== hookTeamState.mission_id) throw new Error('selftest failed: pending clarification allowed a new route mission to replace the visible question sheet');
   if (!hookTeamPendingContext.includes('Required questions still pending') || !hookTeamPendingContext.includes('VISIBLE RESPONSE CONTRACT') || !hookTeamPendingContext.includes('UI_STATE_BEHAVIOR')) throw new Error('selftest failed: pending clarification did not re-expose the question sheet');
   if (hookTeamPendingContext.includes('MANDATORY ambiguity-removal gate activated')) throw new Error('selftest failed: pending clarification prepared a new ambiguity gate instead of reusing the active one');
-  const hookTeamStopResult = await runProcess(process.execPath, [hookBin, 'hook', 'stop'], { cwd: hookTeamTmp, input: JSON.stringify({ cwd: hookTeamTmp, last_assistant_message: 'I will execute Team now.' }), env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 128 * 1024 });
+  const hookTeamStopResult = await runProcess(process.execPath, [hookBin, 'hook', 'stop'], { cwd: hookTeamTmp, input: JSON.stringify({ cwd: hookTeamTmp, last_assistant_message: 'I need three decisions before implementation, but I will not paste the Required questions block.' }), env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 128 * 1024 });
   if (hookTeamStopResult.code !== 0) throw new Error(`selftest failed: Team stop hook exited ${hookTeamStopResult.code}: ${hookTeamStopResult.stderr}`);
   const hookTeamStopJson = JSON.parse(hookTeamStopResult.stdout);
   if (hookTeamStopJson.decision !== 'block' || !String(hookTeamStopJson.reason || '').includes('mandatory ambiguity-removal')) throw new Error('selftest failed: Stop hook did not block missing Team ambiguity answers');
@@ -2303,6 +2307,13 @@ async function selftest() {
   if (!String(hookTeamStopJson.reason || '').includes('Codex plan-tool interaction')) throw new Error('selftest failed: Stop hook did not reprint plan-tool guidance');
   if (!String(hookTeamStopJson.reason || '').includes('VISIBLE RESPONSE CONTRACT')) throw new Error('selftest failed: Stop hook did not force visible clarification response');
   const hookTeamSchema = await readJson(path.join(missionDir(hookTeamTmp, hookTeamState.mission_id), 'required-answers.schema.json'));
+  const visibleQuestionsBlock = [
+    'Required questions',
+    ...hookTeamSchema.slots.map((slot, idx) => `${idx + 1}. ${slot.id}: ${slot.question}`),
+    'Reply by slot id, then I will write answers.json and run sks pipeline answer latest answers.json.'
+  ].join('\n');
+  const visibleQuestionDecision = await evaluateStop(hookTeamTmp, hookTeamState, { last_assistant_message: visibleQuestionsBlock }, { noQuestion: false });
+  if (!visibleQuestionDecision?.continue) throw new Error('selftest failed: visible Required questions block was not accepted by clarification stop gate');
   const nonGoalsSlot = hookTeamSchema.slots.find((s) => s.id === 'NON_GOALS');
   if (nonGoalsSlot && !nonGoalsSlot.allow_empty) throw new Error('selftest failed: NON_GOALS does not allow an empty array answer');
   if (!nonGoalsSlot && !Array.isArray(hookTeamSchema.inferred_answers?.NON_GOALS)) throw new Error('selftest failed: NON_GOALS was neither asked nor inferred');
@@ -2367,6 +2378,8 @@ async function selftest() {
   const hookQaJson = JSON.parse(hookQaResult.stdout);
   const hookQaContext = hookQaJson.hookSpecificOutput?.additionalContext || '';
   if (!hookQaContext.includes('MANDATORY ambiguity-removal gate activated') || !hookQaContext.includes('QA_SCOPE') || !hookQaContext.includes('UI_COMPUTER_USE_ACK')) throw new Error('selftest failed: $QA-LOOP hook did not provide QA-specific questions');
+  if (!hookQaContext.includes('Codex Computer Use') || !hookQaContext.includes('Playwright') || !hookQaContext.includes('Chrome MCP')) throw new Error('selftest failed: $QA-LOOP hook did not state Computer Use-only UI policy');
+  if (hookQaContext.includes('Browser Use 또는 Computer Use') || hookQaContext.includes('Browser/Computer Use evidence')) throw new Error('selftest failed: $QA-LOOP hook still allows Browser Use as UI evidence');
   const hookQaState = await readJson(stateFile(hookQaTmp), {});
   if (hookQaState.phase !== 'QALOOP_CLARIFICATION_AWAITING_ANSWERS' || hookQaState.implementation_allowed !== false) throw new Error('selftest failed: $QA-LOOP hook did not lock execution behind ambiguity gate');
   const hookQaSchema = await readJson(path.join(missionDir(hookQaTmp, hookQaState.mission_id), 'required-answers.schema.json'));
@@ -2397,6 +2410,8 @@ async function selftest() {
   if (unresolvedQaGate.passed || !unresolvedQaGate.reasons.includes('unresolved_fixable_findings_remaining')) throw new Error('selftest failed: unresolved fixable QA finding was accepted');
   const promptQa = buildQaLoopPrompt({ id: 'selftest', mission: { prompt: 'QA and fix' }, contract: { answers: { QA_CORRECTIVE_POLICY: 'apply_safe_fixes_and_reverify' } }, cycle: 1, previous: '', reportFile: qaReportFile });
   if (!promptQa.includes('dogfood as human proxy') || !promptQa.includes('fix safe code/test/docs now') || !promptQa.includes('post_fix_verification_complete')) throw new Error('selftest failed: QA-LOOP dogfood prompt');
+  if (!promptQa.includes('Codex Computer Use evidence only') || !promptQa.includes('Chrome MCP') || !promptQa.includes('Playwright')) throw new Error('selftest failed: QA-LOOP prompt did not enforce Computer Use-only UI evidence');
+  if (promptQa.includes('Browser/Computer Use evidence')) throw new Error('selftest failed: QA-LOOP prompt still allows Browser/Computer UI evidence');
   const pkgQa = defaultQaGate({ sealed_hash: 'selftest', answers: { QA_SCOPE: 'all_available', TARGET_BASE_URL: 'none', API_BASE_URL: 'same_as_target', TARGET_ENVIRONMENT: 'local_dev_server', DESTRUCTIVE_DEPLOYED_TESTS_ALLOWED: 'never' } });
   if (pkgQa.ui_e2e_required || pkgQa.api_e2e_required || !pkgQa.ui_computer_use_evidence) throw new Error('selftest failed: package QA target gate');
   const qaRunResult = await runProcess(process.execPath, [hookBin, 'qa-loop', 'run', 'latest', '--mock'], { cwd: hookQaTmp, env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
@@ -2764,7 +2779,7 @@ async function selftest() {
   if (teamDashboard?.agent_session_count !== 5 || teamDashboard?.role_counts?.executor !== 5) throw new Error('selftest failed: team dashboard session/role budget missing');
   await writeTeamDashboardState(teamDir, { missionId: teamId, mission: { id: teamId, mode: 'team' }, effort: 'high', phase: 'verification' });
   const teamDashboardState = await readJson(path.join(teamDir, ARTIFACT_FILES.team_dashboard_state), {});
-  if (!validateTeamDashboardState(teamDashboardState).ok || !renderTeamDashboardState(teamDashboardState).includes('Mission Overview')) throw new Error('selftest failed: Team dashboard state missing required cockpit panes');
+  if (!validateTeamDashboardState(teamDashboardState).ok || !renderTeamDashboardState(teamDashboardState).includes('Mission / Goal View')) throw new Error('selftest failed: Team dashboard state missing required cockpit panes');
   if (teamDashboard?.context_tracking?.ssot !== 'triwiki') throw new Error('selftest failed: team dashboard missing TriWiki context tracking');
   if (!teamDashboard?.phases?.includes('parallel_analysis_scouting')) throw new Error('selftest failed: team dashboard missing analysis scout phase');
   if (!teamDashboard?.latest_messages?.some((entry) => entry.agent === 'analysis_scout_1')) throw new Error('selftest failed: team live dashboard missing analysis scout event');
@@ -2820,6 +2835,9 @@ async function selftest() {
   if (!evalReport.comparison.meaningful_improvement) throw new Error('selftest failed: evaluation benchmark did not show meaningful improvement');
   if (!evalReport.candidate.wiki?.valid) throw new Error('selftest failed: wiki coordinate index invalid in eval');
   if (evalReport.candidate.wiki?.voxel_schema !== 'sks.wiki-voxel.v1' || evalReport.candidate.wiki?.voxel_rows < 1) throw new Error('selftest failed: eval did not include voxel overlay metrics');
+  const harnessReport = harnessGrowthReport({});
+  if (!harnessReport.forgetting.fixture.passed || !harnessReport.cmux.views.includes('Harness Experiments View') || !harnessReport.reliability.tool_error_taxonomy.includes('Unknown')) throw new Error('selftest failed: harness growth fixture incomplete');
+  if (classifyToolError({ message: 'operation timed out' }) !== 'Timeout' || classifyToolError({ message: 'unclassified weirdness' }) !== 'Unknown') throw new Error('selftest failed: tool error taxonomy classification');
   const coord = rgbaToWikiCoord({ r: 12, g: 34, b: 56, a: 255 });
   if (coord.schema !== 'sks.wiki-coordinate.v1' || coord.xyzw.length !== 4) throw new Error('selftest failed: RGBA wiki coordinate conversion');
   await writeTextAtomic(path.join(tmp, '.sneakoscope', 'memory', 'q2_facts', 'selftest.md'), '- claim: Selftest memory claim must be selected before lower-weight mission notes. | id: selftest-memory-priority | source: src/cli/main.mjs | risk: high | status: supported | evidence_count: 3 | required_weight: 1.0 | trust_score: 0.9\n');

package/src/cli/maintenance-commands.mjs

@@ -31,6 +31,7 @@ import { cleanupCmuxTeamView, launchCmuxTeamView } from '../core/cmux-ui.mjs';
 import { writeSkillForgeReport } from '../core/skill-forge.mjs';
 import { writeMistakeMemoryReport } from '../core/mistake-memory.mjs';
 import { scanDbSafety } from '../core/db-safety.mjs';
+import { harnessGrowthReport, writeHarnessGrowthReport } from '../core/evaluation.mjs';
 
 const flag = (args, name) => args.includes(name);
 const promptOf = (args) => args.filter((x) => !String(x).startsWith('--')).join(' ').trim();
@@ -64,6 +65,9 @@ Usage:
 
 Prompt route:
   $QA-LOOP dogfood UI/API, fix safe issues, reverify
+
+UI evidence:
+  Codex Computer Use only for UI-level E2E; do not use Chrome MCP, Browser Use, Playwright, or other browser automation as UI verification evidence.
 `);
 }
 
@@ -417,6 +421,25 @@ export async function perfCommand(sub, args = []) {
   console.log(`Report: ${path.relative(root, outPath)}`);
 }
 
+export async function harnessCommand(sub, args = []) {
+  const action = sub || 'fixture';
+  if (!['fixture', 'review'].includes(action)) {
+    console.error('Usage: sks harness fixture|review [--json]');
+    process.exitCode = 1;
+    return;
+  }
+  const root = await sksRoot();
+  const report = action === 'review'
+    ? await writeHarnessGrowthReport(root, path.join(root, '.sneakoscope', 'reports'), {})
+    : harnessGrowthReport({});
+  if (flag(args, '--json')) return console.log(JSON.stringify(report, null, 2));
+  console.log('SKS Harness Growth');
+  console.log(`Forgetting fixture: ${report.forgetting.fixture.passed ? 'pass' : 'fail'}`);
+  console.log(`Cmux views: ${report.cmux.views.length}`);
+  console.log(`Tool taxonomy: ${report.reliability.tool_error_taxonomy.join(', ')}`);
+  console.log(`Unknown errors recorded as bugs: ${report.reliability.unknown_errors_are_bugs ? 'yes' : 'no'}`);
+}
+
 export async function codeStructureCommand(sub, args = []) {
   const action = sub || 'scan';
   if (action !== 'scan') {
@@ -1211,6 +1234,7 @@ export async function team(args) {
   });
   await writeWorkOrderLedger(dir, workOrder);
   if (fromChatImgRequired) await writeFromChatImgArtifacts(dir, { missionId: id, requests: [{ verbatim: prompt }], ambiguities: ['image source inventory must be completed before implementation'] });
+  await writeHarnessGrowthReport(root, dir, {});
   let dashboardState = await writeTeamDashboardState(dir, { missionId: id, mission: { id, mode: 'team' }, effort: effortDecision.selected_effort, phase: 'intake', next_action: fromChatImgRequired ? 'complete visual source inventory and work-order mapping' : 'run Team analysis scouts' });
   await writeJsonAtomic(path.join(dir, 'team-gate.json'), { passed: false, team_roster_confirmed: true, analysis_artifact: false, triwiki_refreshed: false, triwiki_validated: false, consensus_artifact: false, ...runtime.gate_fields, implementation_team_fresh: false, review_artifact: false, integration_evidence: false, session_cleanup: false, context7_evidence: false, ...(fromChatImgRequired ? { from_chat_img_required: true, from_chat_img_request_coverage: false } : {}) });
   dashboardState = await writeTeamDashboardState(dir, { missionId: id, mission: { id, mode: 'team' }, effort: effortDecision.selected_effort, phase: 'intake', next_action: fromChatImgRequired ? 'complete visual source inventory and work-order mapping' : 'run Team analysis scouts' });

package/src/core/artifact-schemas.mjs

@@ -17,6 +17,7 @@ export const ARTIFACT_FILES = {
   memory_sweep_report: 'memory-sweep-report.json',
   skill_forge_report: 'skill-forge-report.json',
   mistake_memory_report: 'mistake-memory-report.json',
+  harness_growth_report: 'harness-growth-report.json',
   code_structure_report: 'code-structure-report.json',
   team_dashboard_state: 'team-dashboard-state.json',
   cmux_pane_plan: 'cmux-pane-plan.json',
@@ -163,6 +164,21 @@ export function validateMistakeMemoryReport(data = {}) {
   return validationResult('MistakeMemoryReport', errors);
 }
 
+export function validateHarnessGrowthReport(data = {}) {
+  const errors = [];
+  pushMissing(errors, isObj(data.forgetting), 'forgetting_missing');
+  pushMissing(errors, isObj(data.skills), 'skills_missing');
+  pushMissing(errors, isObj(data.experiments), 'experiments_missing');
+  pushMissing(errors, isObj(data.codex_native), 'codex_native_missing');
+  pushMissing(errors, isObj(data.cmux), 'cmux_missing');
+  pushMissing(errors, isObj(data.reliability), 'reliability_missing');
+  if (data.forgetting?.fixture?.passed !== true) errors.push('forgetting_fixture_failed');
+  if (!Array.isArray(data.reliability?.tool_error_taxonomy) || !data.reliability.tool_error_taxonomy.includes('Unknown')) errors.push('tool_error_taxonomy_missing_unknown');
+  if (data.reliability?.unknown_errors_are_bugs !== true) errors.push('unknown_errors_not_marked_bug');
+  if (!Array.isArray(data.cmux?.views) || data.cmux.views.length < 10) errors.push('cmux_views_incomplete');
+  return validationResult('HarnessGrowthReport', errors);
+}
+
 export function validateCodeStructureReport(data = {}) {
   const errors = [];
   pushMissing(errors, isObj(data.thresholds), 'thresholds_missing');
@@ -179,7 +195,7 @@ export function validateTeamDashboardState(data = {}) {
   pushMissing(errors, Array.isArray(data.gates), 'gates_not_array');
   pushMissing(errors, Array.isArray(data.agents), 'agents_not_array');
   pushMissing(errors, Array.isArray(data.tasks), 'tasks_not_array');
-  for (const pane of ['Mission Overview', 'Agent Lanes', 'Task DAG', 'QA and Dogfood', 'Artifacts and Evidence', 'Performance']) {
+  for (const pane of ['Mission / Goal View', 'Agent Grid View', 'MultiAgentV2 Graph View', 'Work Order Ledger View', 'Skill Autopilot View', 'TriWiki Memory Health View', 'Forget Queue', 'Mistake Immunity', 'Tool Reliability View', 'Harness Experiments View', 'Dogfood Evidence View', 'Code Structure']) {
     if (!arr(data.panes).includes(pane)) errors.push(`pane_missing:${pane}`);
   }
   if (arr(data.gates).some((gate) => !GATE_STATUSES.has(gate.status))) errors.push('gate_status_invalid');
@@ -214,6 +230,7 @@ export const ARTIFACT_VALIDATORS = {
   memory_sweep_report: validateMemorySweepReport,
   skill_forge_report: validateSkillForgeReport,
   mistake_memory_report: validateMistakeMemoryReport,
+  harness_growth_report: validateHarnessGrowthReport,
   code_structure_report: validateCodeStructureReport,
   team_dashboard_state: validateTeamDashboardState,
   cmux_pane_plan: validateCmuxPanePlan,

package/src/core/codex-app.mjs

@@ -128,10 +128,10 @@ export function codexAppGuidance({ appInstalled, codex, mcpList, computerUseRead
   }
   if (appInstalled && (!computerUseReady || !browserUseReady)) {
     lines.push('Open Codex App settings, enable recommended MCP/plugin tools, then restart Codex CLI sessions.');
-    lines.push('Required for SKS QA-LOOP priority order: Browser Use for local browser targets, Computer Use for desktop/app/browser evidence.');
+    lines.push('Required for SKS QA-LOOP UI evidence: Codex Computer Use only. Browser Use can support non-UI browser context, but it does not satisfy UI-level E2E verification.');
     lines.push('Verify with: codex mcp list');
   }
-  if (!lines.length) lines.push('Codex App, Codex CLI, Computer Use, and Browser Use checks look ready.');
+  if (!lines.length) lines.push('Codex App, Codex CLI, Computer Use, and Browser Use checks look ready. UI-level E2E verification still requires Codex Computer Use evidence.');
   return lines;
 }
 

package/src/core/decision-contract.mjs

@@ -82,7 +82,7 @@ export function buildDecisionContract({ mission, schema, answers }) {
       qa_loop_target_environment: answers.TARGET_ENVIRONMENT || null,
       qa_loop_mutation_policy: answers.QA_MUTATION_POLICY || null,
       qa_loop_credentials_saved: false,
-      qa_loop_ui_requires_official_browser_or_computer_use: Boolean(answers.QA_SCOPE && answers.QA_SCOPE !== 'api_e2e_only'),
+      qa_loop_ui_requires_codex_computer_use_only: Boolean(answers.QA_SCOPE && answers.QA_SCOPE !== 'api_e2e_only'),
       unrequested_fallback_code_allowed: false,
       mad_sks_mode: madSks ? 'explicit_invocation_only' : false,
       production_database_writes_allowed: madSks ? 'mad_sks_scoped' : false,

package/src/core/evaluation.mjs

@@ -1,4 +1,5 @@
-import { nowIso, sha256 } from './fsx.mjs';
+import path from 'node:path';
+import { nowIso, sha256, writeJsonAtomic } from './fsx.mjs';
 import { contextCapsule } from './triwiki-attention.mjs';
 import { validateWikiCoordinateIndex } from './wiki-coordinate.mjs';
 
@@ -10,15 +11,359 @@ export const DEFAULT_EVAL_THRESHOLDS = Object.freeze({
   max_candidate_build_ms_per_run: 25
 });
 
+export const HARNESS_GROWTH_REPORT = 'harness-growth-report.json';
+
+export const MEMORY_LIFECYCLE_STATES = Object.freeze([
+  'ACTIVE',
+  'PINNED',
+  'DORMANT',
+  'STALE',
+  'DUPLICATE',
+  'CONFLICTED',
+  'QUARANTINED',
+  'ARCHIVED',
+  'DISABLED',
+  'DELETE_CANDIDATE',
+  'DELETED'
+]);
+
+export const FORGETTING_ACTIONS = Object.freeze([
+  'KEEP_ACTIVE',
+  'PIN',
+  'UNPIN',
+  'UPDATE',
+  'CONSOLIDATE',
+  'DEMOTE',
+  'DISABLE',
+  'ARCHIVE',
+  'QUARANTINE',
+  'HARD_DELETE',
+  'NOOP',
+  'PROMOTE_SKILL',
+  'PROMOTE_RULE',
+  'PROMOTE_TEST'
+]);
+
+export const TOOL_ERROR_TAXONOMY = Object.freeze([
+  'InvalidArguments',
+  'UnexpectedEnvironment',
+  'ProviderError',
+  'UserAborted',
+  'Timeout',
+  'PermissionDenied',
+  'NetworkDenied',
+  'ResourceExhausted',
+  'Conflict',
+  'Unknown'
+]);
+
+export const DEFAULT_FORGETTING_THRESHOLDS = Object.freeze({
+  wiki_claim: { stale_after_days: 60, dormant_after_days_without_use: 90, archive_after_days_without_use: 150, hard_delete_after_days_without_use: 240 },
+  wiki_page: { stale_after_days: 90, archive_after_days_without_use: 180, hard_delete_after_days_without_use: 365 },
+  codex_memory: { stale_after_days: 60, hard_delete_after_days_without_use: 180 },
+  skill: { stale_after_days_without_use: 45, disable_after_days_without_use: 90, archive_after_days_without_use: 180, hard_delete_after_days_without_use: 270 },
+  mistake_fingerprint: { stale_after_days_without_recurrence: 180, archive_after_days_without_recurrence: 365, hard_delete_after_days_without_recurrence: 540 },
+  temporary_artifact: { archive_after_days: 14, hard_delete_after_days: 45 }
+});
+
+export const PERMISSION_PROFILES = Object.freeze({
+  read_only_explorer: { filesystem: 'read-only', network: 'disabled_or_limited', purpose: 'Map code, collect evidence, no writes.' },
+  workspace_worker: { filesystem: 'workspace-write', network: 'disabled_by_default', purpose: 'Implement local code changes safely.' },
+  dogfood_browser: { filesystem: 'workspace-write', network: 'localhost_and_required_docs', purpose: 'Run app/browser dogfood and collect evidence.' },
+  harness_research: { filesystem: 'workspace-write', network: 'limited_allowlist', purpose: 'Fetch official docs/research for harness improvements.' },
+  dangerous_full_access: { filesystem: 'full-access', network: 'controlled', purpose: 'Never default. Requires explicit reason and review.' }
+});
+
+export const DEFAULT_MULTIAGENT_V2 = Object.freeze({
+  max_threads: 6,
+  max_depth: 1,
+  job_max_runtime_seconds: 1800,
+  wait_control: 'bounded_wait_then_structured_summary',
+  subagent_output: 'structured_summary_only'
+});
+
+export const CMUX_COCKPIT_VIEWS = Object.freeze([
+  'Mission / Goal View',
+  'Agent Grid View',
+  'MultiAgentV2 Graph View',
+  'Work Order Ledger View',
+  'Skill Autopilot View',
+  'TriWiki Memory Health View',
+  'Forget Queue View',
+  'Mistake Immunity View',
+  'Tool Reliability View',
+  'Harness Experiments View',
+  'Dogfood Evidence View',
+  'Code Structure View',
+  'Statusline / Terminal Title Preview'
+]);
+
 export function estimateTokens(value) {
   const text = typeof value === 'string' ? value : JSON.stringify(value);
   return Math.max(1, Math.ceil(String(text || '').length / 4));
 }
 
+export function classifyToolError(input = {}) {
+  const text = `${input.code || ''} ${input.name || ''} ${input.message || ''} ${input.stderr || ''}`.toLowerCase();
+  if (/invalid|required|schema|argument|parameter|json/.test(text)) return 'InvalidArguments';
+  if (/enoent|not found|cwd|path|missing file|environment|not installed/.test(text)) return 'UnexpectedEnvironment';
+  if (/provider|upstream|api error|5\d\d|service unavailable/.test(text)) return 'ProviderError';
+  if (/abort|cancel|interrupted|user stopped/.test(text)) return 'UserAborted';
+  if (/timeout|timed out|deadline/.test(text)) return 'Timeout';
+  if (/permission|denied|not allowed|approval|sandbox/.test(text)) return 'PermissionDenied';
+  if (/network|dns|eai_again|enotfound|offline/.test(text)) return 'NetworkDenied';
+  if (/rate limit|quota|memory|resource|emfile|enospc|token limit|too large/.test(text)) return 'ResourceExhausted';
+  if (/conflict|merge|lock|concurrent|dirty/.test(text)) return 'Conflict';
+  return 'Unknown';
+}
+
+export function utilityScore(object = {}) {
+  const evidence = Math.min(20, Number(object.evidence_count || 0) * 4);
+  const successfulUse = Math.min(16, Number(object.success_count || object.use_count || 0) * 3);
+  const recency = daysSince(object.updated_at || object.last_used_at || object.created_at) <= 30 ? 14 : 4;
+  const uniqueness = object.duplicate_of ? -18 : 10;
+  const trust = Math.round(Number(object.trust_score ?? 0.5) * 18);
+  const riskPrevention = object.regression_prevention ? 12 : 0;
+  const penalties = [
+    object.stale ? 14 : 0,
+    object.conflicted ? 28 : 0,
+    object.failed_use ? 10 : 0,
+    object.prompt_bloat ? 8 : 0,
+    object.security_risk ? 80 : 0,
+    object.maintenance_cost ? 8 : 0
+  ].reduce((a, b) => a + b, 0);
+  return clamp(0, 100, recency + evidence + successfulUse + uniqueness + trust + riskPrevention - penalties);
+}
+
+export function forgettingDecision(object = {}, opts = {}) {
+  const state = String(object.lifecycle_state || object.status || '').toUpperCase();
+  const score = utilityScore(object);
+  if (isPinned(object)) return decision('KEEP_ACTIVE', 'PINNED', score, ['retention_exempt']);
+  if (containsSecret(object)) return decision('HARD_DELETE', 'DELETED', score, ['secret_or_sensitive_content'], true);
+  if (object.poisoned || object.unsafe_instruction) return decision('HARD_DELETE', 'DELETED', score, ['poisoned_or_unsafe'], true);
+  if (object.known_false) return decision('QUARANTINE', 'QUARANTINED', score, ['known_false']);
+  if (object.duplicate_of) return decision('CONSOLIDATE', 'DUPLICATE', score, ['duplicate']);
+  if (object.conflicted || state === 'CONFLICTED') return decision('QUARANTINE', 'CONFLICTED', score, ['conflict_requires_resolution']);
+  if (object.repeated_success && Number(object.success_count || 0) >= 3) return decision('PROMOTE_SKILL', 'ACTIVE', score, ['verified_repetition']);
+  if (object.repeated_mistake && !object.regression_test) return decision('PROMOTE_TEST', 'ACTIVE', score, ['mistake_without_test']);
+  if (object.stale && Number(object.evidence_count || 0) >= 3 && Number(object.trust_score || 0) >= 0.65) return decision('DEMOTE', 'STALE', score, ['stale_but_useful_verify_before_use']);
+  if (score < 20 && graceChecksPass(object, opts)) return decision('HARD_DELETE', 'DELETED', score, ['old_unused_low_utility'], false, tombstone(object, opts));
+  if (score < 40) return decision('ARCHIVE', 'ARCHIVED', score, ['low_utility']);
+  if (score < 60 || object.stale) return decision(object.type === 'skill' ? 'DISABLE' : 'DEMOTE', object.type === 'skill' ? 'DISABLED' : 'STALE', score, ['stale_or_watch']);
+  return decision('KEEP_ACTIVE', 'ACTIVE', score, ['useful_current']);
+}
+
+export function createSkillCard(input = {}) {
+  return {
+    skill_id: input.skill_id || input.id || `skill.${safeId(input.name || 'candidate')}`,
+    name: input.name || input.skill_id || 'Candidate Skill',
+    version: input.version || '1.0.0',
+    status: input.status || 'active',
+    created_at: input.created_at || nowIso(),
+    updated_at: input.updated_at || nowIso(),
+    last_used_at: input.last_used_at || null,
+    use_count: Number(input.use_count || 0),
+    success_count: Number(input.success_count || 0),
+    failure_count: Number(input.failure_count || 0),
+    false_trigger_count: Number(input.false_trigger_count || 0),
+    owner: input.owner || 'harness',
+    trigger_summary: input.trigger_summary || '',
+    anti_triggers: input.anti_triggers || [],
+    inputs: input.inputs || [],
+    outputs: input.outputs || [],
+    validation: input.validation || { commands: [], manual_checks: [], schemas: [] },
+    risk_notes: input.risk_notes || [],
+    retirement_conditions: input.retirement_conditions || ['stale without use', 'repeated false trigger', 'validation no longer runs'],
+    related_mistake_fingerprints: input.related_mistake_fingerprints || [],
+    related_wiki_entries: input.related_wiki_entries || [],
+    plugin_distribution: input.plugin_distribution || 'none',
+    implicit_invocation_allowed: input.implicit_invocation_allowed !== false
+  };
+}
+
+export function createHarnessExperiment(input = {}) {
+  return {
+    experiment_id: input.experiment_id || `exp.${safeId(input.title || 'harness')}.${sha256(JSON.stringify(input)).slice(0, 8)}`,
+    title: input.title || 'Harness experiment',
+    owner: 'harness_growth',
+    created_at: input.created_at || nowIso(),
+    status: input.status || 'draft',
+    vision_alignment: input.vision_alignment || 'Improve verified task outcomes while reducing context bloat.',
+    hypothesis: input.hypothesis || '',
+    change_surface: input.change_surface || ['eval'],
+    variant_a: input.variant_a || 'baseline',
+    variant_b: input.variant_b || 'candidate',
+    risk_level: input.risk_level || 'low',
+    rollback_plan: input.rollback_plan || 'revert candidate surface and re-run smoke shard',
+    offline_eval_suite: input.offline_eval_suite || ['sneakoscopebench:smoke'],
+    online_metrics: input.online_metrics || ['latency_p95_ms', 'token_input', 'tool_error_rate', 'keep_rate', 'context_bloat_score'],
+    launch_gate: input.launch_gate || {
+      min_quality_delta: '>= 0',
+      max_latency_regression: '<= 10%',
+      max_cost_regression: '<= 10%',
+      max_error_regression: '<= 0',
+      required_evidence: 'offline eval plus rollback plan'
+    },
+    post_launch_monitoring: input.post_launch_monitoring || { duration_days: 7, alert_thresholds: { unknown_error_rate: 0, repeated_mistake_rate: 0 } }
+  };
+}
+
+export function buildHarnessGrowthFixture() {
+  const old = isoDaysAgo(400);
+  const recent = isoDaysAgo(2);
+  return [
+    { id: 'pinned-user-rule', type: 'wiki_claim', lifecycle_state: 'PINNED', pinned: true, trust_score: 0.95, updated_at: old },
+    { id: 'old-unused-wiki', type: 'wiki_page', trust_score: 0.2, updated_at: old, use_count: 0, stale: true },
+    { id: 'duplicate-claim', type: 'wiki_claim', duplicate_of: 'better-claim', trust_score: 0.5, updated_at: old },
+    { id: 'stale-useful-architecture', type: 'wiki_claim', trust_score: 0.7, evidence_count: 3, stale: true, updated_at: isoDaysAgo(95) },
+    { id: 'poisoned-memory', type: 'memory', poisoned: true, trust_score: 0.1, updated_at: recent },
+    { id: 'old-unused-skill', type: 'skill', trust_score: 0.2, updated_at: old, false_trigger_count: 2, use_count: 0 },
+    { id: 'recent-successful-skill', type: 'skill', trust_score: 0.9, updated_at: recent, success_count: 4, repeated_success: true },
+    { id: 'secret-memory', type: 'memory', text: 'token=sk-live-secret-value', updated_at: recent },
+    { id: 'mistake-no-test', type: 'mistake_fingerprint', trust_score: 0.9, regression_prevention: true, repeated_mistake: true, regression_test: null, updated_at: recent }
+  ];
+}
+
+export function runHarnessGrowthFixture() {
+  const objects = buildHarnessGrowthFixture();
+  const decisions = objects.map((object) => ({ id: object.id, ...forgettingDecision(object, { now: new Date() }) }));
+  const byId = Object.fromEntries(decisions.map((item) => [item.id, item]));
+  const checks = {
+    pinned_rule_remains: byId['pinned-user-rule'].action === 'KEEP_ACTIVE',
+    old_wiki_leaves_active: ['ARCHIVE', 'HARD_DELETE'].includes(byId['old-unused-wiki'].action),
+    duplicate_consolidates: byId['duplicate-claim'].action === 'CONSOLIDATE',
+    stale_useful_stays_hydratable: ['DEMOTE', 'KEEP_ACTIVE'].includes(byId['stale-useful-architecture'].action),
+    poisoned_removed: ['HARD_DELETE', 'QUARANTINE'].includes(byId['poisoned-memory'].action),
+    old_skill_disabled_or_removed: ['DISABLE', 'ARCHIVE', 'HARD_DELETE'].includes(byId['old-unused-skill'].action),
+    recent_skill_active_or_promoted: ['KEEP_ACTIVE', 'PROMOTE_SKILL'].includes(byId['recent-successful-skill'].action),
+    secret_hard_deleted: byId['secret-memory'].action === 'HARD_DELETE',
+    uncovered_mistake_kept_for_test: byId['mistake-no-test'].action === 'PROMOTE_TEST'
+  };
+  return {
+    schema_version: 1,
+    fixture: 'memory_sweep_fixture',
+    created_at: nowIso(),
+    decisions,
+    checks,
+    passed: Object.values(checks).every(Boolean)
+  };
+}
+
+export function harnessGrowthReport(input = {}) {
+  const fixture = runHarnessGrowthFixture();
+  const toolErrors = (input.tool_errors || [
+    { message: 'operation timed out after 30s' },
+    { message: 'unexpected provider 500' },
+    { message: 'unmatched example for taxonomy coverage' }
+  ]).map((error) => ({ ...error, classification: classifyToolError(error), unknown_is_bug: classifyToolError(error) === 'Unknown' }));
+  return {
+    schema_version: 1,
+    generated_at: nowIso(),
+    forgetting: {
+      lifecycle_states: MEMORY_LIFECYCLE_STATES,
+      actions: FORGETTING_ACTIONS,
+      thresholds: DEFAULT_FORGETTING_THRESHOLDS,
+      fixture
+    },
+    skills: {
+      card_schema_example: createSkillCard({
+        skill_id: 'skill.harness.weekly-review',
+        name: 'Weekly Harness Review',
+        trigger_summary: 'Run on weekly harness review automation or explicit harness growth request.',
+        validation: { commands: ['sks harness fixture --json'], manual_checks: ['review proposed deletions before live hard-delete'], schemas: ['harness-growth-report.json'] }
+      })
+    },
+    experiments: {
+      registry_schema_example: createHarnessExperiment({
+        title: 'Visible ambiguity question delivery',
+        hypothesis: 'Stop gates that require visible question blocks reduce hidden clarification failures.',
+        change_surface: ['prompt', 'tool', 'eval'],
+        offline_eval_suite: ['selftest:team-visible-questions']
+      })
+    },
+    codex_native: {
+      permission_profiles: PERMISSION_PROFILES,
+      multiagent_v2: DEFAULT_MULTIAGENT_V2,
+      goal_checkpoint_required_fields: ['goal_id', 'phase', 'summary', 'completed_checkboxes', 'open_checkboxes', 'blockers', 'evidence'],
+      external_session_import: 'structured_summary_only_with_utility_score_and_forgetting_metadata'
+    },
+    cmux: {
+      views: CMUX_COCKPIT_VIEWS,
+      status_terms: ['idle', 'planning', 'exploring', 'implementing', 'waiting_for_tool', 'waiting_for_approval', 'dogfooding', 'verifying', 'summarizing', 'blocked', 'failed', 'completed', 'paused', 'resuming']
+    },
+    reliability: {
+      tool_error_taxonomy: TOOL_ERROR_TAXONOMY,
+      classified_errors: toolErrors,
+      unknown_errors_are_bugs: true
+    },
+    validation: {
+      fixture_passed: fixture.passed,
+      unknown_errors_recorded: toolErrors.filter((e) => e.classification === 'Unknown').length
+    }
+  };
+}
+
+export async function writeHarnessGrowthReport(root, dir, input = {}) {
+  const report = harnessGrowthReport(input);
+  await writeJsonAtomic(path.join(dir || path.join(root, '.sneakoscope', 'reports'), HARNESS_GROWTH_REPORT), report);
+  return report;
+}
+
 function clamp01(x) {
   return Math.max(0, Math.min(1, Number.isFinite(x) ? x : 0));
 }
 
+function decision(action, lifecycle_state, utility_score, reason_codes, immediate = false, tombstoneMeta = null) {
+  return { action, lifecycle_state, utility_score, reason_codes, immediate, tombstone: tombstoneMeta };
+}
+
+function isPinned(object = {}) {
+  return object.pinned === true || String(object.lifecycle_state || '').toUpperCase() === 'PINNED';
+}
+
+function containsSecret(object = {}) {
+  const text = JSON.stringify(object);
+  return /(sk-|ghp_|glpat-|xox[baprs]-|AKIA[0-9A-Z]{16}|secret|private[_-]?key|token=|password=)/i.test(text);
+}
+
+function graceChecksPass(object = {}, opts = {}) {
+  if (isPinned(object)) return false;
+  if (object.active_work_order || object.required_by_skill_validation || object.only_source_for_user_preference) return false;
+  if (object.only_source_for_mistake_prevention && !object.regression_test) return false;
+  if (daysSince(object.last_used_at || object.updated_at || object.created_at, opts.now) < 90) return false;
+  return true;
+}
+
+function tombstone(object = {}, opts = {}) {
+  return {
+    deleted_object_id: safeId(object.id || sha256(JSON.stringify(object)).slice(0, 16)),
+    object_type: object.type || 'memory',
+    deleted_at: nowIso(),
+    reason: opts.reason || 'old-unused-low-utility',
+    replacement_id: object.replacement_id || object.duplicate_of || null,
+    deleted_by: opts.deleted_by || 'automation',
+    content_hash: object.sensitive ? null : sha256(JSON.stringify(object)).slice(0, 24)
+  };
+}
+
+function daysSince(value, now = new Date()) {
+  const t = Date.parse(value || '');
+  if (!Number.isFinite(t)) return 9999;
+  return Math.floor((Number(now) - t) / 86400000);
+}
+
+function isoDaysAgo(days) {
+  return new Date(Date.now() - Number(days) * 86400000).toISOString();
+}
+
+function safeId(value) {
+  return String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80) || 'object';
+}
+
+function clamp(min, max, value) {
+  return Math.max(min, Math.min(max, Math.round(Number(value) || 0)));
+}
+
 function timed(fn, iterations) {
   let result;
   const count = Math.max(1, Number(iterations) || 1);

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.77';
+export const PACKAGE_VERSION = '0.6.78';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 

package/src/core/goal-workflow.mjs

@@ -36,6 +36,34 @@ export async function writeGoalWorkflow(dir, mission, opts = {}) {
       ralph_removed: true,
       ambiguity_gate: 'use normal SKS ambiguity gates when required by the selected execution route; Goal itself delegates persistence/continuation to Codex /goal',
       evidence: ['goal-workflow.json', 'goal-bridge.md']
+    },
+    phase: action === 'clear' ? 'reporting' : 'intake',
+    user_outcome: prompt,
+    work_order_ledger_id: null,
+    checkpoints: [
+      {
+        timestamp: nowIso(),
+        phase: 'intake',
+        summary: 'Goal workflow bridge created.',
+        completed_checkboxes: ['goal workflow artifact written'],
+        open_checkboxes: ['continue original SKS route lifecycle when implementation is needed'],
+        blockers: [],
+        evidence: [GOAL_WORKFLOW_ARTIFACT, GOAL_BRIDGE_ARTIFACT]
+      }
+    ],
+    resume_context: {
+      stable_requirements: prompt ? [prompt] : [],
+      current_files: [GOAL_WORKFLOW_ARTIFACT, GOAL_BRIDGE_ARTIFACT],
+      decisions: ['Codex native /goal is the persisted continuation surface'],
+      known_mistakes_to_avoid: ['do not clear noisy context without writing a structured handoff first'],
+      active_skills: ['goal'],
+      active_agents: []
+    },
+    clear_policy: {
+      preserve_work_order: true,
+      preserve_decisions: true,
+      preserve_evidence_links: true,
+      discard_noisy_logs: true
     }
   };
   await writeJsonAtomic(path.join(dir, GOAL_WORKFLOW_ARTIFACT), workflow);
@@ -51,10 +79,23 @@ export async function updateGoalWorkflow(dir, action) {
     action,
     status: action === 'clear' ? 'cleared' : action === 'pause' ? 'paused' : action === 'resume' ? 'resumed' : current.status || 'created',
     updated_at: nowIso(),
+    phase: action === 'pause' ? 'reporting' : action === 'resume' ? 'implementation' : action === 'clear' ? 'retro' : current.phase || 'intake',
     native_goal: {
       ...(current.native_goal || {}),
       slash_command: nativeGoalCommand(action, current.prompt || '')
-    }
+    },
+    checkpoints: [
+      ...(Array.isArray(current.checkpoints) ? current.checkpoints : []),
+      {
+        timestamp: nowIso(),
+        phase: action,
+        summary: `Goal ${action} requested through SKS bridge.`,
+        completed_checkboxes: [`goal ${action} artifact update`],
+        open_checkboxes: action === 'clear' ? ['handoff preserved before noisy context clear'] : [],
+        blockers: [],
+        evidence: [GOAL_WORKFLOW_ARTIFACT, GOAL_BRIDGE_ARTIFACT]
+      }
+    ]
   };
   await writeJsonAtomic(path.join(dir, GOAL_WORKFLOW_ARTIFACT), next);
   await writeTextAtomic(path.join(dir, GOAL_BRIDGE_ARTIFACT), goalBridgeMarkdown(next));

package/src/core/hooks-runtime.mjs

@@ -5,6 +5,7 @@ import { missionDir, setCurrent, stateFile } from './mission.mjs';
 import { checkDbOperation, dbBlockReason, handleMadSksUserConfirmation } from './db-safety.mjs';
 import { checkHarnessModification, harnessGuardBlockReason } from './harness-guard.mjs';
 import { activeRouteContext, evaluateStop, prepareRoute, promptPipelineContext as routePipelineContext, recordContext7Evidence, recordSubagentEvidence, routePrompt } from './pipeline.mjs';
+import { classifyToolError } from './evaluation.mjs';
 
 const TEAM_DIGEST_MAX_EVENTS = 4;
 const TEAM_DIGEST_MESSAGE_CHARS = 180;
@@ -163,6 +164,7 @@ async function hookPostTool(root, state, payload, noQuestion) {
   }
   await recordContext7Evidence(root, state, payload).catch(() => null);
   await recordSubagentEvidence(root, state, payload).catch(() => null);
+  if (toolFailed(payload)) await recordToolErrorTaxonomy(root, state, payload).catch(() => null);
   const teamDigest = await teamLiveDigest(root, state);
   if (!noQuestion) {
     return teamDigest?.context
@@ -183,6 +185,25 @@ async function hookPostTool(root, state, payload, noQuestion) {
     : { continue: true };
 }
 
+async function recordToolErrorTaxonomy(root, state = {}, payload = {}) {
+  if (!state?.mission_id) return null;
+  const classification = classifyToolError({
+    code: payload.exit_code ?? payload.exitCode ?? payload.tool_response?.exit_code ?? payload.result?.exit_code,
+    name: payload.tool_name || payload.name || payload.tool?.name,
+    message: payload.error || payload.message || payload.stderr || payload.tool_response?.stderr || payload.result?.stderr,
+    stderr: payload.stderr || payload.tool_response?.stderr || payload.result?.stderr
+  });
+  const record = {
+    ts: nowIso(),
+    classification,
+    unknown_is_harness_bug: classification === 'Unknown',
+    tool: payload.tool_name || payload.name || payload.tool?.name || null,
+    payload_hash: sha256(JSON.stringify(payload || {})).slice(0, 16)
+  };
+  await appendJsonl(path.join(missionDir(root, state.mission_id), 'tool-errors.jsonl'), record);
+  return record;
+}
+
 async function hookPermission(root, state, payload, noQuestion) {
   const harnessDecision = await checkHarnessModification(root, payload, { phase: 'permission-request' });
   if (harnessDecision.action === 'block') {

package/src/core/init.mjs

@@ -500,7 +500,7 @@ export async function installSkills(root) {
     'wiki': `---\nname: wiki\ndescription: Dollar-command route for $Wiki TriWiki refresh, pack, validate, and prune commands.\n---\n\nUse for $Wiki or Korean wiki-refresh requests. Refresh/update/갱신: run sks wiki refresh, then validate .sneakoscope/wiki/context-pack.json. Pack: run sks wiki pack, then validate. Prune/clean/정리: use sks wiki refresh --prune, or sks wiki prune --dry-run for inspection. Report claims, anchors, trust, attention.use_first/hydrate_first, validation, and blockers. Do not start ambiguity-gated implementation, subagents, or unrelated work.\n`,
     'team': `---\nname: team\ndescription: SKS Team orchestration for $Team/code work; $From-Chat-IMG is the explicit chat-image alias.\n---\n\nUse for $Team/code work. Ambiguity gate first. Write team-roster.json; team-gate.json needs team_roster_confirmed=true. executor:N means N scouts, N debate voices, then fresh N executors. After consensus, compile team-graph.json, team-runtime-tasks.json, team-decomposition-report.json, and team-inbox/ so worker handoff uses concrete runtime task ids with role/path/domain/lane hints. Refresh/validate TriWiki before debate, implementation, review, and final; consume attention.use_first and hydrate attention.hydrate_first before risky decisions. Log events, close sessions, pass team-session-cleanup.json, then reflection and Honest Mode. Parent integrates/verifies.\n\n${chatCaptureIntakeText()}\n`,
     'from-chat-img': `---\nname: from-chat-img\ndescription: Explicit $From-Chat-IMG Team alias for chat screenshot plus attachment analysis.\n---\n\nUse only for From-Chat-IMG/$From-Chat-IMG. It enters the normal Team pipeline. Treat uploads as chat screenshot plus originals. Use Computer Use/browser visual inspection when available, list requirements first, match regions to attachments with confidence, write ${FROM_CHAT_IMG_COVERAGE_ARTIFACT}, ${FROM_CHAT_IMG_CHECKLIST_ARTIFACT}, ${FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT}, and ${FROM_CHAT_IMG_QA_LOOP_ARTIFACT}, then continue Team gates, review, reflection, and Honest Mode. The ledger must account for every visible customer request, screenshot image region, and separate attachment; ${FROM_CHAT_IMG_CHECKLIST_ARTIFACT} must have a checked item for each request, image-region/attachment match, work item, scoped QA-LOOP, and verification step; ${FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT} stores temporary TriWiki-backed session context with expires_after_sessions=${FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS}. ${FROM_CHAT_IMG_QA_LOOP_ARTIFACT} must prove QA-LOOP ran over the exact customer-request work-order range after implementation, with every work item covered, post-fix verification complete, and zero unresolved findings. team-gate.json cannot pass From-Chat-IMG completion until unresolved_items is empty, every checklist box is checked, and scoped_qa_loop_completed=true.\n`,
-    'qa-loop': `---\nname: qa-loop\ndescription: $QA-LOOP dogfoods UI/API as human proxy with safety gates, Browser/Computer evidence, safe fixes, rechecks, and a QA report.\n---\n\nUse only $QA-LOOP. Ask scope, target, mutation, login. Credentials are runtime-only; never save secrets. UI needs Browser/Computer evidence or mark unverified. Deployed targets are read-only; destructive removal is forbidden. After answer/run, dogfood real flows, apply safe contract-allowed code/test/docs fixes, recheck, and do not pass qa-gate.json with unresolved findings or without post_fix_verification_complete. Finish qa-ledger, date/version report, gate, completion summary, and Honest Mode.\n`,
+    'qa-loop': `---\nname: qa-loop\ndescription: $QA-LOOP dogfoods UI/API as human proxy with safety gates, Codex Computer Use-only UI evidence, safe fixes, rechecks, and a QA report.\n---\n\nUse only $QA-LOOP. Ask scope, target, mutation, login. Credentials are runtime-only; never save secrets. UI-level E2E needs Codex Computer Use evidence or must be marked unverified; Chrome MCP, Browser Use, Playwright, and other browser automation do not satisfy UI verification. Deployed targets are read-only; destructive removal is forbidden. After answer/run, dogfood real flows, apply safe contract-allowed code/test/docs fixes, recheck, and do not pass qa-gate.json with unresolved findings or without post_fix_verification_complete. Finish qa-ledger, date/version report, gate, completion summary, and Honest Mode.\n`,
     'goal': `---\nname: goal\ndescription: Dollar-command route for $Goal or $goal Codex native persisted /goal workflows.\n---\n\nUse when the user invokes $Goal/$goal or asks to persist a workflow with Codex native /goal continuation. Prepare with sks goal create or the $Goal route, then use native Codex /goal create, pause, resume, and clear controls where available. Do not recreate the old no-question loop.\n`,
     'research': `---\nname: research\ndescription: Dollar-command route for $Research or $research frontier discovery workflows.\n---\n\nUse when the user invokes $Research/$research or asks for research, hypotheses, new mechanisms, falsification, or testable predictions. Prefer sks research prepare and sks research run. Do not use for ordinary code edits.\n`,
     'autoresearch': `---\nname: autoresearch\ndescription: Dollar-command route for $AutoResearch or $autoresearch iterative experiment loops.\n---\n\nUse for $AutoResearch, iterative improvement, SEO/GEO, ranking, workflow, benchmark, or experiments. Define program, hypothesis, experiment, metric, keep/discard, falsification, next step, and Honest Mode. Load seo-geo-optimizer for README/npm/GitHub/schema/AI-search work.\n`,

package/src/core/memory-governor.mjs

@@ -1,17 +1,10 @@
 import path from 'node:path';
 import { exists, nowIso, readJson, writeJsonAtomic } from './fsx.mjs';
+import { DEFAULT_FORGETTING_THRESHOLDS, MEMORY_LIFECYCLE_STATES, forgettingDecision } from './evaluation.mjs';
 
 export const MEMORY_OPERATIONS = new Set([
-  'ADD',
-  'UPDATE',
-  'CONSOLIDATE',
-  'DEMOTE',
-  'SOFT_FORGET',
-  'ARCHIVE',
-  'HARD_DELETE',
-  'NOOP',
-  'PROMOTE_SKILL',
-  'PROMOTE_RULE'
+  'ADD', 'KEEP_ACTIVE', 'PIN', 'UNPIN', 'UPDATE', 'CONSOLIDATE', 'DEMOTE', 'SOFT_FORGET', 'DISABLE', 'ARCHIVE',
+  'QUARANTINE', 'HARD_DELETE', 'NOOP', 'PROMOTE_SKILL', 'PROMOTE_RULE', 'PROMOTE_TEST'
 ]);
 
 export const DEFAULT_RETRIEVAL_BUDGET = {
@@ -62,6 +55,9 @@ export async function sweepTriWiki(root, opts = {}) {
     started_at: startedAt,
     completed_at: nowIso(),
     operations,
+    lifecycle_states: MEMORY_LIFECYCLE_STATES,
+    forgetting_defaults: DEFAULT_FORGETTING_THRESHOLDS,
+    tombstones: operations.map((op) => op.tombstone).filter(Boolean),
     retrieval_budget: {
       ...DEFAULT_RETRIEVAL_BUDGET,
       top_k_default: Number(opts.topKDefault || DEFAULT_RETRIEVAL_BUDGET.top_k_default),
@@ -114,14 +110,28 @@ function operationForClaim(claim, before, score, duplicateCount) {
     operation = 'PROMOTE_RULE';
     reasonCodes.push('mistake_prevention');
   }
+  const governed = forgettingDecision({
+    id: claim.id || stableId(text),
+    type: 'wiki_claim',
+    trust_score: score,
+    evidence_count: claim.evidence_count,
+    updated_at: claim.updated_at,
+    stale: claim.freshness === 'stale',
+    known_false: claim.status === 'unsupported',
+    duplicate_of: duplicateCount > 0 ? 'previous-claim' : null,
+    regression_prevention: /mistake|failure|regression|fingerprint/i.test(text)
+  });
   return {
     claim_id: claim.id || stableId(text),
     operation,
+    lifecycle_state: governed.lifecycle_state,
     reason_codes: reasonCodes.length ? reasonCodes : ['kept_within_budget'],
     before_score: round(before),
     after_score: round(score),
+    utility_score: governed.utility_score,
     evidence: [claim.source || claim.file || 'context-pack.json'].filter(Boolean),
-    reversible
+    reversible,
+    tombstone: governed.tombstone || null
   };
 }
 

package/src/core/pipeline.mjs

@@ -642,7 +642,7 @@ function reflectionStopReason(state = {}, status = {}) {
 export async function evaluateStop(root, state, payload, opts = {}) {
   const last = extractLastMessage(payload);
   if (state?.clarification_required && String(state.phase || '').includes('CLARIFICATION_AWAITING_ANSWERS')) {
-    if (looksLikeClarificationAnswer(last)) return { continue: true };
+    if (await hasVisibleClarificationQuestionBlock(root, state, last)) return { continue: true };
     return complianceBlock(root, state, await clarificationStopReason(root, state, 'route'), { gate: 'clarification' });
   }
   if (state?.context7_required && !(await hasContext7DocsEvidence(root, state))) {
@@ -878,6 +878,12 @@ function extractLastMessage(payload) {
   return payload.last_assistant_message || payload.assistant_message || payload.message || payload.response || payload.raw || '';
 }
 
-function looksLikeClarificationAnswer(text) {
-  return /(GOAL_PRECISE|ACCEPTANCE_CRITERIA|질문|answers\.json|required-answers|Decision Contract|clarification|모호성|답변)/i.test(String(text || ''));
+async function hasVisibleClarificationQuestionBlock(root, state = {}, text = '') {
+  const body = String(text || '');
+  if (!/Required questions|필수 질문|질문지|답변할 항목/i.test(body)) return false;
+  const schema = state.mission_id ? await readJson(path.join(missionDir(root, state.mission_id), 'required-answers.schema.json'), null) : null;
+  const slots = Array.isArray(schema?.slots) ? schema.slots : [];
+  if (!slots.length) return /sks pipeline answer|answers\.json/i.test(body);
+  const requiredIds = slots.slice(0, Math.min(3, slots.length)).map((slot) => slot.id).filter(Boolean);
+  return requiredIds.every((id) => body.includes(id)) && /sks pipeline answer|answers\.json|slot id|슬롯|항목/i.test(body);
 }

package/src/core/qa-loop.mjs

@@ -3,6 +3,7 @@ import { exists, nowIso, readJson, readText, writeJsonAtomic, writeTextAtomic, P
 
 export const QA_LOOP_ROUTE = 'QALoop';
 const QA_REPORT_SUFFIX = 'qa-report.md';
+const UI_COMPUTER_USE_ONLY_ACK = 'use_codex_computer_use_only_no_chrome_mcp_no_browser_use_no_playwright_or_mark_ui_not_verified';
 
 function qaReportDateStamp(date = new Date()) {
   return date.toISOString().slice(0, 10);
@@ -28,7 +29,7 @@ export function buildQaLoopQuestionSchema(prompt) {
   return {
     schema_version: 1,
     route: QA_LOOP_ROUTE,
-    description: 'QA-LOOP questions must be answered before execution. Login secrets and browser auth state are runtime-only and must not be saved to mission files or TriWiki. UI evidence must prefer official Codex Browser Use and Computer Use MCP/plugin tools.',
+    description: 'QA-LOOP questions must be answered before execution. Login secrets and browser auth state are runtime-only and must not be saved to mission files or TriWiki. UI-level E2E evidence must use Codex Computer Use only; Chrome MCP, Browser Use, Playwright, and other browser automation do not satisfy UI verification.',
     prompt,
     slots: [
       { id: 'GOAL_PRECISE', question: 'Define the QA objective in one sentence.', required: true, type: 'string' },
@@ -44,7 +45,7 @@ export function buildQaLoopQuestionSchema(prompt) {
       { id: 'TEMP_TEST_CREDENTIALS_READY', question: 'If login is required, are test-only credentials ready to provide ephemerally during the run?', required: true, type: 'enum', options: ['not_required', 'yes_temp_only', 'no_block_authenticated_tests'] },
       { id: 'TEST_CREDENTIALS_RUNTIME_SOURCE', question: 'If login is required, how will test-only credentials be provided without saving the values?', required: true, type: 'enum', options: ['not_required', 'ephemeral_chat_only', 'environment_variables', 'secret_manager'] },
       { id: 'CREDENTIAL_STORAGE_ACK', question: 'Acknowledge credential handling policy.', required: true, type: 'enum', options: ['never_store_credentials_in_artifacts_or_wiki'] },
-      { id: 'UI_COMPUTER_USE_ACK', question: 'Acknowledge UI E2E evidence policy.', required: true, type: 'enum', options: ['use_browser_use_or_computer_use_for_ui_e2e_or_mark_ui_not_verified'] },
+      { id: 'UI_COMPUTER_USE_ACK', question: 'Acknowledge UI E2E evidence policy: Codex Computer Use only; no Chrome MCP, Browser Use, Playwright, or other browser automation.', required: true, type: 'enum', options: [UI_COMPUTER_USE_ONLY_ACK] },
       { id: 'TEAM_MODE_ALLOWED', question: 'May QA-LOOP use Team/subagents where useful?', required: true, type: 'enum', options: ['yes_parallel_where_safe', 'no_parent_only'] },
       { id: 'MAX_QA_CYCLES', question: 'How many no-question QA cycles are allowed before pausing?', required: true, type: 'string' },
       { id: 'ACCEPTANCE_CRITERIA', question: 'List the QA completion criteria.', required: true, type: 'array_or_string' },
@@ -65,7 +66,7 @@ export function validateQaLoopAnswers(schema, answers = {}) {
   if (env !== 'local_dev_server' && mutation === 'seeded_create_change_remove_local_only') errors.push({ slot: 'QA_MUTATION_POLICY', error: 'destructive_removal_tests_are_local_dev_only' });
   if (env === 'deployed_production_domain' && mutation !== 'read_only_smoke_only') errors.push({ slot: 'QA_MUTATION_POLICY', error: 'production_deployed_qa_is_read_only_smoke_only' });
   if (answers.DESTRUCTIVE_DEPLOYED_TESTS_ALLOWED !== 'never') errors.push({ slot: 'DESTRUCTIVE_DEPLOYED_TESTS_ALLOWED', error: 'destructive_deployed_tests_never_allowed' });
-  if (isUiScope(answers.QA_SCOPE) && answers.UI_COMPUTER_USE_ACK !== 'use_browser_use_or_computer_use_for_ui_e2e_or_mark_ui_not_verified') errors.push({ slot: 'UI_COMPUTER_USE_ACK', error: 'ui_e2e_requires_browser_or_computer_use_ack' });
+  if (isUiScope(answers.QA_SCOPE) && answers.UI_COMPUTER_USE_ACK !== UI_COMPUTER_USE_ONLY_ACK) errors.push({ slot: 'UI_COMPUTER_USE_ACK', error: 'ui_e2e_requires_codex_computer_use_only_ack' });
   if (answers.LOGIN_REQUIRED === 'yes' && answers.TEMP_TEST_CREDENTIALS_READY !== 'yes_temp_only') errors.push({ slot: 'TEMP_TEST_CREDENTIALS_READY', error: 'authenticated_tests_require_ephemeral_test_credentials_or_must_be_blocked' });
   if (answers.LOGIN_REQUIRED === 'yes' && answers.TEST_CREDENTIALS_RUNTIME_SOURCE === 'not_required') errors.push({ slot: 'TEST_CREDENTIALS_RUNTIME_SOURCE', error: 'credential_runtime_source_required' });
   if (answers.CREDENTIAL_STORAGE_ACK !== 'never_store_credentials_in_artifacts_or_wiki') errors.push({ slot: 'CREDENTIAL_STORAGE_ACK', error: 'credential_temp_only_ack_required' });
@@ -146,7 +147,7 @@ export async function writeQaLoopArtifacts(dir, mission, contract) {
     mission_id: mission.id,
     qa_report_file: reportFile,
     target: { scope: a.QA_SCOPE, environment: a.TARGET_ENVIRONMENT, base_url: a.TARGET_BASE_URL, api_base_url: a.API_BASE_URL },
-    safety: { mutation_policy: a.QA_MUTATION_POLICY, deployed_destructive_tests_allowed: 'never', credentials: 'temp_only_never_saved', ui_evidence: 'browser_use_or_computer_use_required_for_ui_e2e' },
+    safety: { mutation_policy: a.QA_MUTATION_POLICY, deployed_destructive_tests_allowed: 'never', credentials: 'temp_only_never_saved', ui_evidence: 'codex_computer_use_only_required_for_ui_e2e' },
     checklist
   });
   await writeJsonAtomic(path.join(dir, 'qa-gate.json'), defaultQaGate(contract, { reportFile }));
@@ -195,7 +196,7 @@ TASK: ${mission.prompt}
 CYCLE: ${cycle}
 NO QUESTIONS: use decision-contract.json.
 MODE: dogfood as human proxy; use real flows, fix safe code/test/docs now, then recheck.
-UI: Browser/Computer Use evidence or mark unverified. Secrets runtime-only.
+UI: Codex Computer Use evidence only, or mark UI unverified. Chrome MCP, Browser Use, Playwright, and other browser automation do not satisfy UI-level E2E verification. Secrets runtime-only.
 SAFETY: deployed read-only smoke; no destructive, billing, message, webhook, admin, bulk-write, global-config, or live-data edits unless contract allows.
 GATE: passed=false while unresolved_findings or unresolved_fixable_findings > 0, or post_fix_verification_complete is not true.
 ARTIFACTS: update qa-ledger.json, ${report}, qa-gate.json, and qa-loop/cycle-${cycle}/.
@@ -224,7 +225,7 @@ function qaChecklist(a) {
     ['preflight.roles', 'Map roles, permissions, protected areas.']
   ];
   if (qaUiRequired(a)) cases.push(
-    ['ui.official_mcp_tools', 'Use Browser Use or Computer Use evidence, or mark UI unverified.'],
+    ['ui.computer_use_only', 'Use Codex Computer Use evidence only, or mark UI unverified. Do not use Chrome MCP, Browser Use, Playwright, or other browser automation as UI verification evidence.'],
     ['ui.navigation', 'Check primary navigation, deep links, back/forward, refresh, and protected routes.'],
     ['ui.auth', 'Check login, logout, session expiry, unauthorized access, and role-specific visibility.'],
     ['ui.forms', 'Check required fields, validation, disabled states, success, and failure.'],
@@ -252,7 +253,7 @@ function qaChecklist(a) {
 
 function qaReportTemplate(mission, contract, checklist) {
   const a = contract.answers || {};
-  return `# QA-LOOP Report\n\nMission: ${mission.id}\nTarget: ${a.TARGET_BASE_URL || 'unset'}\nScope: ${a.QA_SCOPE || 'unset'}\nEnvironment: ${a.TARGET_ENVIRONMENT || 'unset'}\n\n## Safety\n\n- Deployed destructive tests: never\n- Credentials: temp-only, never saved\n- UI evidence: Browser Use or Computer Use when runnable\n\n## Checklist\n\n${checklist.map((item) => `- [ ] ${item.id}: ${item.title}`).join('\n')}\n\n## Findings\n\nTBD\n\n## Corrections And Rechecks\n\nTBD\n\n## Honest Mode\n\nTBD\n`;
+  return `# QA-LOOP Report\n\nMission: ${mission.id}\nTarget: ${a.TARGET_BASE_URL || 'unset'}\nScope: ${a.QA_SCOPE || 'unset'}\nEnvironment: ${a.TARGET_ENVIRONMENT || 'unset'}\n\n## Safety\n\n- Deployed destructive tests: never\n- Credentials: temp-only, never saved\n- UI evidence: Codex Computer Use only when runnable; Chrome MCP, Browser Use, Playwright, and other browser automation do not satisfy UI-level E2E verification\n\n## Checklist\n\n${checklist.map((item) => `- [ ] ${item.id}: ${item.title}`).join('\n')}\n\n## Findings\n\nTBD\n\n## Corrections And Rechecks\n\nTBD\n\n## Honest Mode\n\nTBD\n`;
 }
 
 function positiveCount(value) {

package/src/core/questions.mjs

@@ -217,7 +217,7 @@ export function questionsMarkdown(schema) {
   if (isQaLoop) {
     lines.push('QA-LOOP는 이 질문들에 모두 답변하고 Decision Contract가 봉인된 뒤에만 실행됩니다.');
     lines.push('로그인이 필요하면 테스트 전용 계정 정보만 임시 런타임 입력으로 제공해야 하며, answers.json/리포트/로그/wiki에는 절대 저장하지 않습니다.');
-    lines.push('UI E2E는 Browser Use 또는 Computer Use 증거가 없으면 검증 완료로 주장할 수 없습니다.');
+    lines.push('UI 수준 E2E는 Codex Computer Use 증거가 없으면 검증 완료로 주장할 수 없습니다. Chrome MCP, Browser Use, Playwright, 기타 브라우저 자동화는 UI 검증 증거로 인정하지 않습니다.');
     lines.push('개발 서버가 아닌 배포/스테이징 도메인에서는 삭제성 테스트를 절대 실행하지 않습니다.');
   } else {
     lines.push('이 질문들에 모두 답변하고 Decision Contract가 봉인된 뒤에만 실행됩니다.');

package/src/core/routes.mjs

@@ -7,7 +7,7 @@ export const FROM_CHAT_IMG_CHECKLIST_ARTIFACT = 'from-chat-img-checklist.md';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT = 'from-chat-img-temp-triwiki.json';
 export const FROM_CHAT_IMG_QA_LOOP_ARTIFACT = 'from-chat-img-qa-loop.json';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS = 5;
-export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|cmux|auto-review|team|qa-loop|goal|research|db|codex-app|dfix|design|imagegen|dollar|context7|pipeline|reasoning|guard|conflicts|versioning|eval|hproof|gx|wiki|code-structure';
+export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|cmux|auto-review|team|qa-loop|goal|research|db|codex-app|dfix|design|imagegen|dollar|context7|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|code-structure';
 
 export const RECOMMENDED_MCP_SERVERS = [
   {
@@ -193,7 +193,7 @@ export const ROUTES = [
     command: '$QA-LOOP',
     mode: 'QALOOP',
     route: 'QA loop',
-    description: 'Dogfood UI/API as human proxy with safety gates, Browser/Computer evidence, safe fixes, rechecks, Honest Mode.',
+    description: 'Dogfood UI/API as human proxy with safety gates, Codex Computer Use-only UI evidence, safe fixes, rechecks, Honest Mode.',
     requiredSkills: ['qa-loop', 'pipeline-runner', REFLECTION_SKILL_NAME, 'honest-mode'],
     lifecycle: ['qa_questions_answered', 'contract_sealed', 'qa_checklist', 'qa_loop_cycles', 'safe_remediation', 'focused_reverification', 'qa_report_md', 'qa_gate', 'post_route_reflection', 'honest_mode'],
     context7Policy: 'optional',
@@ -346,7 +346,7 @@ export const COMMAND_CATALOG = [
   { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch SKS cmux with the auto-review profile.' },
   { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DFix and $Team.' },
   { name: 'dfix', usage: 'sks dfix', description: 'Explain $DFix ultralight design/content fix mode.' },
-  { name: 'qa-loop', usage: 'sks qa-loop prepare|answer|run|status ...', description: 'Dogfood UI/API as human proxy with safety gates, safe fixes, rechecks, Browser/Computer evidence, report.' },
+  { name: 'qa-loop', usage: 'sks qa-loop prepare|answer|run|status ...', description: 'Dogfood UI/API as human proxy with safety gates, safe fixes, rechecks, Codex Computer Use-only UI evidence, report.' },
   { name: 'context7', usage: 'sks context7 check|setup|tools|resolve|docs|evidence ...', description: 'Check, configure, and call the local Context7 MCP requirement.' },
   { name: 'pipeline', usage: 'sks pipeline status|resume|answer ...', description: 'Inspect the active skill-first route, pass mandatory ambiguity gates, and inspect completion gates.' },
   { name: 'guard', usage: 'sks guard check [--json]', description: 'Check SKS harness self-protection lock, fingerprints, and source-repo exception state.' },
@@ -362,6 +362,7 @@ export const COMMAND_CATALOG = [
   { name: 'research', usage: 'sks research prepare|run|status ...', description: 'Run frontier-style research missions with novelty and falsification gates.' },
   { name: 'db', usage: 'sks db policy|scan|mcp-config|classify|check ...', description: 'Inspect and enforce database/Supabase safety policy.' },
   { name: 'eval', usage: 'sks eval run|compare|thresholds ...', description: 'Run deterministic context-quality and performance evidence checks.' },
+  { name: 'harness', usage: 'sks harness fixture|review [--json]', description: 'Run Harness Growth Factory fixtures for forgetting, skills, experiments, tool taxonomy, permissions, MultiAgentV2, and Cmux views.' },
   { name: 'perf', usage: 'sks perf run [--json] [--iterations N]', description: 'Measure structured GPT-5.5/SKS performance budgets such as CLI startup and package size.' },
   { name: 'code-structure', usage: 'sks code-structure scan [--json]', description: 'Scan handwritten source files for 1000/2000/3000-line structure gates and split-review exceptions.' },
   { name: 'validate-artifacts', usage: 'sks validate-artifacts [mission-id|latest] [--json]', description: 'Validate schema-backed mission artifacts for work orders, effort decisions, visual maps, dogfood reports, skills, mistake memory, Team dashboard state, and Honest Mode.' },

package/src/core/skill-forge.mjs

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from './fsx.mjs';
 import { ARTIFACT_FILES, validateSkillCandidate, validateSkillInjectionDecision } from './artifact-schemas.mjs';
+import { createSkillCard } from './evaluation.mjs';
 
 export function createSkillCandidate(opts = {}) {
   const successfulRuns = Number(opts.evidence?.successful_runs || opts.successful_runs || 0);
@@ -77,6 +78,19 @@ export function createSkillForgeReport(opts = {}) {
     mission_id: opts.mission_id || null,
     created_at: nowIso(),
     candidates,
+    skill_cards: candidates.map((candidate) => createSkillCard({
+      skill_id: candidate.id,
+      name: candidate.id,
+      version: `1.0.${Number(candidate.version || 1) - 1}`,
+      status: candidate.promotion_ready ? 'active' : 'dormant',
+      use_count: Number(candidate.evidence?.successful_runs || 0) + Number(candidate.evidence?.failed_runs || 0),
+      success_count: Number(candidate.evidence?.successful_runs || 0),
+      failure_count: Number(candidate.evidence?.failed_runs || 0),
+      trigger_summary: (candidate.triggers || []).join(', '),
+      anti_triggers: candidate.contraindications || [],
+      validation: { commands: candidate.evidence?.tests || [], manual_checks: [], schemas: ['skill-card'] },
+      implicit_invocation_allowed: candidate.promotion_ready
+    })),
     injection,
     retirements: (opts.skills || []).filter((skill) => skill.stale || skill.conflicting || Number(skill.failed_runs || skill.evidence?.failed_runs || 0) >= 2).map((skill) => ({
       id: skill.id,
@@ -88,7 +102,8 @@ export function createSkillForgeReport(opts = {}) {
     })),
     validation: {
       top_k_respected: injection.injected.length <= injection.top_k,
-      full_skill_loaded_only_after_selection: true
+      full_skill_loaded_only_after_selection: true,
+      stale_or_false_triggered_skills_retired: true
     }
   };
 }

package/src/core/team-dashboard-renderer.mjs

@@ -3,17 +3,21 @@ import { nowIso, readJson, writeJsonAtomic } from './fsx.mjs';
 import { ARTIFACT_FILES, validateTeamDashboardState } from './artifact-schemas.mjs';
 
 export const TEAM_DASHBOARD_PANES = [
-  'Mission Overview',
-  'Agent Lanes',
-  'Task DAG',
-  'QA and Dogfood',
-  'Artifacts and Evidence',
-  'Performance',
-  'Memory Attention',
+  'Mission / Goal View',
+  'Agent Grid View',
+  'MultiAgentV2 Graph View',
+  'Work Order Ledger View',
+  'Skill Autopilot View',
+  'TriWiki Memory Health View',
   'Forget Queue',
-  'Skill Autopilot',
   'Mistake Immunity',
+  'Tool Reliability View',
+  'Harness Experiments View',
+  'Dogfood Evidence View',
   'Code Structure',
+  'Statusline / Terminal Title Preview',
+  'Artifacts and Evidence',
+  'Performance',
   'From-Chat-IMG Visual Map'
 ];
 

package/src/core/team-live.mjs

@@ -400,6 +400,10 @@ export async function renderTeamWatch(dir, opts = {}) {
     '- Neighbor cmux panes follow individual `sks team lane ... --agent <name>` views.',
     '- Use `sks team event ...` to mirror scout, debate, executor, review, and verification status into the live panes.',
     '',
+    '## Cockpit Views',
+    '- Mission / Goal | Agents | MultiAgentV2 | Work Orders | Skills | Memory Health | Forget Queue',
+    '- Mistake Immunity | Tool Reliability | Harness Experiments | Dogfood Evidence | Code Structure | Statusline/Title',
+    '',
     '## Visible Agent Lanes',
     ...(visibleAgents.length
       ? visibleAgents.map(([name, status]) => `- ${name}: ${status.status || 'pending'} | ${status.phase || 'unknown'} | last_seen:${status.last_seen || 'never'}`)