harness-everything 0.30.9 → 0.31.0

package/scripts/plugin-sync.js

@@ -177,20 +177,36 @@ function findMarketplace(payload, marketplace) {
 }
 
 function findPlugin(payload, plugin, marketplace) {
+  if (findPluginEntry(payload, plugin, marketplace)) return true;
+  if (hasExplicitUninstalledPlugin(payload, plugin, marketplace)) return false;
+  return collectStrings(payload).some(value => value.trim() === `${plugin}@${marketplace}`);
+}
+
+function pluginEntryMatches(value, keyHint, plugin, marketplace) {
   const pluginId = `${plugin}@${marketplace}`;
-  return collectStrings(payload).some(value => value.trim() === pluginId) || collectObjects(payload).some(({ value, keyHint }) => {
-    const identifiers = [value.id, value.pluginId, value.identifier, keyHint];
-    if (identifiers.some(candidate => exactString(candidate, pluginId))) return true;
-    const names = [value.name, value.plugin, value.pluginName];
-    if (!names.some(candidate => exactString(candidate, plugin))) return false;
-    const sources = [
-      value.marketplace,
-      value.marketplaceName,
-      value.source && value.source.name,
-      value.source && value.source.id
-    ].filter(Boolean);
-    return sources.length === 0 || sources.some(source => exactString(source, marketplace));
-  });
+  const identifiers = [value.id, value.pluginId, value.identifier, keyHint];
+  if (identifiers.some(candidate => exactString(candidate, pluginId))) return true;
+  const names = [value.name, value.plugin, value.pluginName];
+  if (!names.some(candidate => exactString(candidate, plugin))) return false;
+  const sources = [
+    value.marketplace,
+    value.marketplaceName,
+    value.source && value.source.name,
+    value.source && value.source.id
+  ].filter(Boolean);
+  return sources.length === 0 || sources.some(source => exactString(source, marketplace));
+}
+
+function findPluginEntry(payload, plugin, marketplace) {
+  return collectObjects(payload).find(({ value, keyHint }) =>
+    value.installed !== false && pluginEntryMatches(value, keyHint, plugin, marketplace)
+  )?.value || null;
+}
+
+function hasExplicitUninstalledPlugin(payload, plugin, marketplace) {
+  return collectObjects(payload).some(({ value, keyHint }) =>
+    value.installed === false && pluginEntryMatches(value, keyHint, plugin, marketplace)
+  );
 }
 
 function escapeRegExp(value) {
@@ -232,6 +248,11 @@ function createContext(options = {}) {
       return result && result.status === 0 && !result.error;
     })
   };
+  context.codexHooksInstall = options.codexHooksInstall || (installOptions => require('./codex-hooks-compat').install({
+    ...installOptions,
+    codexHome: options.codexHome,
+    env: options.env
+  }));
   context.repositorySource = options.repositorySource || (
     /^https?:\/\//.test(context.repository) || /^git@/.test(context.repository)
       ? context.repository
@@ -375,25 +396,30 @@ function queryCodexMarketplace(context) {
 }
 
 function queryCodexPlugin(context) {
-  const state = listState(context, {
+  const query = (jsonArgs, plainArgs) => listState(context, {
     command: 'codex',
-    jsonArgs: ['plugin', 'list', '--marketplace', context.marketplace, '--json'],
-    plainArgs: ['plugin', 'list', '--marketplace', context.marketplace],
-    detectJson: payload => findPlugin(payload, context.plugin, context.marketplace),
+    jsonArgs,
+    plainArgs,
+    detectJson: payload => findPluginEntry(payload, context.plugin, context.marketplace) ||
+      (findPlugin(payload, context.plugin, context.marketplace) ? { detected: true } : null),
     detectText: output => textHasPlugin(output, context.plugin, context.marketplace)
   });
-  if (state.known) return state;
+  let state = query(
+    ['plugin', 'list', '--marketplace', context.marketplace, '--json'],
+    ['plugin', 'list', '--marketplace', context.marketplace]
+  );
 
   // Older Codex builds may not accept --marketplace on plugin list. A full
   // list still lets us fail closed while supporting those builds when JSON is
   // available.
-  return listState(context, {
-    command: 'codex',
-    jsonArgs: ['plugin', 'list', '--json'],
-    plainArgs: ['plugin', 'list'],
-    detectJson: payload => findPlugin(payload, context.plugin, context.marketplace),
-    detectText: output => textHasPlugin(output, context.plugin, context.marketplace)
-  });
+  if (!state.known) {
+    state = query(['plugin', 'list', '--json'], ['plugin', 'list']);
+  }
+  if (state.known) {
+    state.plugin = state.value && typeof state.value === 'object' ? state.value : null;
+    state.value = Boolean(state.plugin || state.value);
+  }
+  return state;
 }
 
 function ensureClaudeMarketplace(context) {
@@ -452,7 +478,7 @@ function verifyPlugin(context, host, queryPlugin) {
   const state = queryPlugin(context);
   if (!state.known) return { ok: false, error: `${host} plugin state could not be verified: ${state.error}` };
   if (!state.value) return { ok: false, error: `${host} reports ${context.plugin}@${context.marketplace} is not installed after synchronization` };
-  return { ok: true };
+  return { ok: true, state };
 }
 
 function syncClaude(context) {
@@ -477,6 +503,37 @@ function syncClaude(context) {
   return { host: 'claude', status: 'synchronized', action };
 }
 
+function refreshCodexCompatibilityHooks(context, sourcePluginRoot) {
+  if (context.dryRun) return { ok: true, result: { status: 'dry-run', entries: 0, trustChanged: false } };
+  if (!sourcePluginRoot) {
+    return { ok: false, error: 'Codex did not report the installed plugin source path; refusing to copy hooks from the sync package' };
+  }
+  try {
+    const result = context.codexHooksInstall({ sourcePluginRoot });
+    if (!result || !['installed', 'updated'].includes(result.status)) {
+      return { ok: false, error: 'Codex compatibility-hook installer returned an unexpected result' };
+    }
+    return { ok: true, result };
+  } catch (error) {
+    return { ok: false, error: error && error.message ? error.message : String(error) };
+  }
+}
+
+function codexLocalPluginRoot(plugin) {
+  const source = plugin && plugin.source;
+  if (!source || typeof source !== 'object') {
+    return { ok: false, error: 'Codex did not report a tagged installed plugin source' };
+  }
+  if (source.source !== 'local') {
+    const variant = typeof source.source === 'string' ? source.source : 'missing';
+    return { ok: false, error: `Codex installed plugin source variant "${variant}" is unsupported; compatibility hooks require source "local"` };
+  }
+  if (typeof source.path !== 'string' || !source.path.trim() || !path.isAbsolute(source.path)) {
+    return { ok: false, error: 'Codex local plugin source must report an absolute filesystem path' };
+  }
+  return { ok: true, path: source.path };
+}
+
 function syncCodex(context) {
   if (!context.commandAvailable('codex')) return { host: 'codex', status: 'skipped', reasonCode: 'cli-not-found', reason: 'codex CLI not found' };
   const marketplace = ensureCodexMarketplace(context);
@@ -527,7 +584,19 @@ function syncCodex(context) {
 
   const verification = verifyPlugin(context, 'Codex', queryCodexPlugin);
   if (!verification.ok) return { host: 'codex', status: 'failed', error: verification.error };
-  return { host: 'codex', status: 'synchronized', action };
+  const localSource = context.dryRun ? { ok: true, path: null } : codexLocalPluginRoot(verification.state && verification.state.plugin);
+  if (!localSource.ok) {
+    return {
+      host: 'codex',
+      status: 'failed',
+      action,
+      error: `Codex plugin ${action} succeeded but compatibility hooks could not be refreshed: ${localSource.error}`
+    };
+  }
+  const sourcePluginRoot = localSource.path;
+  const compatHooks = refreshCodexCompatibilityHooks(context, sourcePluginRoot);
+  if (!compatHooks.ok) return { host: 'codex', status: 'failed', action, error: 'Codex plugin ' + action + ' succeeded but compatibility hooks could not be refreshed: ' + compatHooks.error };
+  return { host: 'codex', status: 'synchronized', action, compatHooks: compatHooks.result };
 }
 
 function parseArgs(argv) {
@@ -560,7 +629,9 @@ function help() {
 
 Synchronize the native Harness Everything plugin on installed host CLIs.
 Existing installations take the explicit update/upgrade path; absent
-installations take the install path.
+installations take the install path. Successful Codex sync also refreshes the
+local compatibility-hook runtime and user hook entries; Codex trust remains a
+separate host review.
 
 Options:
   --host <all|claude|codex>  Limit synchronization to one host (default: all)
@@ -615,7 +686,7 @@ function main(argv = process.argv.slice(2)) {
   if (options.json) console.log(JSON.stringify(summary, null, 2));
   else {
     for (const result of summary.results) {
-      if (result.status === 'synchronized') console.log(`[ok] ${result.host}: ${result.action}`);
+      if (result.status === 'synchronized') console.log('[ok] ' + result.host + ': ' + result.action + (result.compatHooks ? '; Codex hooks ' + result.compatHooks.status : ''));
       else if (result.status === 'skipped') console.log(`[skip] ${result.host}: ${result.reason}`);
       else console.error(`[fail] ${result.host}: ${result.error}`);
     }

package/scripts/system-one-observations-export.js

@@ -14,6 +14,14 @@ function option(args, name, fallback) {
   return i !== -1 ? args[i + 1] : fallback;
 }
 
+function parseSince(value) {
+  const text = String(value || '');
+  const normalized = /^\d{4}-\d{2}-\d{2}$/.test(text) ? text + 'T00:00:00.000Z' : text;
+  const timestamp = Date.parse(normalized);
+  if (!Number.isFinite(timestamp)) throw new Error('--since must be an ISO date or timestamp');
+  return timestamp;
+}
+
 function family(text) {
   const normalized = String(text || '').toLowerCase().replace(/[\p{P}\p{S}\d]+/gu, ' ').replace(/\s+/g, ' ').trim().slice(0, 48);
   return crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 12);
@@ -37,6 +45,7 @@ function loadReview(file) {
 
 function derive(record, owner) {
   const self = record.selfReport;
+  const behavior = record.captureMethod === 'session-backfill' ? null : record.behavior;
   let validity = self ? self.validity : null;
   let contextDependent = self ? self.contextDependent : null;
   if (owner && owner.validity && owner.validity !== 'unsure') validity = owner.validity;
@@ -48,7 +57,9 @@ function derive(record, owner) {
   return {
     id: record.id, validity, contextDependent, tier, tierSource,
     intents: self ? self.intents : [], workflow: (self && self.workflow) || (record.router && record.router.strategy) || null,
-    skills, contradictions: obs.contradictions(self, record.behavior),
+    skills,
+    behaviorEvidence: behavior ? 'observed' : 'unobserved',
+    contradictions: obs.contradictions(self, behavior),
     selfReportReason: record.selfReportReason || null, host: record.host,
   };
 }
@@ -63,13 +74,23 @@ function run(args) {
   if (!out) throw new Error('--out is required');
   const share = Number(option(args, '--validation-share', '0.15'));
   const owner = loadReview(option(args, '--owner-review'));
+  const sinceText = option(args, '--since', null);
+  const since = sinceText ? parseSince(sinceText) : null;
+  const selfReportOnly = args.includes('--self-report-only');
   obs.sweep(store);
   const index = obs.readJson(path.join(store, 'observations-index.json'), null);
   if (!index || index.schemaVersion !== 1 || !Array.isArray(index.records)) throw new Error(`no observation index in ${store}`);
   const rows = [];
   let skippedNoText = 0;
+  let skippedBeforeSince = 0;
+  let skippedUnlabeled = 0;
   const now = Date.now();
   for (const record of index.records) {
+    if (since !== null) {
+      const observedAt = Date.parse(record.observedAt || '');
+      if (!Number.isFinite(observedAt) || observedAt < since) { skippedBeforeSince++; continue; }
+    }
+    if (selfReportOnly && !record.selfReport) { skippedUnlabeled++; continue; }
     // Expiry holds on read too, even if no later turn has swept the store.
     const text = obs.recordText(store, record, now);
     if (!text || !text.prompt) { skippedNoText++; continue; }
@@ -91,9 +112,15 @@ function run(args) {
   const count = key => rows.reduce((acc, r) => { const k = String(key(r)); acc[k] = (acc[k] || 0) + 1; return acc; }, {});
   const report = {
     schemaVersion: 1, exportedAt: new Date().toISOString(), records: index.records.length, exported: rows.length,
+    since: sinceText, selfReportOnly, skippedBeforeSince, skippedUnlabeled,
     skippedNoText, validationRows: validation, withSelfReport: withSelf.length,
     selfReportReasons: count(r => r.record.selfReportReason || 'ok'), hosts: count(r => r.record.host),
     validity: count(r => r.label.validity), tiers: count(r => r.label.tier), tierSources: count(r => r.label.tierSource),
+    behaviorEvidence: {
+      observed: rows.filter(r => r.label.behaviorEvidence === 'observed').length,
+      unobserved: rows.filter(r => r.label.behaviorEvidence === 'unobserved').length,
+    },
+    contradictionEvidence: 'observed-behavior-only',
     ownerDecisions: Object.keys(owner).length, agreement, contradictions,
   };
   fs.writeFileSync(path.join(out, 'export-report.json'), JSON.stringify(report, null, 2) + '\n');
@@ -103,4 +130,4 @@ function run(args) {
 if (require.main === module) {
   try { console.log(JSON.stringify(run(process.argv.slice(2)), null, 2)); } catch (error) { console.error(`ERROR: ${error.message}`); process.exitCode = 1; }
 }
-module.exports = { run, derive, family };
+module.exports = { run, derive, family, parseSince };

package/scripts/system-one-observations-import-codex-sessions.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+'use strict';
+
+// Backfill valid Codex self-report labels from local rollout files into the
+// private System One observations store. The importer never uploads session
+// data and only persists user prompt text after the standard local redaction.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const { createReadStream } = require('fs');
+const obs = require('../hooks/scripts/lib/observations');
+
+const DEFAULT_SINCE = '2026-09-27';
+
+function option(args, name, fallback) {
+  const index = args.indexOf(name);
+  return index === -1 ? fallback : args[index + 1];
+}
+
+function defaultCodexHome(env = process.env) {
+  return path.resolve(env.CODEX_HOME || path.join(os.homedir(), '.codex'));
+}
+
+function parseSince(value) {
+  const text = String(value || DEFAULT_SINCE);
+  const normalized = /^\d{4}-\d{2}-\d{2}$/.test(text) ? text + 'T00:00:00.000Z' : text;
+  const timestamp = Date.parse(normalized);
+  if (!Number.isFinite(timestamp)) throw new Error('--since must be an ISO date or timestamp');
+  return timestamp;
+}
+
+function sessionFiles(root) {
+  if (!fs.existsSync(root)) throw new Error('Codex sessions directory does not exist: ' + root);
+  const files = [];
+  function walk(directory) {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const full = path.join(directory, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile() && entry.name.endsWith('.jsonl')) files.push(full);
+    }
+  }
+  walk(root);
+  return files;
+}
+
+function firstUserText(payload) {
+  if (typeof payload.content === 'string') return payload.content;
+  if (!Array.isArray(payload.content)) return '';
+  const item = payload.content.find(entry => entry && entry.type === 'input_text' && typeof entry.text === 'string');
+  return item ? item.text : '';
+}
+
+function assistantText(payload) {
+  if (typeof payload.content === 'string') return payload.content;
+  if (!Array.isArray(payload.content)) return '';
+  return payload.content
+    .filter(entry => entry && ['output_text', 'text'].includes(entry.type) && typeof entry.text === 'string')
+    .map(entry => entry.text)
+    .join('\n');
+}
+
+function isoTimestamp(value) {
+  const timestamp = Date.parse(String(value || ''));
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
+}
+
+function completionLabel(message) {
+  const result = obs.parseLabelLine(typeof message === 'string' ? message : '');
+  if (result.label) return { label: result.label, reason: null };
+  return { label: null, reason: result.reason };
+}
+
+function reconcileFinalMessage(payload, current) {
+  const hasCompletionMessage = Object.prototype.hasOwnProperty.call(payload, 'last_agent_message') &&
+    typeof payload.last_agent_message === 'string';
+  const assistantCanRepresentFinal = current.lastAssistantPhase !== 'commentary';
+  const assistantMessage = assistantCanRepresentFinal ? current.lastAssistantMessage : '';
+  let message = hasCompletionMessage ? payload.last_agent_message : assistantMessage;
+  let parsed = completionLabel(message);
+  let ambiguous = false;
+
+  if (hasCompletionMessage && parsed.reason === 'label-missing' && assistantMessage) {
+    const assistantParsed = completionLabel(assistantMessage);
+    if (assistantParsed.label) {
+      const sameBody = obs.stripLabels(message) === obs.stripLabels(assistantMessage);
+      if (sameBody) {
+        message = assistantMessage;
+        parsed = assistantParsed;
+      } else if (!sameBody) {
+        // Both sources describe the final reply, but disagree about its body.
+        // Do not guess which text is authoritative or let either seed context.
+        message = null;
+        parsed = { label: null, reason: 'label-missing' };
+        ambiguous = true;
+      }
+    }
+  }
+
+  return { message, parsed, ambiguous };
+}
+
+function blankReport(filesScanned) {
+  return {
+    since: DEFAULT_SINCE,
+    filesScanned,
+    turnsScanned: 0,
+    eligibleTurns: 0,
+    validLabels: 0,
+    imported: 0,
+    migratedUnobservedBehavior: 0,
+    skipped: {
+      beforeCutoff: 0,
+      missingLabel: 0,
+      invalidLabel: 0,
+      missingPrompt: 0,
+      invalidTimestamp: 0,
+      turnMismatch: 0,
+      duplicate: 0,
+      ambiguousLiveMatch: 0,
+      ambiguousFinalMessage: 0,
+    },
+    failed: { lockTimeout: 0 },
+    errors: [],
+  };
+}
+
+async function importSessions(options = {}) {
+  const sessionsRoot = path.resolve(options.sessionsDir || path.join(defaultCodexHome(options.env), 'sessions'));
+  const store = path.resolve(options.store || obs.storeRoot(options.env));
+  const since = options.since || DEFAULT_SINCE;
+  const cutoff = parseSince(since);
+  const files = sessionFiles(sessionsRoot);
+  const report = blankReport(files.length);
+  report.since = since;
+  const migrated = obs.markSessionBackfillBehaviorUnobserved(store, { lockTimeoutMs: options.lockTimeoutMs });
+  if (migrated === null) {
+    report.failed.lockTimeout++;
+    report.errors.push('Observation store lock timed out during behavior migration; no session rows were imported.');
+    return report;
+  }
+  report.migratedUnobservedBehavior = migrated;
+
+  for (const file of files) {
+    let sessionId = path.basename(file, '.jsonl');
+    let turnNumber = 0;
+    let current = null;
+    let previousFinal = '';
+    let previousAt = null;
+    const lines = readline.createInterface({ input: createReadStream(file, { encoding: 'utf8' }), crlfDelay: Infinity });
+
+    for await (const line of lines) {
+      if (!line) continue;
+      let row;
+      try { row = JSON.parse(line); } catch (_) { continue; }
+      const payload = row.payload && typeof row.payload === 'object' ? row.payload : {};
+      if (row.type === 'session_meta') {
+        sessionId = String(payload.session_id || payload.id || sessionId);
+        continue;
+      }
+      if (row.type === 'event_msg' && payload.type === 'task_started') {
+        if (current) current = null;
+        turnNumber++;
+        current = {
+          turn: turnNumber,
+          turnId: String(payload.turn_id || ''),
+          startedAt: isoTimestamp(row.timestamp || payload.started_at),
+          prompt: '',
+          promptSeen: false,
+          lastAssistantMessage: '',
+          lastAssistantPhase: null,
+          previous: '',
+          previousAt: null,
+        };
+        if (previousFinal && previousAt && current.startedAt) {
+          const age = Date.parse(current.startedAt) - Date.parse(previousAt);
+          if (age >= 0 && age <= obs.RETENTION_MS) {
+            current.previous = obs.redact(obs.tailBytes(obs.stripLabels(previousFinal), obs.PREVIOUS_BYTES));
+            current.previousAt = previousAt;
+          }
+        }
+        continue;
+      }
+      if (!current) continue;
+      if (row.type === 'response_item' && payload.type === 'message' && payload.role === 'user' && !current.promptSeen) {
+        current.promptSeen = true;
+        current.prompt = firstUserText(payload);
+        continue;
+      }
+      if (row.type === 'response_item' && payload.type === 'message' && payload.role === 'assistant') {
+        current.lastAssistantMessage = assistantText(payload);
+        current.lastAssistantPhase = typeof payload.phase === 'string' ? payload.phase : null;
+        continue;
+      }
+      if (row.type !== 'event_msg' || payload.type !== 'task_complete') continue;
+      const completedTurnId = String(payload.turn_id || '');
+      if (current.turnId && completedTurnId && current.turnId !== completedTurnId) {
+        report.skipped.turnMismatch++;
+        continue;
+      }
+      if (!current.turnId && completedTurnId) current.turnId = completedTurnId;
+
+      report.turnsScanned++;
+      const startedMs = Date.parse(current.startedAt || '');
+      const reconciledFinal = reconcileFinalMessage(payload, current);
+      const finalMessage = reconciledFinal.message;
+      if (!Number.isFinite(startedMs)) {
+        report.skipped.invalidTimestamp++;
+      } else if (startedMs < cutoff) {
+        report.skipped.beforeCutoff++;
+      } else {
+        report.eligibleTurns++;
+        const parsed = reconciledFinal.parsed;
+        if (reconciledFinal.ambiguous) {
+          report.skipped.ambiguousFinalMessage++;
+        } else if (!parsed.label) {
+          report.skipped[parsed.reason === 'label-missing' ? 'missingLabel' : 'invalidLabel']++;
+        } else {
+          report.validLabels++;
+          if (!current.prompt || !current.prompt.trim()) {
+            report.skipped.missingPrompt++;
+          } else {
+            const prompt = obs.redact(current.prompt);
+            const previous = current.previous || '';
+            const text = { prompt, previous };
+            const completedAt = isoTimestamp(payload.completed_at || row.timestamp) || current.startedAt;
+            const capturedAt = current.previousAt
+              ? Math.min(startedMs, Date.parse(current.previousAt))
+              : startedMs;
+            const validUntil = new Date(capturedAt + obs.RETENTION_MS).toISOString();
+            const expired = Date.parse(validUntil) <= Date.now();
+            const record = {
+              id: obs.sha('session-backfill:' + sessionId + ':' + (current.turnId || current.turn) + ':' + current.startedAt, 24),
+              source: 'observation',
+              captureMethod: 'session-backfill',
+              status: expired ? 'expired' : 'active',
+              ...(expired ? { textDeleted: true } : {}),
+              observedAt: completedAt,
+              validUntil,
+              contentSha256: obs.sha(JSON.stringify(text)),
+              host: 'codex',
+              turn: current.turn,
+              writer: { sessionId, ...(current.turnId ? { turnId: current.turnId } : {}) },
+              scope: { taskTerms: obs.normalizeTerms(prompt), requirementTerms: [], roles: [] },
+              promptBytes: Buffer.byteLength(prompt, 'utf8'),
+              router: null,
+              behavior: null,
+              selfReport: parsed.label,
+              selfReportReason: null,
+            };
+            const appendOptions = {
+              dedupeById: true,
+              dedupeByTurn: true,
+              ...(options.lockTimeoutMs === undefined ? {} : { lockTimeoutMs: options.lockTimeoutMs }),
+            };
+            const appended = obs.appendRecordDetailed(store, record, expired ? null : text, appendOptions);
+            if (appended.status === 'appended') report.imported++;
+            else if (appended.status === 'duplicate') report.skipped.duplicate++;
+            else if (appended.status === 'ambiguous') report.skipped.ambiguousLiveMatch++;
+            else if (appended.status === 'lock-timeout') {
+              report.failed.lockTimeout++;
+              report.errors.push('Observation store lock timed out while appending a session turn; the record was not persisted.');
+              return report;
+            }
+          }
+        }
+      }
+
+      previousFinal = reconciledFinal.ambiguous ? '' : (typeof finalMessage === 'string' ? finalMessage : '');
+      previousAt = previousFinal ? isoTimestamp(payload.completed_at || row.timestamp) : null;
+      current = null;
+    }
+  }
+  return report;
+}
+
+function parseArgs(args) {
+  if (args.length % 2 !== 0) throw new Error('Usage: node scripts/system-one-observations-import-codex-sessions.js [--sessions DIR] [--store DIR] [--since YYYY-MM-DD]');
+  const result = { sessionsDir: undefined, store: undefined, since: DEFAULT_SINCE };
+  for (let index = 0; index < args.length; index += 2) {
+    const name = args[index];
+    const value = args[index + 1];
+    if (!value || !['--sessions', '--store', '--since'].includes(name)) {
+      throw new Error('Usage: node scripts/system-one-observations-import-codex-sessions.js [--sessions DIR] [--store DIR] [--since YYYY-MM-DD]');
+    }
+    if (name === '--sessions') result.sessionsDir = value;
+    else if (name === '--store') result.store = value;
+    else result.since = value;
+  }
+  return result;
+}
+
+async function main(args = process.argv.slice(2)) {
+  try {
+    const report = await importSessions(parseArgs(args));
+    process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+    return report.failed.lockTimeout ? 1 : 0;
+  } catch (error) {
+    process.stderr.write('ERROR: ' + error.message + '\n');
+    return 1;
+  }
+}
+
+if (require.main === module) main().then(code => { process.exitCode = code; });
+
+module.exports = { DEFAULT_SINCE, assistantText, firstUserText, importSessions, parseSince, reconcileFinalMessage, sessionFiles };

package/scripts/system-one-observations-review.js

@@ -21,6 +21,8 @@ function option(args, name, fallback) {
 function disagrees(record) {
   const self = record.selfReport;
   if (!self) return true;
+  const behaviorObserved = record.captureMethod !== 'session-backfill' && record.behavior !== null && record.behavior !== undefined;
+  if (!behaviorObserved) return true;
   if (obs.contradictions(self, record.behavior).length) return true;
   return Boolean(record.router && record.router.tier && self.tier && record.router.tier !== self.tier);
 }
@@ -39,6 +41,7 @@ main{max-width:860px;margin:0 auto;padding:16px}.box{white-space:pre-wrap;word-b
 <div class="row"><span id="pos"></span><button id="prev">&larr;</button><button id="next">&rarr;</button><button id="exp">Export JSON</button><span id="stat" class="prev"></span></div>
 <h3>Previous assistant message</h3><div class="box prev" id="previous"></div>
 <h3>Prompt</h3><div class="box" id="prompt"></div>
+<h3>Behavior evidence</h3><div class="box" id="behavior"></div>
 <div class="row"><label>Validity <select id="validity"><option value="">—</option><option>actionable</option><option>invalid</option><option>unsure</option></select></label>
 <label>Needs context <select id="contextDependent"><option value="">—</option><option value="true">yes</option><option value="false">no</option></select></label>
 <label>Tier <select id="tier"><option value="">—</option><option>tier1</option><option>tier2</option><option>tier3</option></select></label></div>
@@ -49,6 +52,7 @@ const $=id=>document.getElementById(id);
 function save(){try{localStorage.setItem(KEY,JSON.stringify(st))}catch(e){}}
 function render(){if(!ITEMS.length){$('prompt').textContent='Nothing to review.';return}const it=ITEMS[i],d=st[it.id]||{};
 $('pos').textContent=(i+1)+' / '+ITEMS.length;$('prompt').textContent=it.prompt;$('previous').textContent=it.previous||'(none)';
+$('behavior').textContent=it.behaviorEvidence==='observed'?'Observed by local hook collection.':'Behavior evidence is unobserved; session backfill did not record tool events or file writes.';
 $('validity').value=d.validity||'';$('tier').value=d.tier||'';$('contextDependent').value=typeof d.contextDependent==='boolean'?String(d.contextDependent):'';$('stat').textContent='decided '+Object.keys(st).length}
 function set(){const it=ITEMS[i];const cd=$('contextDependent').value;st[it.id]={id:it.id,validity:$('validity').value||null,contextDependent:cd==='true'?true:cd==='false'?false:null,tier:$('tier').value||null,decidedAt:new Date().toISOString()};save();render()}
 $('validity').onchange=set;$('contextDependent').onchange=set;$('tier').onchange=set;$('prev').onclick=()=>{if(i>0)i--;render()};$('next').onclick=()=>{if(i<ITEMS.length-1)i++;render()};
@@ -72,7 +76,13 @@ function run(args) {
     if (!all && !disagrees(record)) continue;
     const text = obs.recordText(store, record, now);
     if (!text || !text.prompt) continue;
-    items.push({ id: record.id, prompt: text.prompt, previous: text.previous || '' });
+    items.push({
+      id: record.id,
+      prompt: text.prompt,
+      previous: text.previous || '',
+      behaviorEvidence: record.captureMethod !== 'session-backfill' && record.behavior !== null && record.behavior !== undefined
+        ? 'observed' : 'unobserved',
+    });
     if (items.length >= limit) break;
   }
   fs.mkdirSync(path.dirname(path.resolve(out)), { recursive: true });