sneakoscope 0.6.77 → 0.6.78

package/README.md

@@ -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
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.6.77",
+  "version": "0.6.78",
   "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');
@@ -2764,7 +2775,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 +2831,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();
@@ -417,6 +418,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 +1231,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/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/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/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 = [
   {
@@ -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'}`)