atris 3.15.56 → 3.16.0

package/commands/xp.js

@@ -7,6 +7,7 @@ const crypto = require('crypto');
 const { spawnSync } = require('child_process');
 
 const DEFAULT_GRAPH_DAYS = 365;
+const MAX_SYNC_GRAPH_DAYS = 370;
 const INTENSITY_CHARS = [' ', '.', ':', '*', '#'];
 const ROW_LABELS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
@@ -29,7 +30,11 @@ const EARNING_MODEL = {
   schema: 'atris.agentxp_earning_model.v1',
   score_name: AGENT_XP_LABEL,
   primary_public_source: 'accepted_task_receipt',
-  public_rule: 'No accepted proof-backed task episodes means no AgentXP leaderboard movement.',
+  public_rule: 'No human-accepted proof-backed task episodes means no AgentXP leaderboard movement.',
+  policies: {
+    task_done_with_proof: 'Records proof for review and RL context; emits no Career XP receipt until human accept.',
+    task_accept: 'Human accept with proof and positive reward is the Career XP receipt boundary.',
+  },
   weights: [
     {
       id: 'accepted_task_receipt',
@@ -210,6 +215,38 @@ function combineAgentXpContributionGraphs(graphs, windowDays = DEFAULT_GRAPH_DAY
   return graphFromDailyTotals(totals, windowDays);
 }
 
+function sanitizeContributionGraphForSync(graph) {
+  if (!graph || typeof graph !== 'object') return null;
+  const rawDays = Array.isArray(graph.days) ? graph.days : [];
+  const days = rawDays
+    .slice(-MAX_SYNC_GRAPH_DAYS)
+    .map((day) => {
+      const date = typeof day?.date === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(day.date)
+        ? day.date
+        : null;
+      if (!date) return null;
+      const xp = Math.max(0, asNumber(day.xp ?? day.total_xp));
+      return {
+        date,
+        xp,
+        total_xp: Math.max(0, asNumber(day.total_xp, xp)),
+        intensity: Math.max(0, Math.min(4, asNumber(day.intensity))),
+      };
+    })
+    .filter(Boolean);
+  if (days.length === 0) return null;
+  return {
+    schema: 'atris.agent_xp_contribution_graph.v1',
+    metric_label: AGENT_XP_LABEL,
+    window_days: days.length,
+    total_xp: days.reduce((sum, day) => sum + day.xp, 0),
+    active_days: days.filter(day => day.xp > 0).length,
+    first_date: days[0]?.date || null,
+    last_date: days[days.length - 1]?.date || null,
+    days,
+  };
+}
+
 function currentForm(payload) {
   const arenas = payload.current_form_by_arena || {};
   const local = arenas.local_workspace || {};
@@ -641,6 +678,7 @@ function buildAtrisActionSignalFromRows(rows = []) {
     included_in_total_agent_xp: false,
     public_leaderboard: false,
     role: 'rl_routing_only',
+    note: 'Task done/finish proof can count here as non-public action context; Career XP still requires human accept.',
   };
 }
 
@@ -1348,10 +1386,6 @@ function readTaskProjectionState(workspace) {
   }
 }
 
-function readTaskProjection(workspace) {
-  return readTaskProjectionState(workspace).tasks;
-}
-
 function taskRef(task) {
   return task?.display_id || task?.legacy_ref || task?.id || 'task';
 }
@@ -1682,36 +1716,6 @@ function buildCareerXpSessionCapsule(args = []) {
   return capsule;
 }
 
-function normalizeLocalScore(score, workspace) {
-  const card = score.profile_card || score.player_card || {};
-  const integrity = score.integrity || {};
-  const careerXp = asNumber(card.agent_xp ?? card.career_xp);
-  const leaderboardEligible = Boolean(
-    card.leaderboard_eligible ?? integrity.leaderboard_eligible
-  );
-
-  return {
-    metric_label: AGENT_XP_LABEL,
-    agent_xp: careerXp,
-    career_xp: careerXp,
-    level: levelFromXp(careerXp),
-    operator: score.operator || null,
-    leaderboard_eligible: leaderboardEligible,
-    source: 'local_contribution_score',
-    workspace_root: score.workspace_root || workspace,
-    current_form_by_arena: {
-      local_workspace: {
-        ovr: asNumber(card.ovr || card.current_form),
-        current_form: asNumber(card.current_form || card.ovr),
-        visible_stats: Array.isArray(card.visible_stats) ? card.visible_stats : [],
-        leaderboard_eligible: leaderboardEligible,
-        integrity_status: score.label || integrity.status || 'unknown',
-      },
-    },
-    contribution_graph: score.contribution_graph || {},
-  };
-}
-
 function renderContributionGraph(graph) {
   if (!graph || !Array.isArray(graph.days)) return;
   console.log('');
@@ -1729,36 +1733,6 @@ function renderLocalActivity(activity) {
   );
 }
 
-function loadLocalPayload(args) {
-  const workspace = path.resolve(readFlag(args, '--workspace', process.cwd()));
-  const operator = readFlag(
-    args,
-    '--operator',
-    process.env.ATRIS_OPERATOR || process.env.USER || os.userInfo().username
-  );
-  const script = path.join(workspace, 'scripts', 'contribution_score.py');
-
-  if (!fs.existsSync(script)) {
-    throw new Error(`No local contribution scorer found at ${path.relative(process.cwd(), script)}`);
-  }
-
-  const result = spawnSync(
-    process.env.PYTHON || 'python3',
-    [script, '--workspace', workspace, '--operator', operator, '--json'],
-    { cwd: workspace, encoding: 'utf8', maxBuffer: 20 * 1024 * 1024 }
-  );
-
-  if (result.error) {
-    throw result.error;
-  }
-  if (result.status !== 0) {
-    const detail = (result.stderr || result.stdout || '').trim();
-    throw new Error(detail || `Local scorer exited ${result.status}`);
-  }
-
-  return normalizeLocalScore(JSON.parse(result.stdout), workspace);
-}
-
 function earnedAgentXp(value) {
   return Math.max(0, asNumber(value));
 }
@@ -1945,6 +1919,7 @@ function buildAgentXpSyncPacket(args = []) {
   const publicXp = earnedAgentXp(totalXp);
   const currentForm = currentFormScore(totalXp);
   const levelProgress = agentXpLevelProgress(publicXp);
+  const contributionGraph = sanitizeContributionGraphForSync(projection.contribution_graph);
   const workspaceRootHash = sha256(workspaces.map(item => item.workspace_root_hash || item.name).sort().join(':'));
   const entry = {
     user_id: player,
@@ -1964,6 +1939,7 @@ function buildAgentXpSyncPacket(args = []) {
     lock_reason: eligible ? null : 'not_enough_trusted_proof',
     public_adjustment: null,
     next_move: eligible ? 'Play the next proof-backed AgentXP mission.' : 'Complete one proof-backed AgentXP rep.',
+    contribution_graph: contributionGraph,
   };
   const packet = {
     schema: 'atris.agentxp_sync_packet.v1',

package/lib/auto-accept-certified.js

@@ -0,0 +1,294 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { taskProofState } = require('./task-proof');
+
+const AGENT_CERTIFICATION_REVIEW_PASSES = 2;
+const AUTO_ACCEPT_HIGH_CONFIDENCE_PASSES = 3;
+const DENIED_TAGS = new Set(['billing', 'deploy', 'feedback', 'voice', 'security', 'customer', 'external']);
+
+const SIMPLE_VERIFY_TOKEN_RE = /^[a-zA-Z0-9_./:@=+-]+$/;
+const GIT_WORKTREE_PATH_RE = /^[a-zA-Z0-9_./@=+-]+$/;
+const GIT_REV_TOKEN_RE = /^[a-zA-Z0-9_./@=+~^-]+$/;
+
+function hasUnsafePathSegment(token) {
+  const text = String(token || '');
+  return text.startsWith('/')
+    || /^[a-zA-Z]:[\\/]/.test(text)
+    || text.split(/[\\/]+/).includes('..');
+}
+
+function safeVerifyToken(token) {
+  return SIMPLE_VERIFY_TOKEN_RE.test(token) && !hasUnsafePathSegment(token);
+}
+
+function safeRelativePathToken(token) {
+  const text = String(token || '');
+  return Boolean(text)
+    && !text.startsWith('-')
+    && !text.includes(':')
+    && safeVerifyToken(text);
+}
+
+function safeGitWorktreePathToken(token) {
+  const text = String(token || '');
+  return Boolean(text)
+    && !text.startsWith('-')
+    && !text.includes(':')
+    && GIT_WORKTREE_PATH_RE.test(text)
+    && !text.split(/[\\/]+/).includes('..');
+}
+
+function safeGitRevToken(token) {
+  const text = String(token || '');
+  return Boolean(text)
+    && !text.startsWith('-')
+    && !text.includes(':')
+    && GIT_REV_TOKEN_RE.test(text)
+    && !text.split(/[\\/]+/).includes('..');
+}
+
+function safeNodePathArgs(args) {
+  return args.every(token => safeRelativePathToken(token));
+}
+
+function safeGitDiffCheckArgs(args) {
+  return args.length === 0 || (args.length <= 2 && args.every(safeGitRevToken));
+}
+
+function isAllowedGitDiffCheck(argv) {
+  const [bin, first, second, third, fourth] = argv;
+  if (bin !== 'git') return false;
+  if (first === 'diff' && second === '--check') {
+    return safeGitDiffCheckArgs(argv.slice(3));
+  }
+  if (first === '-C' && safeGitWorktreePathToken(second) && third === 'diff' && fourth === '--check') {
+    return safeGitDiffCheckArgs(argv.slice(5));
+  }
+  return false;
+}
+
+function isInsidePath(candidate, root) {
+  const relative = path.relative(root, candidate);
+  return relative === '' || (relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function validateGitWorktreePath(argv, workspaceRoot) {
+  if (!(argv[0] === 'git' && argv[1] === '-C')) return { ok: true };
+  const workspace = path.resolve(workspaceRoot || process.cwd());
+  const target = path.resolve(workspace, argv[2]);
+  const allowedRoot = path.dirname(workspace);
+  if (!isInsidePath(target, workspace) && !isInsidePath(target, allowedRoot)) {
+    return { ok: false, reason: 'verify_command_not_allowed' };
+  }
+  if (!fs.existsSync(target)) return { ok: false, reason: 'verify_worktree_missing' };
+  return { ok: true };
+}
+
+function reviewPassCount(task) {
+  const metadata = task.metadata || {};
+  const review = task.review || {};
+  const count = Number(metadata.agent_review_pass_count ?? review.agent_review_pass_count);
+  return Number.isFinite(count) ? count : 0;
+}
+
+function isAgentCertified(task) {
+  const metadata = task.metadata || {};
+  const review = task.review || {};
+  const handoff = review.handoff && typeof review.handoff === 'object' ? review.handoff : {};
+  return metadata.agent_certified === true
+    || review.agent_certified === true
+    || handoff.native_goal_status === 'agent_certified'
+    || reviewPassCount(task) >= AGENT_CERTIFICATION_REVIEW_PASSES;
+}
+
+function latestProof(task) {
+  const metadata = task.metadata || {};
+  const review = task.review || {};
+  return String(metadata.latest_agent_proof || review.proof || '').trim();
+}
+
+function proofSentences(proof) {
+  return String(proof || '')
+    .replace(/([.!?])\s+/g, '$1\n')
+    .split(/[\n\r]+/)
+    .map((sentence) => sentence.trim())
+    .filter(Boolean);
+}
+
+function sentenceHasPullRequestReference(sentence) {
+  return /\bPR\s*#?\d+\b/i.test(sentence)
+    || /\bpull request\s*#?\d+\b/i.test(sentence)
+    || /\bgithub\.com\/\S+\/pull\/\d+\b/i.test(sentence)
+    || /#\d+\b/.test(sentence);
+}
+
+function sentenceHasUnmergedPullRequestBoundary(sentence) {
+  return sentenceHasPullRequestReference(sentence)
+    && (/\bopen\s+draft\b/i.test(sentence)
+      || /\bopen\/draft\b/i.test(sentence)
+      || /\bopen\s+and\s+draft\s*=\s*true\b/i.test(sentence)
+      || /\bdraft\s*=\s*true\b/i.test(sentence)
+      || /\bisDraft\s*[:=]\s*true\b/i.test(sentence)
+      || /\bmergedAt\s*[:=]\s*null\b/i.test(sentence)
+      || /\bclosed\s+(?:with\s+)?mergedAt\s*[:=]\s*null\b/i.test(sentence));
+}
+
+function proofHasUnmergedPullRequestBoundary(proof) {
+  return proofSentences(proof).some(sentenceHasUnmergedPullRequestBoundary);
+}
+
+function unmergedPullRequestBoundaryResult(ref, proof) {
+  return {
+    eligible: false,
+    ref,
+    reason: 'proof_unmerged_or_draft_pr_boundary',
+    next_action: 'revise the task out of Review or narrow the proof to draft/local-proof only before auto-accept',
+    proof,
+  };
+}
+
+function distinctReviewActors(task) {
+  const actors = new Set();
+  for (const event of task.events || []) {
+    if (!['proof_ready', 'reviewed'].includes(event.event_type)) continue;
+    const actor = event.actor || event.payload?.actor;
+    if (actor) actors.add(String(actor));
+  }
+  return actors;
+}
+
+function parseVerifyCommand(verify) {
+  const cmd = String(verify || '').trim();
+  if (!cmd) return { ok: false, reason: 'no_verify_command' };
+  if (/[;&|`$<>\n\r]/.test(cmd)) return { ok: false, reason: 'verify_command_not_allowed' };
+  const argv = cmd.split(/\s+/).filter(Boolean);
+  if (!argv.length || argv.some((token, index) => {
+    if (argv[0] === 'git' && argv[1] === '-C' && index === 2) {
+      return !safeGitWorktreePathToken(token);
+    }
+    if (argv[0] === 'git' && ['diff', '-C'].includes(argv[1]) && index >= (argv[1] === '-C' ? 5 : 3)) {
+      return !safeGitRevToken(token);
+    }
+    return !safeVerifyToken(token);
+  })) {
+    return { ok: false, reason: 'verify_command_not_allowed' };
+  }
+  const [bin, first, second] = argv;
+  const allowed = (bin === 'npm' && (
+    (first === 'test' && argv.length === 2)
+    || (first === 'run' && Boolean(second) && !second.startsWith('-') && argv.length === 3)
+  ))
+    || (bin === 'node' && (
+      (first === '--test' && safeNodePathArgs(argv.slice(2)))
+      || (first === '--check' && argv.length === 3 && safeRelativePathToken(second))
+      || (/^scripts\/[a-zA-Z0-9_./-]+$/.test(first || '') && safeNodePathArgs(argv.slice(1)))
+    ))
+    || (bin === 'tsc' && argv.length === 1)
+    || isAllowedGitDiffCheck(argv);
+  if (!allowed) return { ok: false, reason: 'verify_command_not_allowed' };
+  return { ok: true, argv };
+}
+
+function runVerifyCommand(verify, workspaceRoot) {
+  const parsed = parseVerifyCommand(verify);
+  if (!parsed.ok) return parsed;
+  const gitPathCheck = validateGitWorktreePath(parsed.argv, workspaceRoot);
+  if (!gitPathCheck.ok) return gitPathCheck;
+  const result = spawnSync(parsed.argv[0], parsed.argv.slice(1), {
+    cwd: workspaceRoot,
+    shell: false,
+    encoding: 'utf8',
+    timeout: 120000,
+  });
+  return {
+    ok: result.status === 0,
+    reason: result.status === 0 ? 'verify_passed' : 'verify_failed',
+    status: result.status,
+    stderr: String(result.stderr || '').slice(0, 400),
+  };
+}
+
+function strictVerifyMissingResult(ref) {
+  return {
+    eligible: false,
+    ref,
+    reason: 'strict_verify_missing',
+    next_action: 'rerun the review verifier and record a safe metadata.verify command before strict auto-accept',
+    review_chat_command: `atris task review-chat ${ref} --as codex-review`,
+  };
+}
+
+function evaluateAutoAccept(task, options = {}) {
+  const { strictVerify = false, minPasses = AGENT_CERTIFICATION_REVIEW_PASSES } = options;
+  const ref = task.display_id || task.legacy_ref || task.id;
+  if (task.status !== 'review') return { eligible: false, ref, reason: 'not_in_review' };
+  const metadata = task.metadata || {};
+  const review = task.review || {};
+  const approval = String(review.approval_status || metadata.approval_status || 'pending').toLowerCase();
+  if (approval && approval !== 'pending' && approval !== 'agent_certified') {
+    return { eligible: false, ref, reason: `approval_${approval}` };
+  }
+  if (metadata.auto_accepted_at) return { eligible: false, ref, reason: 'already_auto_accepted' };
+
+  const tag = String(task.tag || '').toLowerCase();
+  if (DENIED_TAGS.has(tag)) return { eligible: false, ref, reason: `denied_tag_${tag}` };
+
+  if (!isAgentCertified(task)) return { eligible: false, ref, reason: 'not_agent_certified' };
+
+  const passes = reviewPassCount(task);
+  if (passes < minPasses) return { eligible: false, ref, reason: 'insufficient_review_passes', passes };
+
+  const proof = latestProof(task);
+  if (proofHasUnmergedPullRequestBoundary(proof)) {
+    return unmergedPullRequestBoundaryResult(ref, proof);
+  }
+  const proofCheck = taskProofState(proof);
+  if (!proofCheck.ok) return { eligible: false, ref, reason: proofCheck.reason, proof };
+
+  const actors = distinctReviewActors(task);
+  const multiActor = actors.size >= 2;
+  const highConfidence = passes >= AUTO_ACCEPT_HIGH_CONFIDENCE_PASSES;
+  if (!multiActor && !highConfidence) {
+    return {
+      eligible: false,
+      ref,
+      reason: 'needs_second_reviewer_or_third_pass',
+      passes,
+      actors: [...actors],
+    };
+  }
+
+  if (strictVerify) {
+    const verify = metadata.verify;
+    if (!verify) return strictVerifyMissingResult(ref);
+    const workspaceRoot = task.workspace_root || process.cwd();
+    const verifyResult = runVerifyCommand(verify, workspaceRoot);
+    if (!verifyResult.ok) {
+      return { eligible: false, ref, reason: verifyResult.reason, verify, ...verifyResult };
+    }
+  }
+
+  return {
+    eligible: true,
+    ref,
+    reason: strictVerify
+      ? 'certified_strict_verify'
+      : (highConfidence ? 'certified_high_confidence' : 'certified_multi_actor'),
+    passes,
+    actors: [...actors],
+    proof,
+    policy: strictVerify ? 'strict_verify' : (highConfidence ? '3_passes' : '2_actors_2_passes'),
+  };
+}
+
+module.exports = {
+  AGENT_CERTIFICATION_REVIEW_PASSES,
+  AUTO_ACCEPT_HIGH_CONFIDENCE_PASSES,
+  DENIED_TAGS,
+  evaluateAutoAccept,
+  parseVerifyCommand,
+  runVerifyCommand,
+};

package/lib/file-ops.js

@@ -87,13 +87,6 @@ function createLogFile(logFile, dateFormatted) {
   fs.writeFileSync(logFile, initialContent);
 }
 
-function getTimeLabel() {
-  const now = new Date();
-  const hours = String(now.getHours()).padStart(2, '0');
-  const minutes = String(now.getMinutes()).padStart(2, '0');
-  return `${hours}:${minutes}`;
-}
-
 // Inbox operations
 function parseInboxItems(content) {
   const match = content.match(/## Inbox\n([\s\S]*?)(?=\n##|\n---|$)/);
@@ -139,11 +132,6 @@ function addInboxItemToContent(content, id, summary) {
   return replaceInboxSection(content, updatedItems);
 }
 
-function removeInboxItemFromContent(content, id) {
-  const items = parseInboxItems(content).filter((item) => item.id !== id);
-  return replaceInboxSection(content, items);
-}
-
 function getNextInboxId(content) {
   const items = parseInboxItems(content);
   if (items.length === 0) return 1;
@@ -158,185 +146,13 @@ function addInboxIdea(logFile, summary) {
   return nextId;
 }
 
-// Completion operations
-function parseCompletionItems(content) {
-  const match = content.match(/## Completed ✅\n([\s\S]*?)(?=\n##|\n---|$)/);
-  if (!match) {
-    return [];
-  }
-  const body = match[1];
-  const lines = body.split('\n');
-  const items = [];
-  lines.forEach((line) => {
-    const trimmed = line.trim();
-    if (!trimmed) return;
-    if (trimmed.startsWith('(Empty')) return;
-    const parsed = trimmed.match(/^- \*\*C(\d+):\*\*\s*(.+)$|^- \*\*C(\d+):\s+(.+)$/);
-    if (parsed) {
-      const id = parseInt(parsed[1] || parsed[3], 10);
-      const text = parsed[2] || parsed[4];
-      items.push({ id, text, line: trimmed });
-    }
-  });
-  return items;
-}
-
-function replaceCompletedSection(content, items) {
-  const regex = /(## Completed ✅\n)([\s\S]*?)(\n---|\n##|$)/;
-  if (!regex.test(content)) {
-    const lines = items.length ? items.map((item) => item.line).join('\n') : '';
-    return `${content}\n\n## Completed ✅\n\n${lines}\n`;
-  }
-
-  return content.replace(regex, (match, header, body, suffix) => {
-    const inner = items.length
-      ? `\n${items.map((item) => item.line).join('\n')}\n`
-      : '\n';
-    return `${header}${inner}${suffix}`;
-  });
-}
-
-function addCompletionItemToContent(content, id, summary) {
-  const items = parseCompletionItems(content).filter((item) => item.id !== id);
-  const newItem = { id, text: summary, line: `- **C${id}:** ${summary}` };
-  const updatedItems = [...items, newItem];
-  return replaceCompletedSection(content, updatedItems);
-}
-
-function getNextCompletionId(content) {
-  const items = parseCompletionItems(content);
-  if (items.length === 0) return 1;
-  return items.reduce((max, item) => (item.id > max ? item.id : max), 0) + 1;
-}
-
-// Notes operations
-function insertIntoNotesSection(content, block) {
-  const regex = /(## Notes\n)([\s\S]*?)(\n---|\n##|$)/;
-  const match = content.match(regex);
-  if (!match) {
-    return `${content}\n\n## Notes\n\n${block}\n`;
-  }
-  const header = match[1];
-  const body = match[2];
-  const suffix = match[3];
-  const trimmedBody = body.replace(/\s*$/, '');
-  const newBody = trimmedBody
-    ? `${trimmedBody}\n\n${block}\n`
-    : `\n${block}\n`;
-  return content.replace(regex, `${header}${newBody}${suffix}`);
-}
-
-function recordBrainstormSession(
-  logFile,
-  sourceLabel,
-  topic,
-  desiredOutcome,
-  keyQuestions,
-  focusAreas,
-  constraints,
-  references,
-  tonePreference,
-  nextSteps,
-  sessionSummary
-) {
-  let content = fs.readFileSync(logFile, 'utf8');
-  const lines = [
-    `### Brainstorm Session — ${getTimeLabel()}`,
-    `**Source:** ${sourceLabel}`,
-    `**Topic:** ${topic}`,
-  ];
-  if (desiredOutcome) {
-    lines.push(`**User Story / Desired Outcome:** ${desiredOutcome}`);
-  }
-  if (tonePreference) {
-    lines.push(`**Vibe / Feelings:** ${tonePreference}`);
-  }
-  if (keyQuestions && keyQuestions.length > 0) {
-    lines.push('**Key Questions:**');
-    keyQuestions.forEach((item) => lines.push(`- ${item}`));
-  }
-  if (focusAreas && focusAreas.length > 0) {
-    lines.push('**Focus Areas:**');
-    focusAreas.forEach((item) => lines.push(`- ${item}`));
-  }
-  if (constraints) {
-    lines.push(`**Constraints:** ${constraints}`);
-  }
-  if (references) {
-    lines.push(`**Context / References:** ${references}`);
-  }
-  if (sessionSummary) {
-    lines.push(`**Session Summary:** ${sessionSummary}`);
-  }
-  if (nextSteps && nextSteps.length > 0) {
-    lines.push('**Next Steps:**');
-    nextSteps.forEach((item) => lines.push(`- ${item}`));
-  }
-
-  const block = lines.join('\n');
-  content = insertIntoNotesSection(content, block);
-  fs.writeFileSync(logFile, content);
-}
-
-function recordAutopilotVision(logFile, sourceLabel, summary, successCriteria, riskNotes) {
-  const content = fs.readFileSync(logFile, 'utf8');
-  const lines = [
-    `### Autopilot Vision — ${getTimeLabel()}`,
-    `**Source:** ${sourceLabel}`,
-    `**Summary:** ${summary}`,
-    '**Success Criteria:**',
-    ...successCriteria.map((item) => `- ${item}`),
-  ];
-  if (riskNotes && riskNotes.trim()) {
-    lines.push(`**Risks / Notes:** ${riskNotes}`);
-  }
-  const block = lines.join('\n');
-  const updated = insertIntoNotesSection(content, block);
-  fs.writeFileSync(logFile, updated);
-}
-
-function recordAutopilotIteration(logFile, iteration, result, notes) {
-  const content = fs.readFileSync(logFile, 'utf8');
-  const lines = [
-    `### Autopilot Iteration ${iteration} — ${getTimeLabel()}`,
-    `**Validator Result:** ${result}`,
-  ];
-  if (notes && notes.trim()) {
-    lines.push(`**Notes:** ${notes}`);
-  }
-  const block = lines.join('\n');
-  const updated = insertIntoNotesSection(content, block);
-  fs.writeFileSync(logFile, updated);
-}
-
-function recordAutopilotSuccess(logFile, inboxId, summary) {
-  let content = fs.readFileSync(logFile, 'utf8');
-  if (typeof inboxId === 'number' && !Number.isNaN(inboxId)) {
-    content = removeInboxItemFromContent(content, inboxId);
-  }
-  const nextId = getNextCompletionId(content);
-  content = addCompletionItemToContent(content, nextId, `Autopilot — ${summary}`);
-  fs.writeFileSync(logFile, content);
-}
-
 module.exports = {
   getLogPath,
   ensureLogDirectory,
   createLogFile,
-  getTimeLabel,
   parseInboxItems,
   replaceInboxSection,
   addInboxItemToContent,
-  removeInboxItemFromContent,
   getNextInboxId,
   addInboxIdea,
-  parseCompletionItems,
-  replaceCompletedSection,
-  addCompletionItemToContent,
-  getNextCompletionId,
-  insertIntoNotesSection,
-  recordBrainstormSession,
-  recordAutopilotVision,
-  recordAutopilotIteration,
-  recordAutopilotSuccess,
 };