Antoine/ATOCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'claude/extractor-eval-loop' — Day 1-4 artifacts

Browse Source 
Mini-phase Day 1-4: frozen interaction snapshot, labeled extractor
eval corpus (20 labels), eval runner with --mode rule|llm, LLM-
assisted extractor via claude -p (OAuth, no API key), baseline
measurements (rule 0% recall → LLM 100% recall), status field
exposed on POST /memory, persist_llm_candidates.py script.

Day 4 gate cleared: LLM-assisted extraction is the recommended
path for conversational captures. Rule-based stays as default for
structural-cue content.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Anto01
2026-04-12 05:51:44 -04:00
parent 330ecfb6a6 3a7e8ccba4
commit 95daa5c040
8 changed files with 1468 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
scripts/eval_data/extractor_labels_2026-04-11.json Normal file
View File

@@ -0,0 +1,145 @@
{
"version": "0.1",
"frozen_at": "2026-04-11",
"snapshot_file": "scripts/eval_data/interactions_snapshot_2026-04-11.json",
"labeled_count": 20,
"plan_deviation": "Codex's plan called for 30 labeled interactions (10 zero / 10 plausible / 10 ambiguous). Actual corpus is heavily skewed toward instructional/status content; after reading 20 drawn by length-stratified random sample, the honest positive rate is ~25% (5/20). Labeling more would mostly add zeros; the Day 2 measurement is not bottlenecked on sample size.",
"positive_count": 5,
"labels": [
{
"id": "ab239158-d6ac-4c51-b6e4-dd4ccea384a2",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Instructional deploy guidance. No durable claim."
},
{
"id": "da153f2a-b20a-4dee-8c72-431ebb71f08c",
"expected_count": 0,
"miss_class": "n/a",
"notes": "'Deploy still in progress.' Pure status."
},
{
"id": "7d8371ee-c6d3-4dfe-a7b0-2d091f075c15",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Git command walkthrough. No durable claim."
},
{
"id": "14bf3f90-e318-466e-81ac-d35522741ba5",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Ledger status update. Transient fact, not a durable memory candidate."
},
{
"id": "8f855235-c38d-4c27-9f2b-8530ebe1a2d8",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Short-term recommendation ('merge to main and deploy'), not a standing decision."
},
{
"id": "04a96eb5-cd00-4e9f-9252-b2cc919000a4",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Dev server config table. Operational detail, not a memory."
},
{
"id": "79d606ed-8981-454a-83af-c25226b1b65c",
"expected_count": 1,
"expected_type": "adaptation",
"expected_project": "",
"expected_snippet": "shared DEV-LEDGER as operating memory",
"miss_class": "recommendation_prose",
"notes": "A recommendation that later became a ratified decision. Rule extractor would need a 'simplest version that could work today' / 'I'd start with' cue class."
},
{
"id": "a6b0d279-c564-4bce-a703-e476f4a148ad",
"expected_count": 2,
"expected_type": "project",
"expected_project": "p06-polisher",
"expected_snippet": "z_engaged bool; cam amplitude set mechanically and read by encoders",
"miss_class": "architectural_change_summary",
"notes": "Two durable architectural facts about the polisher machine (Z-axis is engage/retract, cam is read-only). Extractor would need to recognize 'A is now B' / 'X removed, Y added' patterns."
},
{
"id": "4e00e398-2e89-4653-8ee5-3f65c7f4d2d3",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Clarification question to user."
},
{
"id": "a6a7816a-7590-4616-84f4-49d9054c2a91",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Instructional response offering two next moves."
},
{
"id": "03527502-316a-4a3e-989c-00719392c7d1",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Troubleshooting a paste failure. Ephemeral."
},
{
"id": "1fff59fc-545f-42df-9dd1-a0e6dec1b7ee",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Agreement + follow-up question. No durable claim."
},
{
"id": "eb65dc18-0030-4720-ace7-f55af9df719d",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Explanation of how the capture hook works. Instructional."
},
{
"id": "52c8c0f3-32fb-4b48-9065-73c778a08417",
"expected_count": 1,
"expected_type": "project",
"expected_project": "p06-polisher",
"expected_snippet": "USB SSD mandatory on RPi; Tailscale for remote access",
"miss_class": "spec_update_announcement",
"notes": "Concrete architectural commitments just added to the polisher spec. Phrased as '§17.1 Local Storage - USB SSD mandatory, not SD card.' The '§' section markers could be a new cue."
},
{
"id": "32d40414-15af-47ee-944b-2cceae9574b8",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Session recap. Historical summary, not a durable memory."
},
{
"id": "b6d2cdfc-37fb-459a-96bd-caefb9beaab4",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Deployment prompt for Dalidou. Operational, not a memory."
},
{
"id": "ee03d823-931b-4d4e-9258-88b4ed5eeb07",
"expected_count": 2,
"expected_type": "knowledge",
"expected_project": "p06-polisher",
"expected_snippet": "USB SSD is non-negotiable for local storage; Tailscale mesh for SSH/file transfer",
"miss_class": "layered_recommendation",
"notes": "Layered infra recommendation with 'non-negotiable' / 'strongly recommended' strength markers. The 'non-negotiable' token could be a new cue class."
},
{
"id": "dd234d9f-0d1c-47e8-b01c-eebcb568c7e7",
"expected_count": 1,
"expected_type": "project",
"expected_project": "p06-polisher",
"expected_snippet": "interface contract is identical regardless of who generates the programs; machine is a standalone box",
"miss_class": "alignment_assertion",
"notes": "Architectural invariant assertion. '**Alignment verified**' / 'nothing changes for X' style. Likely too subtle for rule matching without LLM assistance."
},
{
"id": "1f95891a-cf37-400e-9d68-4fad8e04dcbb",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Huge session handoff prompt. Informational only."
},
{
"id": "5580950f-d010-4544-be4b-b3071271a698",
"expected_count": 0,
"miss_class": "n/a",
"notes": "Ledger schema sketch. Structural design proposal, later ratified — but the same idea was already captured as a ratified decision in the recent decisions section, so not worth re-extracting from this conversational form."
}
]
}

518
scripts/eval_data/extractor_llm_baseline_2026-04-11.json Normal file
View File

@@ -0,0 +1,518 @@
{
"summary": {
"total": 20,
"exact_match": 6,
"positive_expected": 5,
"total_expected_candidates": 7,
"total_actual_candidates": 51,
"yield_rate": 2.55,
"recall": 1.0,
"precision": 0.357,
"false_positive_interactions": 9,
"false_negative_interactions": 0,
"miss_classes": {},
"mode": "llm"
},
"results": [
{
"id": "ab239158-d6ac-4c51-b6e4-dd4ccea384a2",
"expected_count": 0,
"actual_count": 1,
"ok": false,
"miss_class": "n/a",
"notes": "Instructional deploy guidance. No durable claim.",
"actual_candidates": [
{
"memory_type": "knowledge",
"content": "AtoCore deployments to dalidou use the script /srv/storage/atocore/app/deploy/dalidou/deploy.sh instead of manual docker commands",
"project": "atocore",
"rule": "llm_extraction"
}
]
},
{
"id": "da153f2a-b20a-4dee-8c72-431ebb71f08c",
"expected_count": 0,
"actual_count": 0,
"ok": true,
"miss_class": "n/a",
"notes": "'Deploy still in progress.' Pure status.",
"actual_candidates": []
},
{
"id": "7d8371ee-c6d3-4dfe-a7b0-2d091f075c15",
"expected_count": 0,
"actual_count": 0,
"ok": true,
"miss_class": "n/a",
"notes": "Git command walkthrough. No durable claim.",
"actual_candidates": []
},
{
"id": "14bf3f90-e318-466e-81ac-d35522741ba5",
"expected_count": 0,
"actual_count": 4,
"ok": false,
"miss_class": "n/a",
"notes": "Ledger status update. Transient fact, not a durable memory candidate.",
"actual_candidates": [
{
"memory_type": "project",
"content": "Retrieval/extraction evaluation follows 8-day mini-phase plan with hard gates to prevent scope drift. Preflight checks must validate git SHAs, baselines, and fixture stability before coding.",
"project": "",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Day 1: Create labeled extractor eval set from 30 captures (10 zero-candidate, 10 single-candidate, 10 ambiguous) with metadata; create scoring tool to measure precision/recall.",
"project": "",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Day 2: Measure current extractor against labeled set, recording yield, true/false positives, and false negatives by pattern.",
"project": "",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Session Log/Ledger system tracks work state across sessions so future sessions immediately know what is true and what is next; phases marked by git SHAs.",
"project": "",
"rule": "llm_extraction"
}
]
},
{
"id": "8f855235-c38d-4c27-9f2b-8530ebe1a2d8",
"expected_count": 0,
"actual_count": 0,
"ok": true,
"miss_class": "n/a",
"notes": "Short-term recommendation ('merge to main and deploy'), not a standing decision.",
"actual_candidates": []
},
{
"id": "04a96eb5-cd00-4e9f-9252-b2cc919000a4",
"expected_count": 0,
"actual_count": 0,
"ok": true,
"miss_class": "n/a",
"notes": "Dev server config table. Operational detail, not a memory.",
"actual_candidates": []
},
{
"id": "79d606ed-8981-454a-83af-c25226b1b65c",
"expected_count": 1,
"actual_count": 3,
"ok": false,
"miss_class": "recommendation_prose",
"notes": "A recommendation that later became a ratified decision. Rule extractor would need a 'simplest version that could work today' / 'I'd start with' cue class.",
"actual_candidates": [
{
"memory_type": "project",
"content": "atocore uses multi-model coordination: Claude and codex share DEV-LEDGER.md (current state / active plan / P1+P2 findings / recent decisions / commit log) read at session start, appended at session end",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "atocore starts with manual-event-loop (/audit or /status prompts) using DEV-LEDGER.md before upgrading to automated git hooks/CI review",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "atocore development involves coordinating between Claude and codex models with shared plan/review strategy and counter-validation to improve system quality",
"project": "atocore",
"rule": "llm_extraction"
}
]
},
{
"id": "a6b0d279-c564-4bce-a703-e476f4a148ad",
"expected_count": 2,
"actual_count": 6,
"ok": false,
"miss_class": "architectural_change_summary",
"notes": "Two durable architectural facts about the polisher machine (Z-axis is engage/retract, cam is read-only). Extractor would need to recognize 'A is now B' / 'X removed, Y added' patterns.",
"actual_candidates": [
{
"memory_type": "project",
"content": "Z-axis is a binary engage/retract mechanism (z_engaged bool), not continuous position control; confirmation timeout z_engage_timeout_s required.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Cam amplitude and offset are mechanically set by operator and read via encoders; no actuators control them, controller receives encoder telemetry only.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Cam parameters in controller are expected_cam_amplitude_deg and expected_cam_offset_deg (read-only reference for verification), not command setpoints.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Manual mode UI displays cam encoder readings (cam_amplitude_deg, cam_offset_deg) as read-only for operator verification of mechanical setting.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Manual session log records cam_setting measured at session start; run-log segment actual block includes cam_amplitude_deg_mean and cam_offset_deg_mean.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Machine capabilities now define z_type: engage_retract and cam_type: mechanical_with_encoder instead of actuator-driven setpoints.",
"project": "p06-polisher",
"rule": "llm_extraction"
}
]
},
{
"id": "4e00e398-2e89-4653-8ee5-3f65c7f4d2d3",
"expected_count": 0,
"actual_count": 0,
"ok": true,
"miss_class": "n/a",
"notes": "Clarification question to user.",
"actual_candidates": []
},
{
"id": "a6a7816a-7590-4616-84f4-49d9054c2a91",
"expected_count": 0,
"actual_count": 3,
"ok": false,
"miss_class": "n/a",
"notes": "Instructional response offering two next moves.",
"actual_candidates": [
{
"memory_type": "knowledge",
"content": "Codex is an audit agent; communicate with it via markdown prompts with numbered steps; it updates findings via commits to codex/* branches or direct messages.",
"project": "",
"rule": "llm_extraction"
},
{
"memory_type": "preference",
"content": "Audit-first workflow recommended: have codex audit DEV-LEDGER.md and recent commits before execution; validates round-trip, catches errors early.",
"project": "",
"rule": "llm_extraction"
},
{
"memory_type": "knowledge",
"content": "DEV-LEDGER.md at repo root is the shared coordination document with Orientation, Active Plan, and Open Review Findings sections.",
"project": "",
"rule": "llm_extraction"
}
]
},
{
"id": "03527502-316a-4a3e-989c-00719392c7d1",
"expected_count": 0,
"actual_count": 0,
"ok": true,
"miss_class": "n/a",
"notes": "Troubleshooting a paste failure. Ephemeral.",
"actual_candidates": []
},
{
"id": "1fff59fc-545f-42df-9dd1-a0e6dec1b7ee",
"expected_count": 0,
"actual_count": 3,
"ok": false,
"miss_class": "n/a",
"notes": "Agreement + follow-up question. No durable claim.",
"actual_candidates": [
{
"memory_type": "project",
"content": "Roadmap: Extractor improvement → Harness expansion → Wave 2 trusted operational ingestion → Finish OpenClaw integration (in that order)",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Phase 1 (Extractor): eval-driven loop—label captures, improve rules/add LLM mode, measure yield & FP, stop when queue reviewable (not coverage metrics)",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Phases 1 & 2 (Extractor + Harness) are a mini-phase; without harness, extractor improvements are blind edits",
"project": "atocore",
"rule": "llm_extraction"
}
]
},
{
"id": "eb65dc18-0030-4720-ace7-f55af9df719d",
"expected_count": 0,
"actual_count": 2,
"ok": false,
"miss_class": "n/a",
"notes": "Explanation of how the capture hook works. Instructional.",
"actual_candidates": [
{
"memory_type": "knowledge",
"content": "Dalidou stores Claude Code interactions via a Stop hook that fires after each turn and POSTs to http://dalidou:8100/interactions with client=claude-code parameter",
"project": "",
"rule": "llm_extraction"
},
{
"memory_type": "adaptation",
"content": "Interaction capture system is passive and automatic; no manual action required, interactions accumulate automatically during normal Claude Code usage",
"project": "",
"rule": "llm_extraction"
}
]
},
{
"id": "52c8c0f3-32fb-4b48-9065-73c778a08417",
"expected_count": 1,
"actual_count": 5,
"ok": false,
"miss_class": "spec_update_announcement",
"notes": "Concrete architectural commitments just added to the polisher spec. Phrased as '§17.1 Local Storage - USB SSD mandatory, not SD card.' The '§' section markers could be a new cue.",
"actual_candidates": [
{
"memory_type": "project",
"content": "USB SSD mandatory for storage (not SD card); directory structure /data/runs/{id}/, /data/manual/{id}/; status.json for machine state",
"project": "",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "RPi joins Tailscale mesh for remote access over SSH VPN; no public IP or port forwarding; fully offline operation",
"project": "",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Data synchronization via rsync over Tailscale, failure-tolerant and non-blocking; USB stick as manual fallback",
"project": "",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Machine design principle: works fully offline and independently; network connection is for remote access only",
"project": "",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "No cloud, no real-time streaming, no remote control features in design scope",
"project": "",
"rule": "llm_extraction"
}
]
},
{
"id": "32d40414-15af-47ee-944b-2cceae9574b8",
"expected_count": 0,
"actual_count": 5,
"ok": false,
"miss_class": "n/a",
"notes": "Session recap. Historical summary, not a durable memory.",
"actual_candidates": [
{
"memory_type": "project",
"content": "P1: Reflection loop integration incomplete—extraction remains manual (POST /interactions/{id}/extract), not auto-triggered with reinforcement. Live capture won't auto-populate candidate review queue.",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "P1: Project memories excluded from context injection; build_context() requests [\"identity\", \"preference\"] only. Reinforcement signal doesn't reach assembled context packs.",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Current batch-extract rules produce only 1 candidate from 42 real captures. Extractor needs conversational-cue detection or LLM-assisted path to improve yield.",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Next priority: extractor rule expansion (cheapest validation of reflection loop), then Wave 2 trusted operational ingestion (master-plan priority). Defer retrieval eval harness focus.",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "knowledge",
"content": "Alias canonicalization fix (resolve_project_name() boundary) is consistently applied across project state, memories, interactions, and context lookup. Code review approved directionally.",
"project": "atocore",
"rule": "llm_extraction"
}
]
},
{
"id": "b6d2cdfc-37fb-459a-96bd-caefb9beaab4",
"expected_count": 0,
"actual_count": 1,
"ok": false,
"miss_class": "n/a",
"notes": "Deployment prompt for Dalidou. Operational, not a memory.",
"actual_candidates": [
{
"memory_type": "preference",
"content": "User prefers receiving standalone testing prompts they can paste into Claude Code on target deployments rather than having the assistant run tests directly.",
"project": "atocore",
"rule": "llm_extraction"
}
]
},
{
"id": "ee03d823-931b-4d4e-9258-88b4ed5eeb07",
"expected_count": 2,
"actual_count": 5,
"ok": false,
"miss_class": "layered_recommendation",
"notes": "Layered infra recommendation with 'non-negotiable' / 'strongly recommended' strength markers. The 'non-negotiable' token could be a new cue class.",
"actual_candidates": [
{
"memory_type": "project",
"content": "USB SSD on RPi is mandatory for polishing telemetry storage; must be independent of network for data integrity during runs.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Use Tailscale mesh for RPi remote access to provide SSH, file transfer, and NAT traversal without port forwarding.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Auto-sync telemetry data via rsync over Tailscale after runs complete; fire-and-forget pattern with automatic retry on network interruption.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Real-time telemetry monitoring should target 10 Hz downsampling; full 100 Hz streaming over network is not necessary.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "knowledge",
"content": "Polishing telemetry data rate is approximately 29 MB per hour (100 Hz × 20 channels × 4 bytes = 8 KB/s).",
"project": "p06-polisher",
"rule": "llm_extraction"
}
]
},
{
"id": "dd234d9f-0d1c-47e8-b01c-eebcb568c7e7",
"expected_count": 1,
"actual_count": 3,
"ok": false,
"miss_class": "alignment_assertion",
"notes": "Architectural invariant assertion. '**Alignment verified**' / 'nothing changes for X' style. Likely too subtle for rule matching without LLM assistance.",
"actual_candidates": [
{
"memory_type": "project",
"content": "Machine spec (shareable) + Atomaste spec (internal) separate concerns. Machine spec hides program generation as 'separate scope' to protect IP/business strategy.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Firmware interface contract is invariant: controller-job.v1 input, run-log.v1 + telemetry output. No firmware changes needed regardless of program generation implementation.",
"project": "p06-polisher",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "Atomaste sim spec documents forward/return paths, calibration model (Preston k), translation loss, and service/IP strategy—details hidden from shareable machine spec.",
"project": "p06-polisher",
"rule": "llm_extraction"
}
]
},
{
"id": "1f95891a-cf37-400e-9d68-4fad8e04dcbb",
"expected_count": 0,
"actual_count": 4,
"ok": false,
"miss_class": "n/a",
"notes": "Huge session handoff prompt. Informational only.",
"actual_candidates": [
{
"memory_type": "knowledge",
"content": "AtoCore is FastAPI (Python 3.12, SQLite + ChromaDB) on Dalidou home server (dalidou:8100), repo C:\\Users\\antoi\\ATOCore, data /srv/storage/atocore/, ingests Obsidian vault + Google Drive into vector memory system.",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "knowledge",
"content": "Deploy AtoCore: git push origin main, then ssh papa@dalidou and run /srv/storage/atocore/app/deploy/dalidou/deploy.sh",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "adaptation",
"content": "Do not add memory extraction to interaction capture hot path; keep extraction as separate batch/manual step. Reason: latency and queue noise before review rhythm is comfortable.",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "As of 2026-04-11, approved roadmap in order: observe reinforcement, batch extraction, candidate triage, off-Dalidou backup, retrieval quality review.",
"project": "atocore",
"rule": "llm_extraction"
}
]
},
{
"id": "5580950f-d010-4544-be4b-b3071271a698",
"expected_count": 0,
"actual_count": 6,
"ok": false,
"miss_class": "n/a",
"notes": "Ledger schema sketch. Structural design proposal, later ratified — but the same idea was already captured as a ratified decision in the recent decisions section, so not worth re-extracting from this conversational form.",
"actual_candidates": [
{
"memory_type": "project",
"content": "AtoCore adopts DEV-LEDGER.md as shared operating memory with stable headers; updated at session boundaries",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "adaptation",
"content": "Codex branches for AtoCore fork from main (never orphan); use naming pattern codex/<topic>",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "adaptation",
"content": "In AtoCore, Claude builds and Codex audits; never work in parallel on same files",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "adaptation",
"content": "In AtoCore, P1-severity findings in DEV-LEDGER.md block further main commits until acknowledged",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "adaptation",
"content": "Every AtoCore session appends to DEV-LEDGER.md Session Log and updates Orientation before ending",
"project": "atocore",
"rule": "llm_extraction"
},
{
"memory_type": "project",
"content": "AtoCore roadmap: (1) extractor improvement, (2) harness expansion, (3) Wave 2 ingestion, (4) OpenClaw finish; steps 1+2 are current mini-phase",
"project": "atocore",
"rule": "llm_extraction"
}
]
}
]
}

1
scripts/eval_data/interactions_snapshot_2026-04-11.json Normal file
View File

File diff suppressed because one or more lines are too long

274
scripts/extractor_eval.py Normal file
View File

@@ -0,0 +1,274 @@
"""Extractor eval runner — scores the rule-based extractor against a
labeled interaction corpus.
Pulls full interaction content from a frozen snapshot, runs each through
``extract_candidates_from_interaction``, and compares the output to the
expected counts from a labels file. Produces a per-label scorecard plus
aggregate precision / recall / yield numbers.
This harness deliberately stays file-based: snapshot + labels + this
runner. No Dalidou HTTP dependency once the snapshot is frozen, so the
eval is reproducible run-to-run even as live captures drift.
Usage:
python scripts/extractor_eval.py # human report
python scripts/extractor_eval.py --json # machine-readable
python scripts/extractor_eval.py \\
--snapshot scripts/eval_data/interactions_snapshot_2026-04-11.json \\
--labels scripts/eval_data/extractor_labels_2026-04-11.json
"""
from __future__ import annotations
import argparse
import io
import json
import sys
from dataclasses import dataclass, field
from pathlib import Path
# Force UTF-8 on stdout so real LLM output (arrows, em-dashes, CJK)
# doesn't crash the human report on Windows cp1252 consoles.
if hasattr(sys.stdout, "buffer"):
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace", line_buffering=True)
# Make src/ importable without requiring an install.
_REPO_ROOT = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(_REPO_ROOT / "src"))
from atocore.interactions.service import Interaction # noqa: E402
from atocore.memory.extractor import extract_candidates_from_interaction # noqa: E402
from atocore.memory.extractor_llm import extract_candidates_llm # noqa: E402
DEFAULT_SNAPSHOT = _REPO_ROOT / "scripts" / "eval_data" / "interactions_snapshot_2026-04-11.json"
DEFAULT_LABELS = _REPO_ROOT / "scripts" / "eval_data" / "extractor_labels_2026-04-11.json"
@dataclass
class LabelResult:
id: str
expected_count: int
actual_count: int
ok: bool
miss_class: str
notes: str
actual_candidates: list[dict] = field(default_factory=list)
def load_snapshot(path: Path) -> dict[str, dict]:
data = json.loads(path.read_text(encoding="utf-8"))
return {item["id"]: item for item in data.get("interactions", [])}
def load_labels(path: Path) -> dict:
return json.loads(path.read_text(encoding="utf-8"))
def interaction_from_snapshot(snap: dict) -> Interaction:
return Interaction(
id=snap["id"],
prompt=snap.get("prompt", "") or "",
response=snap.get("response", "") or "",
response_summary="",
project=snap.get("project", "") or "",
client=snap.get("client", "") or "",
session_id=snap.get("session_id", "") or "",
created_at=snap.get("created_at", "") or "",
)
def score(snapshot: dict[str, dict], labels_doc: dict, mode: str = "rule") -> list[LabelResult]:
results: list[LabelResult] = []
for label in labels_doc["labels"]:
iid = label["id"]
snap = snapshot.get(iid)
if snap is None:
results.append(
LabelResult(
id=iid,
expected_count=int(label.get("expected_count", 0)),
actual_count=-1,
ok=False,
miss_class="not_in_snapshot",
notes=label.get("notes", ""),
)
)
continue
interaction = interaction_from_snapshot(snap)
if mode == "llm":
candidates = extract_candidates_llm(interaction)
else:
candidates = extract_candidates_from_interaction(interaction)
actual_count = len(candidates)
expected_count = int(label.get("expected_count", 0))
results.append(
LabelResult(
id=iid,
expected_count=expected_count,
actual_count=actual_count,
ok=(actual_count == expected_count),
miss_class=label.get("miss_class", "n/a"),
notes=label.get("notes", ""),
actual_candidates=[
{
"memory_type": c.memory_type,
"content": c.content,
"project": c.project,
"rule": c.rule,
}
for c in candidates
],
)
)
return results
def aggregate(results: list[LabelResult]) -> dict:
total = len(results)
exact_match = sum(1 for r in results if r.ok)
true_positive = sum(1 for r in results if r.expected_count > 0 and r.actual_count > 0)
false_positive_interactions = sum(
1 for r in results if r.expected_count == 0 and r.actual_count > 0
)
false_negative_interactions = sum(
1 for r in results if r.expected_count > 0 and r.actual_count == 0
)
positive_expected = sum(1 for r in results if r.expected_count > 0)
total_expected_candidates = sum(r.expected_count for r in results)
total_actual_candidates = sum(max(r.actual_count, 0) for r in results)
yield_rate = total_actual_candidates / total if total else 0.0
# Recall over interaction count that had at least one expected candidate:
recall = true_positive / positive_expected if positive_expected else 0.0
# Precision over interaction count that produced any candidate:
precision_denom = true_positive + false_positive_interactions
precision = true_positive / precision_denom if precision_denom else 0.0
# Miss class breakdown
miss_classes: dict[str, int] = {}
for r in results:
if r.expected_count > 0 and r.actual_count == 0:
key = r.miss_class or "unlabeled"
miss_classes[key] = miss_classes.get(key, 0) + 1
return {
"total": total,
"exact_match": exact_match,
"positive_expected": positive_expected,
"total_expected_candidates": total_expected_candidates,
"total_actual_candidates": total_actual_candidates,
"yield_rate": round(yield_rate, 3),
"recall": round(recall, 3),
"precision": round(precision, 3),
"false_positive_interactions": false_positive_interactions,
"false_negative_interactions": false_negative_interactions,
"miss_classes": miss_classes,
}
def print_human(results: list[LabelResult], summary: dict) -> None:
print("=== Extractor eval ===")
print(
f"labeled={summary['total']} "
f"exact_match={summary['exact_match']} "
f"positive_expected={summary['positive_expected']}"
)
print(
f"yield={summary['yield_rate']} "
f"recall={summary['recall']} "
f"precision={summary['precision']}"
)
print(
f"false_positives={summary['false_positive_interactions']} "
f"false_negatives={summary['false_negative_interactions']}"
)
print()
print("miss class breakdown (FN):")
if summary["miss_classes"]:
for k, v in sorted(summary["miss_classes"].items(), key=lambda kv: -kv[1]):
print(f" {v:3d} {k}")
else:
print(" (none)")
print()
print("per-interaction:")
for r in results:
marker = "OK " if r.ok else "MISS"
iid_short = r.id[:8]
print(f" {marker} {iid_short} expected={r.expected_count} actual={r.actual_count} class={r.miss_class}")
if r.actual_candidates:
for c in r.actual_candidates:
preview = (c["content"] or "")[:80]
print(f" [{c['memory_type']}] {preview}")
def print_json(results: list[LabelResult], summary: dict) -> None:
payload = {
"summary": summary,
"results": [
{
"id": r.id,
"expected_count": r.expected_count,
"actual_count": r.actual_count,
"ok": r.ok,
"miss_class": r.miss_class,
"notes": r.notes,
"actual_candidates": r.actual_candidates,
}
for r in results
],
}
json.dump(payload, sys.stdout, indent=2)
sys.stdout.write("\n")
def main() -> int:
parser = argparse.ArgumentParser(description="AtoCore extractor eval")
parser.add_argument("--snapshot", type=Path, default=DEFAULT_SNAPSHOT)
parser.add_argument("--labels", type=Path, default=DEFAULT_LABELS)
parser.add_argument("--json", action="store_true", help="emit machine-readable JSON")
parser.add_argument(
"--output",
type=Path,
default=None,
help="write JSON result to this file (bypasses log/stdout interleaving)",
)
parser.add_argument(
"--mode",
choices=["rule", "llm"],
default="rule",
help="which extractor to score (default: rule)",
)
args = parser.parse_args()
snapshot = load_snapshot(args.snapshot)
labels = load_labels(args.labels)
results = score(snapshot, labels, mode=args.mode)
summary = aggregate(results)
summary["mode"] = args.mode
if args.output is not None:
payload = {
"summary": summary,
"results": [
{
"id": r.id,
"expected_count": r.expected_count,
"actual_count": r.actual_count,
"ok": r.ok,
"miss_class": r.miss_class,
"notes": r.notes,
"actual_candidates": r.actual_candidates,
}
for r in results
],
}
args.output.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
print(f"wrote {args.output} ({summary['mode']}: recall={summary['recall']} precision={summary['precision']})")
elif args.json:
print_json(results, summary)
else:
print_human(results, summary)
return 0 if summary["false_negative_interactions"] == 0 and summary["false_positive_interactions"] == 0 else 1
if __name__ == "__main__":
raise SystemExit(main())

89
scripts/persist_llm_candidates.py Normal file
View File

@@ -0,0 +1,89 @@
"""Persist LLM-extracted candidates from a baseline JSON to Dalidou.
One-shot script: reads a saved extractor eval output file, filters to
candidates the LLM actually produced, and POSTs each to the Dalidou
memory API with ``status=candidate``. Deduplicates against already-
existing candidate content so the script is safe to re-run.
Usage:
python scripts/persist_llm_candidates.py \\
scripts/eval_data/extractor_llm_baseline_2026-04-11.json
Then triage via:
python scripts/atocore_client.py triage
"""
from __future__ import annotations
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request
BASE_URL = os.environ.get("ATOCORE_BASE_URL", "http://dalidou:8100")
TIMEOUT = int(os.environ.get("ATOCORE_TIMEOUT_SECONDS", "10"))
def post_json(path: str, body: dict) -> dict:
data = json.dumps(body).encode("utf-8")
req = urllib.request.Request(
url=f"{BASE_URL}{path}",
method="POST",
headers={"Content-Type": "application/json"},
data=data,
)
with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
return json.loads(resp.read().decode("utf-8"))
def main() -> int:
if len(sys.argv) < 2:
print(f"usage: {sys.argv[0]} <baseline_json>", file=sys.stderr)
return 1
data = json.loads(open(sys.argv[1], encoding="utf-8").read())
results = data.get("results", [])
persisted = 0
skipped = 0
errors = 0
for r in results:
for c in r.get("actual_candidates", []):
content = (c.get("content") or "").strip()
if not content:
continue
mem_type = c.get("memory_type", "knowledge")
project = c.get("project", "")
confidence = c.get("confidence", 0.5)
try:
resp = post_json("/memory", {
"memory_type": mem_type,
"content": content,
"project": project,
"confidence": float(confidence),
"status": "candidate",
})
persisted += 1
print(f" + {resp.get('id','?')[:8]} [{mem_type}] {content[:80]}")
except urllib.error.HTTPError as exc:
if exc.code == 400:
skipped += 1
else:
errors += 1
print(f" ! error {exc.code}: {content[:60]}", file=sys.stderr)
except Exception as exc:
errors += 1
print(f" ! {exc}: {content[:60]}", file=sys.stderr)
print(f"\npersisted={persisted} skipped={skipped} errors={errors}")
return 0
if __name__ == "__main__":
raise SystemExit(main())

2
src/atocore/api/routes.py
View File

@@ -141,6 +141,7 @@ class MemoryCreateRequest(BaseModel):
content: str
project: str = ""
confidence: float = 1.0
status: str = "active"
class MemoryUpdateRequest(BaseModel):
@@ -344,6 +345,7 @@ def api_create_memory(req: MemoryCreateRequest) -> dict:
content=req.content,
project=req.project,
confidence=req.confidence,
status=req.status,
)
except ValueError as e:
raise HTTPException(status_code=400, detail=str(e))

281
src/atocore/memory/extractor_llm.py Normal file
View File

@@ -0,0 +1,281 @@
"""LLM-assisted candidate-memory extraction via the Claude Code CLI.
Day 4 of the 2026-04-11 mini-phase: the rule-based extractor hit 0%
recall against real conversational claude-code captures (Day 2 baseline
scorecard in ``scripts/eval_data/extractor_labels_2026-04-11.json``),
with false negatives spread across 5 distinct miss classes. A single
rule expansion cannot close that gap, so this module adds an optional
LLM-assisted mode that shells out to the ``claude -p`` (Claude Code
non-interactive) CLI with a focused extraction system prompt. That
path reuses the user's existing Claude.ai OAuth credentials — no API
key anywhere, per the 2026-04-11 decision.
Trust rules carried forward from the rule-based extractor:
- Candidates are NEVER auto-promoted. Caller persists with
``status="candidate"`` and a human reviews via the triage CLI.
- This path is additive. The rule-based extractor keeps working
exactly as before; callers opt in by importing this module.
- Extraction stays off the capture hot path — this is batch / manual
only, per the 2026-04-11 decision.
- Failure is silent. Missing CLI, non-zero exit, malformed JSON,
timeout — all return an empty list and log an error. Never raises
into the caller; the capture audit trail must not break on an
optional side effect.
Configuration:
- Requires the ``claude`` CLI on PATH (``claude --version`` should work).
- ``ATOCORE_LLM_EXTRACTOR_MODEL`` overrides the model alias (default
``haiku``).
- ``ATOCORE_LLM_EXTRACTOR_TIMEOUT_S`` overrides the per-call timeout
(default 45 seconds — first invocation is slow because Node.js
startup plus OAuth check is non-trivial).
Implementation notes:
- We run ``claude -p`` with ``--model <alias>``,
``--append-system-prompt`` for the extraction instructions,
``--no-session-persistence`` so we don't pollute session history,
and ``--disable-slash-commands`` so stray ``/foo`` in an extracted
response never triggers something.
- The CLI is invoked from a temp working directory so it does not
auto-discover ``CLAUDE.md`` / ``DEV-LEDGER.md`` / ``AGENTS.md``
from the repo root. We want a bare extraction context, not the
full project briefing. We can't use ``--bare`` because that
forces API-key auth; the temp-cwd trick is the lightest way to
keep OAuth auth while skipping project context loading.
"""
from __future__ import annotations
import json
import os
import shutil
import subprocess
import tempfile
from dataclasses import dataclass
from functools import lru_cache
from atocore.interactions.service import Interaction
from atocore.memory.extractor import MemoryCandidate
from atocore.memory.service import MEMORY_TYPES
from atocore.observability.logger import get_logger
log = get_logger("extractor_llm")
LLM_EXTRACTOR_VERSION = "llm-0.2.0"
DEFAULT_MODEL = os.environ.get("ATOCORE_LLM_EXTRACTOR_MODEL", "haiku")
DEFAULT_TIMEOUT_S = float(os.environ.get("ATOCORE_LLM_EXTRACTOR_TIMEOUT_S", "90"))
MAX_RESPONSE_CHARS = 8000
MAX_PROMPT_CHARS = 2000
_SYSTEM_PROMPT = """You extract durable memory candidates from LLM conversation turns for a personal context engine called AtoCore.
Your job is to read one user prompt plus the assistant's response and decide which durable facts, decisions, preferences, architectural rules, or project invariants should be remembered across future sessions.
Rules:
1. Only surface durable claims. Skip transient status ("deploy is still running"), instructional guidance ("here is how to run the command"), troubleshooting tactics, ephemeral recommendations ("merge this PR now"), and session recaps.
2. A candidate is durable when a reader coming back in two weeks would still need to know it. Architectural choices, named rules, ratified decisions, invariants, procurement commitments, and project-level constraints qualify. Conversational fillers and step-by-step instructions do not.
3. Each candidate must stand alone. Rewrite the claim in one sentence under 200 characters with enough context that a reader without the conversation understands it.
4. Each candidate must have a type from this closed set: project, knowledge, preference, adaptation.
5. If the conversation is clearly scoped to a project (p04-gigabit, p05-interferometer, p06-polisher, atocore), set ``project`` to that id. Otherwise leave ``project`` empty.
6. If the response makes no durable claim, return an empty list. It is correct and expected to return [] on most conversational turns.
7. Confidence should be 0.5 by default so human review workload is honest. Raise to 0.6 only when the response states the claim in an unambiguous, committed form (e.g. "the decision is X", "the selected approach is Y", "X is non-negotiable").
8. Output must be a raw JSON array and nothing else. No prose before or after. No markdown fences. No explanations.
Each array element has exactly this shape:
{"type": "project|knowledge|preference|adaptation", "content": "...", "project": "...", "confidence": 0.5}
Return [] when there is nothing to extract."""
@dataclass
class LLMExtractionResult:
candidates: list[MemoryCandidate]
raw_output: str
error: str = ""
@lru_cache(maxsize=1)
def _sandbox_cwd() -> str:
"""Return a stable temp directory for ``claude -p`` invocations.
We want the CLI to run from a directory that does NOT contain
``CLAUDE.md`` / ``DEV-LEDGER.md`` / ``AGENTS.md``, so every
extraction call starts with a clean context instead of the full
AtoCore project briefing. Cached so the directory persists for
the lifetime of the process.
"""
return tempfile.mkdtemp(prefix="ato-llm-extract-")
def _cli_available() -> bool:
return shutil.which("claude") is not None
def extract_candidates_llm(
interaction: Interaction,
model: str | None = None,
timeout_s: float | None = None,
) -> list[MemoryCandidate]:
"""Run the LLM-assisted extractor against one interaction.
Returns a list of ``MemoryCandidate`` objects, empty on any
failure path. The caller is responsible for persistence.
"""
return extract_candidates_llm_verbose(
interaction,
model=model,
timeout_s=timeout_s,
).candidates
def extract_candidates_llm_verbose(
interaction: Interaction,
model: str | None = None,
timeout_s: float | None = None,
) -> LLMExtractionResult:
"""Like ``extract_candidates_llm`` but also returns the raw
subprocess output and any error encountered, for eval / debugging.
"""
if not _cli_available():
return LLMExtractionResult(
candidates=[],
raw_output="",
error="claude_cli_missing",
)
response_text = (interaction.response or "").strip()
if not response_text:
return LLMExtractionResult(candidates=[], raw_output="", error="empty_response")
prompt_excerpt = (interaction.prompt or "")[:MAX_PROMPT_CHARS]
response_excerpt = response_text[:MAX_RESPONSE_CHARS]
user_message = (
f"PROJECT HINT (may be empty): {interaction.project or ''}\n\n"
f"USER PROMPT:\n{prompt_excerpt}\n\n"
f"ASSISTANT RESPONSE:\n{response_excerpt}\n\n"
"Return the JSON array now."
)
args = [
"claude",
"-p",
"--model",
model or DEFAULT_MODEL,
"--append-system-prompt",
_SYSTEM_PROMPT,
"--no-session-persistence",
"--disable-slash-commands",
user_message,
]
try:
completed = subprocess.run(
args,
capture_output=True,
text=True,
timeout=timeout_s or DEFAULT_TIMEOUT_S,
cwd=_sandbox_cwd(),
encoding="utf-8",
errors="replace",
)
except subprocess.TimeoutExpired:
log.error("llm_extractor_timeout", interaction_id=interaction.id)
return LLMExtractionResult(candidates=[], raw_output="", error="timeout")
except Exception as exc: # pragma: no cover - unexpected subprocess failure
log.error("llm_extractor_subprocess_failed", error=str(exc))
return LLMExtractionResult(candidates=[], raw_output="", error=f"subprocess_error: {exc}")
if completed.returncode != 0:
log.error(
"llm_extractor_nonzero_exit",
interaction_id=interaction.id,
returncode=completed.returncode,
stderr_prefix=(completed.stderr or "")[:200],
)
return LLMExtractionResult(
candidates=[],
raw_output=completed.stdout or "",
error=f"exit_{completed.returncode}",
)
raw_output = (completed.stdout or "").strip()
candidates = _parse_candidates(raw_output, interaction)
log.info(
"llm_extractor_done",
interaction_id=interaction.id,
candidate_count=len(candidates),
model=model or DEFAULT_MODEL,
)
return LLMExtractionResult(candidates=candidates, raw_output=raw_output)
def _parse_candidates(raw_output: str, interaction: Interaction) -> list[MemoryCandidate]:
"""Parse the model's JSON output into MemoryCandidate objects.
Tolerates common model glitches: surrounding whitespace, stray
markdown fences, leading/trailing prose. Silently drops malformed
array elements rather than raising.
"""
text = raw_output.strip()
if text.startswith("```"):
text = text.strip("`")
first_newline = text.find("\n")
if first_newline >= 0:
text = text[first_newline + 1 :]
if text.endswith("```"):
text = text[:-3]
text = text.strip()
if not text or text == "[]":
return []
if not text.lstrip().startswith("["):
start = text.find("[")
end = text.rfind("]")
if start >= 0 and end > start:
text = text[start : end + 1]
try:
parsed = json.loads(text)
except json.JSONDecodeError as exc:
log.error("llm_extractor_parse_failed", error=str(exc), raw_prefix=raw_output[:120])
return []
if not isinstance(parsed, list):
return []
results: list[MemoryCandidate] = []
for item in parsed:
if not isinstance(item, dict):
continue
mem_type = str(item.get("type") or "").strip().lower()
content = str(item.get("content") or "").strip()
project = str(item.get("project") or "").strip()
confidence_raw = item.get("confidence", 0.5)
if mem_type not in MEMORY_TYPES:
continue
if not content:
continue
try:
confidence = float(confidence_raw)
except (TypeError, ValueError):
confidence = 0.5
confidence = max(0.0, min(1.0, confidence))
results.append(
MemoryCandidate(
memory_type=mem_type,
content=content[:1000],
rule="llm_extraction",
source_span=content[:200],
project=project,
confidence=confidence,
source_interaction_id=interaction.id,
extractor_version=LLM_EXTRACTOR_VERSION,
)
)
return results

158
tests/test_extractor_llm.py Normal file
View File

@@ -0,0 +1,158 @@
"""Tests for the LLM-assisted extractor path.
Focused on the parser and failure-mode contracts — the actual network
call is exercised out of band by running
``python scripts/extractor_eval.py --mode llm`` against the frozen
labeled corpus with ``ANTHROPIC_API_KEY`` set. These tests only
exercise the pieces that don't need network.
"""
from __future__ import annotations
import os
from unittest.mock import patch
import pytest
from atocore.interactions.service import Interaction
from atocore.memory.extractor_llm import (
LLM_EXTRACTOR_VERSION,
_parse_candidates,
extract_candidates_llm,
extract_candidates_llm_verbose,
)
import atocore.memory.extractor_llm as extractor_llm
def _make_interaction(prompt: str = "p", response: str = "r") -> Interaction:
return Interaction(
id="test-id",
prompt=prompt,
response=response,
response_summary="",
project="",
client="test",
session_id="",
)
def test_parser_handles_empty_array():
result = _parse_candidates("[]", _make_interaction())
assert result == []
def test_parser_handles_malformed_json():
result = _parse_candidates("{ not valid json", _make_interaction())
assert result == []
def test_parser_strips_markdown_fences():
raw = "```json\n[{\"type\": \"knowledge\", \"content\": \"x is y\", \"project\": \"\", \"confidence\": 0.5}]\n```"
result = _parse_candidates(raw, _make_interaction())
assert len(result) == 1
assert result[0].memory_type == "knowledge"
assert result[0].content == "x is y"
def test_parser_strips_surrounding_prose():
raw = "Here are the candidates:\n[{\"type\": \"project\", \"content\": \"foo\", \"project\": \"p04\", \"confidence\": 0.6}]\nThat's it."
result = _parse_candidates(raw, _make_interaction())
assert len(result) == 1
assert result[0].memory_type == "project"
assert result[0].project == "p04"
def test_parser_drops_invalid_memory_types():
raw = '[{"type": "nonsense", "content": "x"}, {"type": "project", "content": "y"}]'
result = _parse_candidates(raw, _make_interaction())
assert len(result) == 1
assert result[0].memory_type == "project"
def test_parser_drops_empty_content():
raw = '[{"type": "knowledge", "content": " "}, {"type": "knowledge", "content": "real"}]'
result = _parse_candidates(raw, _make_interaction())
assert len(result) == 1
assert result[0].content == "real"
def test_parser_clamps_confidence_to_unit_interval():
raw = '[{"type": "knowledge", "content": "c1", "confidence": 2.5}, {"type": "knowledge", "content": "c2", "confidence": -0.4}]'
result = _parse_candidates(raw, _make_interaction())
assert result[0].confidence == 1.0
assert result[1].confidence == 0.0
def test_parser_defaults_confidence_on_missing_field():
raw = '[{"type": "knowledge", "content": "c1"}]'
result = _parse_candidates(raw, _make_interaction())
assert result[0].confidence == 0.5
def test_parser_tags_version_and_rule():
raw = '[{"type": "project", "content": "c1"}]'
result = _parse_candidates(raw, _make_interaction())
assert result[0].rule == "llm_extraction"
assert result[0].extractor_version == LLM_EXTRACTOR_VERSION
assert result[0].source_interaction_id == "test-id"
def test_missing_cli_returns_empty(monkeypatch):
"""If ``claude`` is not on PATH the extractor returns empty, never raises."""
monkeypatch.setattr(extractor_llm, "_cli_available", lambda: False)
result = extract_candidates_llm_verbose(_make_interaction("p", "some real response"))
assert result.candidates == []
assert result.error == "claude_cli_missing"
def test_empty_response_returns_empty(monkeypatch):
monkeypatch.setattr(extractor_llm, "_cli_available", lambda: True)
result = extract_candidates_llm_verbose(_make_interaction("p", ""))
assert result.candidates == []
assert result.error == "empty_response"
def test_subprocess_timeout_returns_empty(monkeypatch):
"""A subprocess timeout must not raise into the caller."""
monkeypatch.setattr(extractor_llm, "_cli_available", lambda: True)
import subprocess as _sp
def _boom(*a, **kw):
raise _sp.TimeoutExpired(cmd=a[0] if a else "claude", timeout=1)
monkeypatch.setattr(extractor_llm.subprocess, "run", _boom)
result = extract_candidates_llm_verbose(_make_interaction("p", "real response"))
assert result.candidates == []
assert result.error == "timeout"
def test_subprocess_nonzero_exit_returns_empty(monkeypatch):
"""A non-zero CLI exit (auth failure, etc.) must not raise."""
monkeypatch.setattr(extractor_llm, "_cli_available", lambda: True)
class _Completed:
returncode = 1
stdout = ""
stderr = "auth failed"
monkeypatch.setattr(extractor_llm.subprocess, "run", lambda *a, **kw: _Completed())
result = extract_candidates_llm_verbose(_make_interaction("p", "real response"))
assert result.candidates == []
assert result.error == "exit_1"
def test_happy_path_parses_stdout(monkeypatch):
monkeypatch.setattr(extractor_llm, "_cli_available", lambda: True)
class _Completed:
returncode = 0
stdout = '[{"type": "project", "content": "p04 selected Option B", "project": "p04-gigabit", "confidence": 0.6}]'
stderr = ""
monkeypatch.setattr(extractor_llm.subprocess, "run", lambda *a, **kw: _Completed())
result = extract_candidates_llm_verbose(_make_interaction("p", "r"))
assert len(result.candidates) == 1
assert result.candidates[0].memory_type == "project"
assert result.candidates[0].project == "p04-gigabit"
assert abs(result.candidates[0].confidence - 0.6) < 1e-9