create-walle 0.9.11 → 0.9.13

package/template/wall-e/skills/script-skill-runner.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+const { findSkill } = require('./skill-loader');
+
+const WALL_E_DIR = path.join(__dirname, '..');
+
+async function runScriptSkillByName(skillName, task = {}, opts = {}) {
+  const skill = opts.skill || findSkill(skillName);
+  if (!skill) throw new Error(`Skill not found: ${skillName}`);
+  return runScriptSkill(skill, task, opts);
+}
+
+function runScriptSkill(skill, task = {}, opts = {}) {
+  if (!skill || skill.execution !== 'script') {
+    throw new Error(`Skill "${skill?.name || 'unknown'}" is not script-based`);
+  }
+  const entryPath = resolveSkillEntry(skill);
+  const skillConfig = buildSkillConfig(skill, task);
+  const args = buildSkillArgs(skill, skillConfig);
+  const log = typeof opts.log === 'function' ? opts.log : () => {};
+  log(`Running: node ${entryPath}${args.length ? ' ' + args.join(' ') : ''}`);
+
+  return new Promise((resolve, reject) => {
+    const env = {
+      ...process.env,
+      HOME: process.env.HOME,
+      WALL_E_SKILL_CONFIG: JSON.stringify(skillConfig),
+      WALL_E_SKILL_DIR: skill.dir,
+      WALL_E_SRC_DIR: WALL_E_DIR,
+      ...(opts.env || {}),
+    };
+    if (task.checkpoint) env.WALL_E_CHECKPOINT = task.checkpoint;
+
+    const child = spawn(process.execPath, [entryPath, ...args], {
+      cwd: opts.cwd || WALL_E_DIR,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (typeof opts.onProcess === 'function') opts.onProcess(child);
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk;
+      for (const line of chunk.split('\n').filter(Boolean)) {
+        log(line);
+        if (line.startsWith('CHECKPOINT:') && typeof opts.onCheckpoint === 'function') {
+          opts.onCheckpoint(line.slice(11).trim());
+        }
+      }
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk;
+      for (const line of chunk.split('\n').filter(Boolean)) log(`[stderr] ${line}`);
+    });
+    child.on('close', (code) => {
+      if (typeof opts.onClose === 'function') opts.onClose(child, code);
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Exit code ${code}: ${stderr.slice(0, 500)}`));
+        return;
+      }
+      let output = stdout.trim();
+      if (stderr.trim()) output += '\n[stderr] ' + stderr.trim();
+      resolve(output);
+    });
+    child.on('error', (err) => {
+      if (typeof opts.onClose === 'function') opts.onClose(child, null);
+      reject(err);
+    });
+  });
+}
+
+function resolveSkillEntry(skill) {
+  const entry = skill.entry || 'run.js';
+  const entryPath = path.resolve(skill.dir, entry);
+  const lexicalSkillRel = path.relative(path.resolve(skill.dir), entryPath);
+  const lexicalWallERel = path.relative(WALL_E_DIR, entryPath);
+  const lexicallyInsideSkill = !lexicalSkillRel.startsWith('..') && !path.isAbsolute(lexicalSkillRel);
+  const lexicallyInsideWallE = !lexicalWallERel.startsWith('..') && !path.isAbsolute(lexicalWallERel);
+  if (!lexicallyInsideSkill && !lexicallyInsideWallE) {
+    throw new Error(`Script skill ${skill.name} entry escapes skill and Wall-E directories`);
+  }
+  if (!fs.existsSync(entryPath)) {
+    throw new Error(`Skill entry point not found: ${entryPath}`);
+  }
+  const realEntryPath = fs.realpathSync(entryPath);
+  const realSkillDir = fs.realpathSync(skill.dir);
+  const realWallEDir = fs.realpathSync(WALL_E_DIR);
+  const skillRel = path.relative(realSkillDir, realEntryPath);
+  const wallERel = path.relative(realWallEDir, realEntryPath);
+  const insideSkillDir = !skillRel.startsWith('..') && !path.isAbsolute(skillRel);
+  const insideWallE = !wallERel.startsWith('..') && !path.isAbsolute(wallERel);
+  if (!insideSkillDir && !insideWallE) {
+    throw new Error(`Script skill ${skill.name} entry escapes skill and Wall-E directories`);
+  }
+  return realEntryPath;
+}
+
+function buildSkillConfig(skill, task = {}) {
+  const skillConfig = {};
+  if (skill.config) {
+    for (const [key, value] of Object.entries(skill.config)) {
+      if (value && typeof value === 'object' && value.default !== undefined) {
+        skillConfig[key] = value.default;
+      }
+    }
+  }
+  let taskConfig = {};
+  if (task.skill_config) {
+    if (typeof task.skill_config === 'string') {
+      try {
+        taskConfig = JSON.parse(task.skill_config);
+      } catch {
+        taskConfig = {};
+      }
+    } else {
+      taskConfig = task.skill_config;
+    }
+  }
+  return { ...skillConfig, ...taskConfig };
+}
+
+function buildSkillArgs(skill, skillConfig = {}) {
+  const args = [...(skill.args || [])].map(arg => String(arg));
+  if (skillConfig.mode && !args.includes(skillConfig.mode) && skill.name === 'slack-backfill') {
+    args.push(String(skillConfig.mode));
+    if (skillConfig.month) args.push(String(skillConfig.month));
+  }
+  return args;
+}
+
+module.exports = {
+  buildSkillArgs,
+  buildSkillConfig,
+  resolveSkillEntry,
+  runScriptSkill,
+  runScriptSkillByName,
+};

package/template/wall-e/skills/skill-executor.js

@@ -1,6 +1,6 @@
 'use strict';
 const brain = require('../brain');
-const { getDefaultClient } = require('../llm/client');
+const { getDefaultClient, getDefaultModel, resolveCompatibleModel } = require('../llm/client');
 const { executeTool, getToolDefinitions } = require('./tool-executor');
 const { augmentSystemPrompt } = require('../loops/loop-directives');
 let telemetry;
@@ -16,7 +16,7 @@ try { telemetry = require('../telemetry'); } catch { telemetry = { track() {} };
  */
 async function runSkill(skill, opts = {}) {
   const { selectSkillHarness, ensureDefaultHarness } = require('./skill-harness-registry');
-  ensureDefaultHarness();
+  ensureDefaultHarness(_runSkillInternal);
   const selection = selectSkillHarness(skill, opts);
   // Log the selection — mirrors OpenClaw's logAgentHarnessSelection
   // (selection.ts:246). Even at debug level, the trail exists in telemetry.
@@ -39,9 +39,6 @@ async function _runSkillInternal(skill, opts = {}) {
   const ownerName = brain.getOwnerName();
   const startTime = Date.now();
 
-  // Resolve model once so it can be tagged on skill_executions (Item G).
-  // Single source of truth — same precedence as the API call below.
-  const resolvedModel = opts.model || process.env.WALLE_MODEL || 'claude-haiku-4-5-20251001';
   const decisionReason = opts.decision_reason || 'due';
 
   // Build tool definitions — use skill's custom ones or defaults
@@ -52,8 +49,10 @@ async function _runSkillInternal(skill, opts = {}) {
   // Build the prompt
   const prompt = skill.prompt_template || buildDefaultPrompt(skill, ownerName);
 
-  // Call Claude with tools
+  // Call the configured provider with a provider-compatible model. This avoids
+  // sending stale Claude model ids to Gemini/OpenAI after provider switches.
   const provider = getDefaultClient();
+  const resolvedModel = resolveCompatibleModel(opts.model || process.env.WALLE_MODEL || getDefaultModel(), provider.type);
   const messages = [{ role: 'user', content: prompt }];
   const allToolCalls = [];
   const allToolResults = [];

package/template/wall-e/skills/skill-fallback.js

@@ -30,6 +30,7 @@
 
 let telemetry;
 try { telemetry = require('../telemetry'); } catch { telemetry = { track() {} }; }
+const { getDefaultModel, getDefaultProviderType, resolveCompatibleModel } = require('../llm/client');
 
 function _resolveCandidates(skill, opts) {
   if (Array.isArray(opts?.model_candidates) && opts.model_candidates.length) {
@@ -68,7 +69,8 @@ function _resolveCandidates(skill, opts) {
   } catch {}
 
   // Single-model fallback (no chain)
-  const single = opts?.model || process.env.WALLE_MODEL || 'claude-haiku-4-5-20251001';
+  const providerType = opts?.provider || opts?.providerType || getDefaultProviderType();
+  const single = resolveCompatibleModel(opts?.model || process.env.WALLE_MODEL || getDefaultModel(), providerType);
   return [single];
 }
 

package/template/wall-e/skills/skill-harness-registry.js

@@ -140,26 +140,25 @@ function listRegisteredSkillHarnesses() {
 
 function clearSkillHarnessRegistry() {
   _harnesses.clear();
+  _defaultHarnessRegistered = false;
 }
 
 // ── Bundled default harness: claude-tool-use ──
 // The existing runSkill body becomes the universal-fallback harness.
 // priority=0 ensures any registered specialized harness can preempt it.
-//
-// Lazy-required to avoid circular dep (skill-executor → registry → executor).
+// The executor passes its implementation in so this registry stays dependency-light.
 let _defaultHarnessRegistered = false;
-function ensureDefaultHarness() {
+function ensureDefaultHarness(runAttempt) {
   if (_defaultHarnessRegistered) return;
+  if (typeof runAttempt !== 'function') {
+    throw new Error('ensureDefaultHarness requires a runAttempt function');
+  }
   _defaultHarnessRegistered = true;
   registerSkillHarness({
     id: 'claude-tool-use',
     label: 'Claude tool-use loop (default)',
     supports: () => ({ supported: true, priority: 0 }),
-    runAttempt: async (skill, opts) => {
-      // Lazy require avoids circular dependency at module load
-      const { _runSkillInternal } = require('./skill-executor');
-      return await _runSkillInternal(skill, opts);
-    },
+    runAttempt,
   });
 }
 

package/template/wall-e/skills/skill-planner.js

@@ -9,6 +9,41 @@ const { resolveInternalSkill } = require('./internal-skill-registry');
 let telemetry;
 try { telemetry = require('../telemetry'); } catch { telemetry = { trackError() {}, track() {} }; }
 
+const DECISION_TELEMETRY_MIN_INTERVAL_MS = 15 * 60 * 1000;
+const _lastDecisionTelemetry = new Map();
+let _slackAlertMigrationDone = false;
+
+function isBrainReady() {
+  try {
+    brain.getDb();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function ensurePlannerBrainReady() {
+  if (isBrainReady()) return true;
+  try {
+    brain.initDb();
+    return true;
+  } catch (err) {
+    console.warn(`[skill-planner] Brain DB unavailable; skipping scheduled skills: ${err.message}`);
+    return false;
+  }
+}
+
+function shouldTrackDecisionTelemetry(skillName, decision) {
+  if (!decision) return false;
+  if (decision.decision === 'run' || decision.reason === 'just_auto_disabled') return true;
+  const key = `${skillName}:${decision.decision}:${decision.reason || ''}`;
+  const now = Date.now();
+  const last = _lastDecisionTelemetry.get(key) || 0;
+  if (now - last < DECISION_TELEMETRY_MIN_INTERVAL_MS) return false;
+  _lastDecisionTelemetry.set(key, now);
+  return true;
+}
+
 // ── Service alerts ─────────────────────────────────────────────────────────
 // Stored in kv_store as JSON array. Surfaces auth failures, version updates, etc.
 
@@ -41,6 +76,7 @@ function addServiceAlert(alert) {
   const existing = alerts.findIndex(a => a.service === alert.service && a.type === alert.type);
   if (existing >= 0) alerts.splice(existing, 1);
   alerts.push({
+    ...alert,
     id: `${alert.service}:${alert.type}:${Date.now()}`,
     service: alert.service,
     type: alert.type,
@@ -99,9 +135,16 @@ function migrateSlackFamilyAlerts() {
   }
 }
 
-// Run migration once at module load (wall-e reloads skill-planner on boot,
-// and this is cheap — a single KV read + possible write).
-migrateSlackFamilyAlerts();
+function runSlackAlertMigrationIfReady() {
+  if (_slackAlertMigrationDone || !isBrainReady()) return;
+  migrateSlackFamilyAlerts();
+  _slackAlertMigrationDone = true;
+}
+
+// Run opportunistically at module load only after the brain singleton is ready.
+// Some daemon paths import the planner before initDb(); touching KV there
+// generated noisy "Database not initialized" telemetry.
+runSlackAlertMigrationIfReady();
 
 // Note: `isSkillBackedOff`, `isSkillDue`, and `getBackoffMs` were removed
 // in favour of the pure-function `decideSkillDispatch` in
@@ -176,6 +219,9 @@ async function attemptAuthRecovery(skillName, err) {
  * Run all enabled skills that are due.
  */
 async function runDueSkills(opts = {}) {
+  if (!ensurePlannerBrainReady()) return { executed: 0, memoriesCreated: 0, skipped: 'db_unavailable' };
+  runSlackAlertMigrationIfReady();
+
   // Iterate ALL skills — including disabled ones — so decideSkillDispatch
   // emits per-skill decisions. The decision function itself filters
   // disabled/auto_disabled/backed_off; we only proceed to dispatch when
@@ -211,7 +257,9 @@ async function runDueSkills(opts = {}) {
       // Telemetry: structured event per decision per tick. Operator can
       // grep "skill_dispatch_decision skill=X reason=backed_off" without
       // reading source.
-      try { telemetry.track('skill_dispatch_decision', { skill: skill.name, decision: decision.decision, reason: decision.reason }); } catch {}
+      if (shouldTrackDecisionTelemetry(skill.name, decision)) {
+        try { telemetry.track('skill_dispatch_decision', { skill: skill.name, decision: decision.decision, reason: decision.reason }); } catch {}
+      }
       // Recovery logger: long-form structured trace for post-incident
       // debugging (Items E + A of error-recovery deep-dive).
       if (decision.reason === 'backed_off') {

package/template/wall-e/skills/slack-ingest.js

@@ -4,11 +4,13 @@ const path = require('path');
 const brain = require('../brain');
 
 const CLAUDE_DIR = path.join(process.env.HOME, '.claude');
-const OWNER_SLACK_ID = process.env.SLACK_OWNER_USER_ID;
-if (!OWNER_SLACK_ID) throw new Error('SLACK_OWNER_USER_ID env var required');
 const BATCH_SIZE = 100; // messages per API call
 const RATE_LIMIT_MS = 1200; // Slack rate limit: ~1 req/sec
 
+function getOwnerSlackId() {
+  return process.env.SLACK_OWNER_USER_ID || null;
+}
+
 /**
  * Get fresh Slack token from Claude Code's credentials.
  */
@@ -181,7 +183,7 @@ async function fetchConversationHistory(conv, token, oldestTs) {
     for (const msg of (data.messages || [])) {
       if (!msg.text && !msg.attachments) continue;
 
-      const isOwner = msg.user === OWNER_SLACK_ID;
+      const isOwner = msg.user === getOwnerSlackId();
       const text = msg.text || '';
       if (!text.trim()) continue;
 
@@ -230,6 +232,12 @@ async function fetchConversationHistory(conv, token, oldestTs) {
  * Returns { done, messagesIngested, conversationsProcessed }
  */
 async function runIngestBatch(opts = {}) {
+  if (!getOwnerSlackId()) {
+    const message = 'SLACK_OWNER_USER_ID env var required';
+    console.log(`[slack-ingest] ${message}`);
+    return { done: false, messagesIngested: 0, conversationsProcessed: 0, error: 'missing_env', message };
+  }
+
   // Pre-check: try to refresh token if it's about to expire
   try {
     const slackMcp = require('../tools/slack-mcp');

package/template/wall-e/sources/base.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const {
+  PRIVACY_CLASSES,
+  assertAdapterSchema,
+  assertIngestRecord,
+  assertSourceRef,
+} = require('./record-types');
+
+class SourceAdapterBase {
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.schema = assertAdapterSchema(this.describeSchema());
+  }
+
+  describeSchema() {
+    return this.constructor.schema || {
+      adapterId: this.constructor.adapterId || this.constructor.name || 'source-adapter',
+      version: '0.0.0',
+      supportsIncremental: false,
+      defaultPrivacyClass: PRIVACY_CLASSES.PII_POTENTIAL,
+      declaredTransformations: [],
+      fields: {},
+    };
+  }
+
+  async *ingest() {
+    throw new Error(`${this.schema.adapterId}.ingest() not implemented`);
+  }
+
+  async isCurrent() {
+    return false;
+  }
+
+  async sourceSummary() {
+    return null;
+  }
+
+  async close() {}
+
+  validateSource(source) {
+    return assertSourceRef({
+      privacyClass: this.schema.defaultPrivacyClass,
+      ...source,
+      adapterId: source?.adapterId || this.schema.adapterId,
+    });
+  }
+
+  validateRecord(record) {
+    return assertIngestRecord(record, this.schema);
+  }
+}
+
+class SourceIngestContext {
+  constructor({ isCurrent = null, diagnostics = null } = {}) {
+    this._isCurrent = isCurrent;
+    this.diagnostics = diagnostics || [];
+  }
+
+  async isCurrent(item) {
+    if (typeof this._isCurrent !== 'function') return false;
+    return Boolean(await this._isCurrent(item));
+  }
+
+  warn(message, fields = {}) {
+    this.diagnostics.push({ level: 'warn', message, ...fields });
+  }
+
+  error(message, fields = {}) {
+    this.diagnostics.push({ level: 'error', message, ...fields });
+  }
+}
+
+async function collectIngestRecords(adapter, source, { context = null, validate = true } = {}) {
+  const ctx = context || new SourceIngestContext();
+  const src = typeof adapter.validateSource === 'function' ? adapter.validateSource(source) : assertSourceRef(source);
+  const records = [];
+  for await (const record of adapter.ingest({ source: src, context: ctx })) {
+    records.push(validate && typeof adapter.validateRecord === 'function'
+      ? adapter.validateRecord(record)
+      : record);
+  }
+  return { records, diagnostics: ctx.diagnostics, source: src };
+}
+
+module.exports = {
+  SourceAdapterBase,
+  SourceIngestContext,
+  collectIngestRecords,
+};

package/template/wall-e/sources/builtin.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const registry = require('./registry');
+const ClaudeCodeJsonlAdapter = require('./claude-code-jsonl');
+const CodexJsonlAdapter = require('./codex-jsonl');
+const GeminiJsonlAdapter = require('./gemini-jsonl');
+const WalleJsonlAdapter = require('./walle-jsonl');
+
+const BUILTIN_SOURCE_ADAPTERS = Object.freeze([
+  ClaudeCodeJsonlAdapter,
+  CodexJsonlAdapter,
+  GeminiJsonlAdapter,
+  WalleJsonlAdapter,
+]);
+
+function ensureBuiltinSourceAdapters() {
+  for (const Adapter of BUILTIN_SOURCE_ADAPTERS) {
+    const instance = new Adapter();
+    if (!registry.has(instance.schema.adapterId)) {
+      registry.register(Adapter);
+    }
+  }
+  return registry;
+}
+
+module.exports = {
+  BUILTIN_SOURCE_ADAPTERS,
+  ClaudeCodeJsonlAdapter,
+  CodexJsonlAdapter,
+  GeminiJsonlAdapter,
+  WalleJsonlAdapter,
+  ensureBuiltinSourceAdapters,
+};

package/template/wall-e/sources/claude-code-jsonl.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const { SourceAdapterBase } = require('./base');
+const {
+  cleanUserText,
+  extractMessageText,
+  extractToolCalls,
+  fileVersion,
+  looksLikeToolResult,
+  readJsonlFile,
+  sourceIdFromFile,
+  toIso,
+} = require('./jsonl-utils');
+const { buildExchangeRecords, messageToRecords } = require('./coding-session-utils');
+
+class ClaudeCodeJsonlAdapter extends SourceAdapterBase {
+  static schema = {
+    adapterId: 'claude-code-jsonl',
+    version: '1.0.0',
+    supportsIncremental: true,
+    defaultPrivacyClass: 'pii_potential',
+    declaredTransformations: [
+      'newline_normalize',
+      'strip_tool_chrome',
+      'base64_payload_omit',
+      'tool_result_summarize',
+      'whitespace_trim',
+      'exchange_pair_chunk',
+    ],
+    fields: {
+      sourceId: { type: 'string', required: true },
+      sourceFile: { type: 'string', required: true },
+      cwd: { type: 'string', required: false },
+      gitBranch: { type: 'string', required: false },
+    },
+  };
+
+  validateSource(source) {
+    const normalized = super.validateSource(source);
+    if (!source.sourceId) normalized.sourceId = sourceIdFromFile('claude', normalized.sourceFile || normalized.uri);
+    return normalized;
+  }
+
+  async *ingest({ source, context }) {
+    const filePath = source.sourceFile || source.uri;
+    const version = fileVersion(filePath);
+    const { events, diagnostics } = readJsonlFile(filePath);
+    for (const diagnostic of diagnostics) context?.warn?.(diagnostic.message, diagnostic);
+
+    const messages = [];
+    for (const { line, event } of events) {
+      if (!event?.message || !['user', 'assistant'].includes(event.type)) continue;
+      const role = event.message.role || event.type;
+      if (!['user', 'assistant'].includes(role)) continue;
+      let content = extractMessageText(event.message);
+      if (role === 'user') content = cleanUserText(content);
+      if (!content || looksLikeToolResult(content)) continue;
+
+      const message = {
+        itemId: event.uuid || `line-${line}`,
+        role,
+        content,
+        timestamp: toIso(event.timestamp || event.message.timestamp),
+        cwd: event.cwd || source.cwd || '',
+        gitBranch: event.gitBranch || source.metadata?.gitBranch || '',
+        rawType: event.type,
+        harness: 'claude-code',
+        toolCalls: extractToolCalls(event.message),
+      };
+      messages.push(message);
+      for (const record of messageToRecords({ source, message, version })) yield record;
+    }
+
+    for (const record of buildExchangeRecords(source, messages)) yield record;
+  }
+}
+
+module.exports = ClaudeCodeJsonlAdapter;

package/template/wall-e/sources/codex-jsonl.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const { SourceAdapterBase } = require('./base');
+const {
+  cleanUserText,
+  extractMessageText,
+  fileVersion,
+  looksLikeToolResult,
+  parseToolInput,
+  readJsonlFile,
+  sourceIdFromFile,
+  summarizeToolInput,
+  toIso,
+} = require('./jsonl-utils');
+const { buildExchangeRecords, memoryRecord, messageToRecords, sourceItem } = require('./coding-session-utils');
+
+class CodexJsonlAdapter extends SourceAdapterBase {
+  static schema = {
+    adapterId: 'codex-jsonl',
+    version: '1.0.0',
+    supportsIncremental: true,
+    defaultPrivacyClass: 'pii_potential',
+    declaredTransformations: [
+      'newline_normalize',
+      'strip_tool_chrome',
+      'base64_payload_omit',
+      'tool_result_summarize',
+      'whitespace_trim',
+      'exchange_pair_chunk',
+    ],
+    fields: {
+      sourceId: { type: 'string', required: true },
+      sourceFile: { type: 'string', required: true },
+      cwd: { type: 'string', required: false },
+      gitBranch: { type: 'string', required: false },
+    },
+  };
+
+  validateSource(source) {
+    const normalized = super.validateSource(source);
+    if (!source.sourceId) normalized.sourceId = sourceIdFromFile('codex', normalized.sourceFile || normalized.uri);
+    return normalized;
+  }
+
+  async *ingest({ source, context }) {
+    const filePath = source.sourceFile || source.uri;
+    const version = fileVersion(filePath);
+    const { events, diagnostics } = readJsonlFile(filePath);
+    for (const diagnostic of diagnostics) context?.warn?.(diagnostic.message, diagnostic);
+
+    let cwd = source.cwd || '';
+    let gitBranch = source.metadata?.gitBranch || '';
+    const messages = [];
+    const seen = new Set();
+
+    for (const { line, event } of events) {
+      const payload = event.payload || {};
+      const item = payload.item || payload;
+      if (event.type === 'session_meta') {
+        cwd = payload.cwd || cwd;
+        gitBranch = payload.gitBranch || gitBranch;
+        continue;
+      }
+      if (event.type === 'turn_context') {
+        cwd = payload.cwd || cwd;
+        gitBranch = payload.gitBranch || gitBranch;
+        continue;
+      }
+
+      if (event.type !== 'response_item' && event.type !== 'event_msg') continue;
+
+      const role = item.role || payload.role || event.role || null;
+      if (role === 'user' || role === 'assistant') {
+        const content = role === 'user'
+          ? cleanUserText(extractMessageText(item))
+          : extractMessageText(item);
+        if (!content || looksLikeToolResult(content)) continue;
+        const itemId = item.id || payload.id || `${event.type}-${line}`;
+        const key = `${role}:${itemId}:${content}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const message = {
+          itemId,
+          role,
+          content,
+          timestamp: toIso(event.timestamp || payload.timestamp || item.timestamp),
+          cwd,
+          gitBranch,
+          rawType: event.type,
+          harness: 'codex',
+          toolCalls: [],
+        };
+        messages.push(message);
+        for (const record of messageToRecords({ source, message, version })) yield record;
+        continue;
+      }
+
+      if (payload.type === 'function_call' || item.type === 'function_call') {
+        const name = item.name || payload.name || 'tool';
+        const input = parseToolInput(item.arguments ?? payload.arguments ?? item.input ?? payload.input);
+        const itemId = item.id || payload.id || `tool-${line}`;
+        yield sourceItem({
+          source,
+          itemId,
+          version,
+          timestamp: event.timestamp || payload.timestamp,
+          metadata: { role: 'tool', cwd, gitBranch, name, input },
+        });
+        yield memoryRecord({
+          source,
+          itemId: `${itemId}:tool`,
+          memoryType: 'coding_session_tool_call',
+          role: 'tool',
+          contentRaw: `[Tool: ${name}] ${summarizeToolInput(name, input)}`,
+          timestamp: event.timestamp || payload.timestamp,
+          metadata: { cwd, gitBranch, name, input },
+        });
+      }
+    }
+
+    for (const record of buildExchangeRecords(source, messages)) yield record;
+  }
+}
+
+module.exports = CodexJsonlAdapter;