This is a field report about a method, not about a specific person. It describes how to turn raw work logs into a profile where every claim can be traced to evidence, and why the same recipe transfers to other tools. Real results, project names, quotes, and personal data are not part of this dump; the examples below are synthetic.
\nA resume is a self-report. A certification is a test on a sample. Work logs are traces of real decisions, actions, and consequences, but they are scattered, noisy, and sensitive.
\nThe naive path is to hand a model the entire history and ask it to \"tell me about this person.\" The result is usually a smooth text that is hard to verify: the model averages projects, confuses communication style with decisions, and readily flatters. The more data you feed it, the more convincing the output looks — and the less evidence it contains.
\nWhat is needed is a method that:
\nWe used one dense source — logs from the OpenCode agent environment — and ran them through a fixed pipeline. OpenCode is not required here: the density of the trace matters more than the brand of the tool.
\nThe pipeline deliberately avoids one \"magic\" call. The split into baseline → critique → merge matters more than the choice of model: it prevents one averaged answer from replacing a set of local observations.
\nOpenCode is convenient because intent, action, and outcome live in one place:
\nThis does not make logs \"objective.\" It makes them dense and connected: there is less to guess and more to show.
\nIf the reader has a different stack, they need at least one source of intent and one source of consequence.
\n| Source | \nWhat it gives | \nWhat it lacks | \n
|---|---|---|
| Slack / Teams / Mattermost | \nFraming, veto, and bridging in threads | \nConsequences: decisions, artifacts, metrics | \n
| Jira / Linear / GitHub | \nDecisions, priorities, outcomes | \nReasoning: why this option was chosen | \n
| Zoom / Meet transcripts | \nExtended framing and abstraction shift | \nActions, veto, consequences | \n
| Email / Jabber | \nExplicit decisions and agreements | \nStructure, context, links to artifacts | \n
| IDE / agent logs (OpenCode, Claude Code) | \nA dense trace of action | \nPrivacy and boundaries; often a single tool | \n
If you only have chat, you get a communication profile, not a work profile. If you have chat + tickets + repository, you can talk about decisions. A composition of two or three sources with shared IDs is usually more useful than one \"perfect\" source.
\nThe table below is not a universal standard. It is our contract: decisions and invariants that can be repeated.
\n| What we did | \nWhy | \nWhat to replace it with in another stack | \n
|---|---|---|
| Read the database read-only, chose a window and root sessions | \nDo not mutate the source; separate user decisions from agent execution | \nChat/transcript export; filter by owner and session type | \n
| Used the project as the unit, not an individual message | \nDo not mix contexts or build a profile from random messages | \nChannel, repository, ticket project, meeting | \n
| Filtered user text by length, kept substantive sessions, removed batch/global/temp | \nRemove automation and noise; keep decisions | \nYour own threshold and exclusions; the important part is to write them down | \n
| Built a baseline: aggregates + narrative | \nGet a hypothesis to test, not the truth | \nYour own metrics summary and first profile | \n
| One LLM call per project: baseline + message sample | \nLocal critique does not drown in a global average | \nAny model; the important part is \"critique with evidence\" | \n
| A separate merge call over all corrections | \nResolve conflicts instead of losing them | \nYour own aggregator; preserve disagreements | \n
| Kept report, corrections, calls, usage | \nLeave a trace and make audit possible | \nJSONL/CSV + report; record the model and date | \n
Invariants: do not hide cost or volume, do not make a claim without evidence, do not mix projects, do not present the baseline as final, and preserve limitations and conflicting versions.
\nOne unit of output is not a \"personality trait\"; it is a claim with a link to evidence.
\n{\n \"claim\": \"In this project, the person first reduces scope, then fixes acceptance criteria.\",\n \"scope\": { \"project\": \"project-a\", \"period\": \"2026-01-01..2026-02-01\" },\n \"evidence\": [\n { \"kind\": \"message\", \"ref\": \"session-1#msg-4\", \"quote\": \"let's ship the smaller version first\" },\n { \"kind\": \"artifact\", \"ref\": \"release-notes#v0.1\", \"quote\": \"scope reduced to the first milestone\" }\n ],\n \"interpretation\": { \"lever\": \"framing\" },\n \"confidence\": 0.7,\n \"counterevidence\": [\"in another project, scope expanded instead\"],\n \"limitations\": [\"one project, small sample\"]\n}\nlever is an interpretive lens, not a diagnosis. If it is not useful, keep only claim, evidence, confidence, and counterevidence.
There are three model roles, plus a human pass. Do not mix the model roles: one model can perform all three calls, but the context should be different.
\nYou are a profile auditor. Below is a baseline built from logs. It is a hypothesis, not the truth.\n\nYour task:\n1) find claims supported by evidence;\n2) find claims contradicted by evidence;\n3) find important themes missing from the baseline;\n4) state limitations and conflicts explicitly.\n\nRules:\n- do not flatter and do not \"fill in\" the person;\n- support every conclusion with a link to a message, action, or artifact;\n- if there is no evidence, write \"insufficient data\";\n- do not turn communication style into a personality trait.\n\nBaseline:\n{baseline}\n\nEvidence:\n{sample}\nYou are analyzing one project, not the whole person.\n\nInput:\n- the profile baseline;\n- a sample of the user's messages for {project};\n- where available, links to artifacts and outcomes.\n\nReturn:\n1. what is supported (with evidence);\n2. what is contradicted (with evidence);\n3. what is missing for a conclusion;\n4. how this project differs from the baseline;\n5. what limits this slice has.\n\nDo not mix this project with others. Do not draw conclusions about the person outside this context.\nBelow are the baseline and N independent project audits.\n\nAssemble a final profile, but:\n- preserve disagreements between projects;\n- do not average conflicting observations;\n- separate evidence from interpretation;\n- keep an evidence link for every strong claim;\n- list the limits and what cannot be claimed from this data.\n\nResponse format:\n1. summary;\n2. supported strengths;\n3. supported limitations;\n4. conflicts and uncertainties;\n5. what to check next.\nThe model's output is a draft of a mirror, not a verdict. The person marks each claim:
\nThis pass is what turns a profile into agency. Without it, the model defines the person; with it, the person edits the mirror.
\nThe prompts above are a floor, not a ceiling. These are moves worth testing on the same slice. Change one variable at a time, and keep an idea only if it survives a second project.
\nRun a second call whose only job is to attack the first draft:
\nMerge only what survives both the advocate and the skeptic. Keep the disagreements visible; they are often the most honest part of the profile.
\nTimestamps are an underused dimension. Ask:
\nCaveat: timestamps show activity, not importance. A fast reply can be shallow; a slow one can be deep work.
\nExtract the phrases where the person minimizes their work: \"just\", \"only\", \"helped with\", \"wired up\", \"minor\". Compare them with the actual change, duration, and outcome. Ask the model to flag underclaiming separately from overclaiming. Show the gap; do not rewrite the person's voice.
\nAsk what the person did that does not produce a clean artifact:
\nThis work is often missing from resumes because it has no obvious deliverable.
\nRun three roles on the same slice: a skeptical operator, a teacher, and a maintainer. Merge only the claims they independently support. Keep the disagreements as questions for the person.
\nA model that asks \"what did you mean by this?\" is often more useful than one that concludes. Add a final instruction: \"List the five questions you would ask the person before making this claim.\" Put them in the human self-review.
\nFreeze one slice and one model; change one instruction; compare evidence coverage, unsupported claims, and useful surprises. Keep a log of model, version, temperature, token budget, and prompt hash. Re-test on a project you did not use while writing the prompt.
\nRun a redaction pass before any output: names, paths, tokens, customer data, private URLs. Ask the model to list what it would remove, then verify by hand. Privacy is a prompt constraint, not a post-processing step.
\nFor SQLite, use a URI with mode=ro; do not write to the live database.
import sqlite3\n\nDB = \"file:path/to/opencode.db?mode=ro\"\ncon = sqlite3.connect(DB, uri=True)\nThe schema depends on the tool version. In our version the tables were session, message, part, and project. Check your own schema before querying.
SELECT id, project_id, parent_id, title, time_created\nFROM session\nWHERE parent_id IS NULL\nORDER BY time_created;\nimport hashlib\n\ndef keep(text: str, max_chars: int = 1000) -> bool:\n if not text or len(text) >= max_chars:\n return False\n return True\n\ndef dedupe(rows):\n seen = set()\n for row in rows:\n h = hashlib.sha1(row[\"text\"].encode(\"utf-8\")).hexdigest()\n if h in seen:\n continue\n seen.add(h)\n yield row\nRules to write down before the run:
\nThe baseline is aggregates plus a short narrative. Do not call it a final profile. It should contain:
\nFor each project:
\ncorrections/<project>.md;calls.jsonl.Set a budget and limits before the run. If the model returns generic text without evidence links, the call is a failure.
\nThe merge receives all corrections. A human then checks:
\nOne real run on a single project, with a 20k-character sample and deepseek-v4.1-flash at $0.15/$0.60 per 1M input/output tokens, cost about $0.01:
Treat these as order-of-magnitude, not a cross-model price list. The model and provider set the price: a Claude model on the same endpoint rejected the OpenAI protocol and would need a different adapter and different rates. Cost scales with sample size, number of projects, and output budget. Extraction is cheap; sending a large sample to a reasoning model is not. Check finish_reason and reasoning tokens before paying for a merge.
The snippets above show the shape; this is a runnable reference. It uses only the Python standard library. It reads a read-only SQLite log database or an existing JSONL export, filters records, builds a deterministic baseline, calls an OpenAI-compatible endpoint once per project, merges the corrections, and verifies the outputs. No API key is stored in the file; the script reads it from an environment variable.
\nSmoke-tested with synthetic JSONL and SQLite fixtures and a mock OpenAI-compatible endpoint, then run end-to-end on a real OpenCode database and a live OpenAI-compatible provider (one project, deepseek-v4.1-flash, about $0.01). Treat it as a script plus a recipe, not a turnkey tool: your AI agent should adapt the extractor and prompts to your stack while keeping the filter, evidence, and verification invariants.
The SQL assumes an OpenCode-like schema (part, message, session, project). For another tool, either adapt extract_records() or export JSONL and pass it with --input. For Slack or Mattermost, map messages and threads to the same record shape; for Claude Code or another agent log, map its session/event export. The rest of the pipeline is source-agnostic.
Run order:
\npython scripts/profile_from_logs.py extract --db path/to/logs.db --out out\npython scripts/profile_from_logs.py filter --out out\npython scripts/profile_from_logs.py baseline --out out\n$env:LLM_API_KEY = \"...\"\npython scripts/profile_from_logs.py critique --out out --base-url https://api.openai.com/v1 --model gpt-4o-mini\npython scripts/profile_from_logs.py merge --out out --base-url https://api.openai.com/v1 --model gpt-4o-mini\npython scripts/profile_from_logs.py verify --out out\n#!/usr/bin/env python3\n\"\"\"\nReference pipeline: work logs -> evidence-backed profile.\n\nStages:\n extract read a read-only SQLite log DB (or an existing JSONL export)\n filter keep substantive user messages, dedupe, write project slices\n baseline deterministic aggregates + a short hypothesis\n critique one OpenAI-compatible LLM call per project\n merge one LLM call over all corrections\n verify secret/personal-data scan and output sanity checks\n\nNo secrets are stored in this file. Set the API key via an environment variable.\n\"\"\"\n\nimport argparse\nimport hashlib\nimport json\nimport os\nimport re\nimport sqlite3\nimport sys\nimport time\nimport urllib.error\nimport urllib.request\nfrom datetime import datetime, timedelta\nfrom pathlib import Path\n\nDEFAULT_BASE_URL = \"https://api.openai.com/v1\"\nDEFAULT_MODEL = \"gpt-4o-mini\"\nDEFAULT_MAX_CHARS = 1000\nDEFAULT_DAYS = 120\nDEFAULT_OUTPUT_LIMIT = 4000\n\nSENSITIVE_PATTERNS = [\n r\"sk-[A-Za-z0-9_-]{10,}\",\n r\"st_[A-Za-z0-9_-]{10,}\",\n r\"ghp_[A-Za-z0-9]{20,}\",\n r\"github_pat_[A-Za-z0-9_]+\",\n r\"xox[baprs]-[A-Za-z0-9-]+\",\n r\"AKIA[0-9A-Z]{16}\",\n r\"Bearer\\s+[A-Za-z0-9._-]+\",\n r\"OPENCODE_[A-Z_]+\\s*=\\s*\\S+\",\n r\"x-opencode-[a-z-]+\\s*[:=]\\s*\\S+\",\n r\"api[_-]?key\\s*[:=]\\s*\\S+\",\n r\"password\\s*[:=]\\s*\\S+\",\n]\n\nPERSONAL_PATTERNS = [\n r\"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\",\n]\n\nPHONE_CANDIDATE = re.compile(r\"\\+?\\d[\\d ()-]{8,}\\d\")\n\n\ndef find_phone(text):\n for match in PHONE_CANDIDATE.finditer(text):\n digits = re.sub(r\"\\D\", \"\", match.group(0))\n if 10 <= len(digits) <= 15:\n return match.group(0)\n return None\n\nCRITIQUE_PROMPT = \"\"\"You are analyzing one project, not the whole person.\n\nInput:\n- the profile baseline;\n- a sample of the user's messages for {project};\n- where available, links to artifacts and outcomes.\n\nReturn:\n1. what is supported (with evidence);\n2. what is contradicted (with evidence);\n3. what is missing for a conclusion;\n4. how this project differs from the baseline;\n5. what limits this slice has.\n\nDo not mix this project with others. Do not draw conclusions about the person\noutside this context. Do not flatter. If there is no evidence, say so.\n\nBaseline:\n{baseline}\n\nSample:\n{sample}\n\"\"\"\n\nMERGE_PROMPT = \"\"\"Below are the baseline and {count} independent project audits.\n\nAssemble a final profile, but:\n- preserve disagreements between projects;\n- do not average conflicting observations;\n- separate evidence from interpretation;\n- keep an evidence link for every strong claim;\n- list the limits and what cannot be claimed from this data.\n\nResponse format:\n1. summary;\n2. supported strengths;\n3. supported limitations;\n4. conflicts and uncertainties;\n5. what to check next.\n\nBaseline:\n{baseline}\n\nProject audits:\n{corrections}\n\"\"\"\n\n\ndef log(message):\n print(\"[%s] %s\" % (time.strftime(\"%H:%M:%S\"), message), flush=True)\n\n\ndef read_jsonl(path):\n rows = []\n with Path(path).open(\"r\", encoding=\"utf-8\") as fh:\n for line in fh:\n line = line.strip()\n if line:\n rows.append(json.loads(line))\n return rows\n\n\ndef write_jsonl(path, rows):\n path = Path(path)\n path.parent.mkdir(parents=True, exist_ok=True)\n with path.open(\"w\", encoding=\"utf-8\") as fh:\n for row in rows:\n fh.write(json.dumps(row, ensure_ascii=False) + \"\\n\")\n\n\ndef db_connect(path):\n return sqlite3.connect(\n \"file:%s?mode=ro\" % Path(path).as_posix(),\n uri=True,\n timeout=30,\n )\n\n\ndef keep_project(project, include_global=False):\n p = (project or \"\").replace(\"\\\\\", \"/\")\n if not p or p == \"?\":\n return False\n if p == \"/\" and not include_global:\n return False\n if \"/AppData/Local/Temp/\" in p:\n return False\n return True\n\n\ndef slugify(value):\n raw = (value or \"project\").replace(\"\\\\\", \"/\").strip(\"/\").replace(\":\", \"\")\n out = \"\".join(c if c.isalnum() or c in \"._-\" else \"_\" for c in raw)\n out = out.strip(\"_\") or \"project\"\n if len(out) > 70:\n out = out[:60] + \"_\" + hashlib.sha1(raw.encode(\"utf-8\")).hexdigest()[:8]\n return out\n\n\ndef extract_records(db_path, days, max_chars, include_global=False):\n if days < 1 or days > 36500:\n raise SystemExit(\"--days must be between 1 and 36500\")\n cutoff = int((datetime.now() - timedelta(days=days)).timestamp() * 1000)\n sql = \"\"\"\n SELECT s.id AS session_id,\n COALESCE(pr.worktree, '?') AS project,\n p.time_created AS ts,\n json_extract(p.data, '$.text') AS text,\n COALESCE(s.cost, 0) AS cost\n FROM part p\n JOIN message m ON m.id = p.message_id\n JOIN session s ON s.id = p.session_id\n LEFT JOIN project pr ON pr.id = s.project_id\n WHERE p.time_created >= ?\n AND s.parent_id IS NULL\n AND json_extract(p.data, '$.type') = 'text'\n AND json_extract(m.data, '$.role') = 'user'\n AND length(COALESCE(json_extract(p.data, '$.text'), '')) > 0\n AND length(json_extract(p.data, '$.text')) < ?\n ORDER BY p.time_created\n \"\"\"\n con = db_connect(db_path)\n try:\n rows = con.execute(sql, (cutoff, max_chars)).fetchall()\n finally:\n con.close()\n\n records = []\n for session_id, project, ts, text, cost in rows:\n if not keep_project(project, include_global):\n continue\n text = (text or \"\").strip()\n if not text:\n continue\n records.append({\n \"project\": project,\n \"session_id\": session_id,\n \"role\": \"user\",\n \"ts\": int(ts),\n \"text\": text,\n \"cost\": float(cost or 0),\n })\n return records\n\n\ndef load_input(path):\n rows = read_jsonl(path)\n required = {\"project\", \"session_id\", \"role\", \"ts\", \"text\"}\n for row in rows:\n missing = required - set(row)\n if missing:\n raise SystemExit(\"input record is missing fields: %s\" % sorted(missing))\n return rows\n\n\ndef filter_records(records, max_chars, include_global=False, include_short=False):\n by_session = {}\n for row in records:\n key = (row[\"project\"], row[\"session_id\"])\n by_session.setdefault(key, []).append(row)\n\n substantive = set()\n for key, items in by_session.items():\n cost = sum(float(item.get(\"cost\", 0)) for item in items)\n if include_short or len(items) >= 4 or cost >= 0.005:\n substantive.add(key)\n\n seen = set()\n out = []\n for row in records:\n if not keep_project(row.get(\"project\"), include_global):\n continue\n text = (row.get(\"text\") or \"\").strip()\n if not text or len(text) >= max_chars:\n continue\n key = (row[\"project\"], row[\"session_id\"])\n if key not in substantive:\n continue\n digest = hashlib.sha1(text.encode(\"utf-8\")).hexdigest()\n dedupe_key = (row[\"project\"], digest)\n if dedupe_key in seen:\n continue\n seen.add(dedupe_key)\n out.append(row)\n out.sort(key=lambda item: int(item[\"ts\"]))\n return out\n\n\ndef group_projects(records):\n projects = {}\n for row in records:\n projects.setdefault(row[\"project\"], []).append(row)\n return projects\n\n\ndef build_baseline(records):\n projects = group_projects(records)\n lines = [\n \"# Baseline (hypothesis, not a final profile)\",\n \"\",\n \"This baseline is deterministic aggregates plus a short narrative. \"\n \"It is a hypothesis to test with project-level critique.\",\n \"\",\n \"| Project | Messages | Sessions | Characters | First | Last |\",\n \"|---|---:|---:|---:|---|---|\",\n ]\n for project in sorted(projects):\n items = projects[project]\n sessions = {item[\"session_id\"] for item in items}\n chars = sum(len(item[\"text\"]) for item in items)\n first = datetime.fromtimestamp(min(int(i[\"ts\"]) for i in items) / 1000).date().isoformat()\n last = datetime.fromtimestamp(max(int(i[\"ts\"]) for i in items) / 1000).date().isoformat()\n lines.append(\"| %s | %d | %d | %d | %s | %s |\" % (\n project, len(items), len(sessions), chars, first, last\n ))\n lines.extend([\n \"\",\n \"## What this baseline can and cannot say\",\n \"\",\n \"- It describes the selected slice, not the whole person.\",\n \"- It does not establish quality, seniority, or intent.\",\n \"- It must be checked against artifacts and outcomes.\",\n \"- Missing sources are a limit, not evidence of absence.\",\n \"\",\n ])\n return \"\\n\".join(lines), projects\n\n\ndef call_llm(base_url, api_key, model, messages, max_tokens):\n url = base_url.rstrip(\"/\") + \"/chat/completions\"\n payload = {\n \"model\": model,\n \"messages\": messages,\n \"temperature\": 0.2,\n \"max_tokens\": max_tokens,\n }\n request = urllib.request.Request(\n url,\n data=json.dumps(payload).encode(\"utf-8\"),\n headers={\n \"Content-Type\": \"application/json\",\n \"Authorization\": \"Bearer %s\" % api_key,\n },\n method=\"POST\",\n )\n try:\n with urllib.request.urlopen(request, timeout=180) as response:\n data = json.loads(response.read().decode(\"utf-8\"))\n except urllib.error.HTTPError as exc:\n body = exc.read().decode(\"utf-8\", errors=\"replace\")[:500]\n raise RuntimeError(\"LLM HTTP %s: %s\" % (exc.code, body))\n content = data[\"choices\"][0][\"message\"][\"content\"]\n usage = data.get(\"usage\", {})\n return content, usage\n\n\ndef cost_usd(usage, price_in, price_out):\n return (\n float(usage.get(\"prompt_tokens\", 0)) * price_in\n + float(usage.get(\"completion_tokens\", 0)) * price_out\n ) / 1_000_000\n\n\ndef sample_text(items, max_messages, max_chars):\n parts = []\n used = 0\n for item in items[:max_messages]:\n text = item[\"text\"]\n if used + len(text) > max_chars:\n break\n parts.append(\"- \" + text)\n used += len(text)\n return \"\\n\".join(parts)\n\n\ndef scan_files(paths):\n errors = []\n warnings = []\n for path in paths:\n path = Path(path)\n if not path.exists():\n errors.append(\"missing output: %s\" % path)\n continue\n text = path.read_text(encoding=\"utf-8\", errors=\"replace\")\n for pattern in SENSITIVE_PATTERNS:\n if re.search(pattern, text, re.I):\n errors.append(\"secret-like pattern in %s: %s\" % (path, pattern))\n for pattern in PERSONAL_PATTERNS:\n if re.search(pattern, text, re.I):\n warnings.append(\"possible personal data in %s: %s\" % (path, pattern))\n phone = find_phone(text)\n if phone:\n warnings.append(\"possible phone number in %s\" % path)\n return errors, warnings\n\n\ndef cmd_extract(args):\n out = Path(args.out)\n out.mkdir(parents=True, exist_ok=True)\n if args.input:\n records = load_input(args.input)\n source = args.input\n else:\n if not args.db:\n raise SystemExit(\"extract needs --db or --input\")\n records = extract_records(args.db, args.days, args.max_chars, args.include_global)\n source = args.db\n target = out / \"private\" / \"records.jsonl\"\n write_jsonl(target, records)\n log(\"extracted %d user records from %s -> %s\" % (len(records), source, target))\n\n\ndef cmd_filter(args):\n out = Path(args.out)\n records = read_jsonl(out / \"private\" / \"records.jsonl\")\n filtered = filter_records(\n records,\n max_chars=args.max_chars,\n include_global=args.include_global,\n include_short=args.include_short,\n )\n write_jsonl(out / \"private\" / \"filtered.jsonl\", filtered)\n projects = group_projects(filtered)\n write_jsonl(out / \"private\" / \"projects.json\", [\n {\"project\": project, \"messages\": len(items)}\n for project, items in sorted(projects.items())\n ])\n log(\"kept %d/%d records across %d projects\" % (len(filtered), len(records), len(projects)))\n\n\ndef cmd_baseline(args):\n out = Path(args.out)\n records = read_jsonl(out / \"private\" / \"filtered.jsonl\")\n baseline, projects = build_baseline(records)\n (out / \"baseline.md\").write_text(baseline + \"\\n\", encoding=\"utf-8\")\n (out / \"baseline.json\").write_text(\n json.dumps(\n {project: len(items) for project, items in sorted(projects.items())},\n ensure_ascii=False,\n indent=2,\n ) + \"\\n\",\n encoding=\"utf-8\",\n )\n log(\"wrote baseline for %d projects\" % len(projects))\n\n\ndef cmd_critique(args):\n out = Path(args.out)\n records = read_jsonl(out / \"private\" / \"filtered.jsonl\")\n projects = group_projects(records)\n baseline = (out / \"baseline.md\").read_text(encoding=\"utf-8\")\n corrections_dir = out / \"corrections\"\n corrections_dir.mkdir(parents=True, exist_ok=True)\n calls_path = out / \"calls.jsonl\"\n index_path = corrections_dir / \"index.json\"\n index_entries = []\n index_path.write_text(\"[]\\n\", encoding=\"utf-8\")\n total_cost = 0.0\n api_key = os.environ.get(args.api_key_env, \"\")\n if not api_key and not args.dry_run:\n raise SystemExit(\"set %s or pass --dry-run\" % args.api_key_env)\n\n for index, project in enumerate(sorted(projects), 1):\n if args.max_projects and index > args.max_projects:\n break\n items = projects[project]\n sample = sample_text(items, args.sample_messages, args.sample_chars)\n prompt = CRITIQUE_PROMPT.format(project=project, baseline=baseline, sample=sample)\n if args.dry_run:\n target = corrections_dir / (slugify(project) + \".prompt.txt\")\n log(\"dry-run: would critique %s (%d messages)\" % (project, len(items)))\n target.write_text(prompt + \"\\n\", encoding=\"utf-8\")\n index_entries.append({\"project\": project, \"file\": target.name, \"dry_run\": True})\n index_path.write_text(json.dumps(index_entries, ensure_ascii=False, indent=2) + \"\\n\", encoding=\"utf-8\")\n continue\n target = corrections_dir / (slugify(project) + \".md\")\n log(\"critique %s (%d messages)\" % (project, len(items)))\n content, usage = call_llm(\n args.base_url, api_key, args.model,\n [{\"role\": \"user\", \"content\": prompt}],\n args.max_tokens,\n )\n target.write_text(content.strip() + \"\\n\", encoding=\"utf-8\")\n index_entries.append({\"project\": project, \"file\": target.name, \"dry_run\": False})\n index_path.write_text(json.dumps(index_entries, ensure_ascii=False, indent=2) + \"\\n\", encoding=\"utf-8\")\n total_cost += cost_usd(usage, args.price_in, args.price_out)\n with calls_path.open(\"a\", encoding=\"utf-8\") as fh:\n fh.write(json.dumps({\n \"stage\": \"critique\",\n \"project\": project,\n \"model\": args.model,\n \"usage\": usage,\n \"cost_usd\": round(total_cost, 6),\n }, ensure_ascii=False) + \"\\n\")\n if args.budget_usd and total_cost > args.budget_usd:\n raise SystemExit(\"budget exceeded: $%.4f > $%.4f\" % (total_cost, args.budget_usd))\n log(\"critique done; total cost $%.4f\" % total_cost)\n\n\ndef load_correction_paths(out):\n index_path = out / \"corrections\" / \"index.json\"\n if index_path.exists():\n entries = json.loads(index_path.read_text(encoding=\"utf-8\"))\n return [\n out / \"corrections\" / entry[\"file\"]\n for entry in entries\n if not entry.get(\"dry_run\")\n ]\n return sorted((out / \"corrections\").glob(\"*.md\"))\n\n\ndef cmd_merge(args):\n out = Path(args.out)\n baseline = (out / \"baseline.md\").read_text(encoding=\"utf-8\")\n corrections = []\n for path in load_correction_paths(out):\n if path.exists() and path.suffix == \".md\":\n corrections.append(\"## %s\\n\\n%s\" % (path.stem, path.read_text(encoding=\"utf-8\")))\n if not corrections:\n raise SystemExit(\"no corrections found; run critique first\")\n prompt = MERGE_PROMPT.format(\n count=len(corrections),\n baseline=baseline,\n corrections=\"\\n\\n\".join(corrections),\n )\n if args.dry_run:\n (out / \"report.prompt.txt\").write_text(prompt, encoding=\"utf-8\")\n log(\"dry-run: wrote report prompt\")\n return\n api_key = os.environ.get(args.api_key_env, \"\")\n if not api_key:\n raise SystemExit(\"set %s\" % args.api_key_env)\n content, usage = call_llm(\n args.base_url, api_key, args.model,\n [{\"role\": \"user\", \"content\": prompt}],\n args.max_tokens,\n )\n (out / \"report.md\").write_text(content.strip() + \"\\n\", encoding=\"utf-8\")\n with (out / \"calls.jsonl\").open(\"a\", encoding=\"utf-8\") as fh:\n fh.write(json.dumps({\n \"stage\": \"merge\",\n \"model\": args.model,\n \"usage\": usage,\n \"cost_usd\": round(cost_usd(usage, args.price_in, args.price_out), 6),\n }, ensure_ascii=False) + \"\\n\")\n log(\"wrote report.md\")\n\n\ndef cmd_verify(args):\n out = Path(args.out)\n correction_paths = load_correction_paths(out)\n targets = [out / \"baseline.md\", out / \"report.md\"] + correction_paths\n errors, warnings = scan_files(targets)\n report = out / \"report.md\"\n if not correction_paths:\n errors.append(\"no corrections found\")\n if report.exists():\n text = report.read_text(encoding=\"utf-8\").lower()\n for word in (\"conflict\", \"limitation\"):\n if word not in text:\n warnings.append(\"report.md does not mention %s\" % word)\n if report.exists() and not (out / \"calls.jsonl\").exists():\n warnings.append(\"calls.jsonl is missing\")\n for warning in warnings:\n print(\"WARN:\", warning)\n for error in errors:\n print(\"ERROR:\", error)\n if errors:\n raise SystemExit(1)\n print(\"verify: %d warning(s), 0 error(s)\" % len(warnings))\n\n\ndef add_common(parser):\n parser.add_argument(\"--out\", required=True, help=\"output directory\")\n parser.add_argument(\"--max-chars\", type=int, default=DEFAULT_MAX_CHARS)\n parser.add_argument(\"--include-global\", action=\"store_true\")\n parser.add_argument(\"--include-short\", action=\"store_true\")\n\n\ndef add_llm(parser):\n parser.add_argument(\"--base-url\", default=os.environ.get(\"LLM_BASE_URL\", DEFAULT_BASE_URL))\n parser.add_argument(\"--model\", default=os.environ.get(\"LLM_MODEL\", DEFAULT_MODEL))\n parser.add_argument(\"--api-key-env\", default=\"LLM_API_KEY\")\n parser.add_argument(\"--max-tokens\", type=int, default=DEFAULT_OUTPUT_LIMIT)\n parser.add_argument(\"--price-in\", type=float, default=0.0, help=\"USD per 1M input tokens\")\n parser.add_argument(\"--price-out\", type=float, default=0.0, help=\"USD per 1M output tokens\")\n parser.add_argument(\"--budget-usd\", type=float, default=0.0)\n parser.add_argument(\"--dry-run\", action=\"store_true\")\n\n\ndef main():\n parser = argparse.ArgumentParser(description=__doc__)\n sub = parser.add_subparsers(dest=\"cmd\", required=True)\n\n p = sub.add_parser(\"extract\")\n add_common(p)\n p.add_argument(\"--db\")\n p.add_argument(\"--input\", help=\"existing JSONL export\")\n p.add_argument(\"--days\", type=int, default=DEFAULT_DAYS)\n p.set_defaults(func=cmd_extract)\n\n p = sub.add_parser(\"filter\")\n add_common(p)\n p.set_defaults(func=cmd_filter)\n\n p = sub.add_parser(\"baseline\")\n add_common(p)\n p.set_defaults(func=cmd_baseline)\n\n p = sub.add_parser(\"critique\")\n add_common(p)\n add_llm(p)\n p.add_argument(\"--sample-messages\", type=int, default=200)\n p.add_argument(\"--sample-chars\", type=int, default=40000)\n p.add_argument(\"--max-projects\", type=int, default=0)\n p.set_defaults(func=cmd_critique)\n\n p = sub.add_parser(\"merge\")\n add_common(p)\n add_llm(p)\n p.set_defaults(func=cmd_merge)\n\n p = sub.add_parser(\"verify\")\n add_common(p)\n p.set_defaults(func=cmd_verify)\n\n args = parser.parse_args()\n args.func(args)\n\n\nif __name__ == \"__main__\":\n main()\nfinish_reason and reasoning tokens, not just HTTP 200.ModelProtocolUnsupported while DeepSeek models worked. Test the chosen model, or add a protocol adapter.Authorization; add the headers in call_llm or put a small proxy in front.x-opencode-* and OPENCODE_* names failed on a legitimate mention. Match only name: value or name=value; then a real run passed with one phone-number warning.The method has a product extension, but it is a design proposal, not a standard.
\nThe \"export resume\" button is an abstraction. The delivery point can be an API, a webhook, a credential endpoint, an auto-filled profile, or a wallet. The UI is not the point; the contract is: who signed, what exactly, for which period, with what scope, until when, and whether it can be revoked.
\nRoles:
\nIf the export \"always sits\" in a profile, it is a live attestation. It needs a TTL, selective disclosure, and storage of signed claims with evidence pointers rather than raw logs. Otherwise it is not attestation; it is surveillance.
\nA source signature attests observation, not the person's quality. A provider sees only its own silo; it has a conflict of interest; people whose work is not logged fall into a blind spot. A single vendor's button is a new lock-in; an open contract is a chance to build a resume from several independent exports.
\nThe same export can power two products:
\nThe inward report can show evidence gaps: \"strong framing and bridging, but no closure case; here are three ways to produce one.\" That is more useful than a single score and less like a certification funnel. But the growth report must be private by default, with separate consent, and must not go to the employer.
\nThe risk is not verification itself; it is coercion. If an employer requires the export as a condition of hiring, voluntariness breaks. If the source sells certifications, recommendations become a funnel. Attestation and the growth report should be separated by a contract, not by marketing.
\nThe first reader of a work trace is not a recruiter; it is the person. A resume is a persuasion document. A trace is a mirror with receipts: it shows what you actually did, what you kept treating as routine, what you did when no one asked, what you avoided, and where you grew.
\nThis matters because expertise becomes invisible to its owner. People discount the skills they use automatically, describe complex work as \"just wiring things together\", and forget the decisions that others found hard. A trace can surface that normalized work — not to inflate the person, but to calibrate the story.
\nIt can also show the opposite: gaps, avoidance, and contradictions. That is why the goal is calibration, not affirmation. The useful output is not \"you are better than you think\"; it is \"here is the evidence, decide what it means.\"
\nThis is why the private growth report should be separate from the public export. The person needs a candid mirror before deciding what to disclose. If the same artifact is always employer-facing, self-censorship starts and the mirror stops working.
\nThis dump deliberately does not contain:
\nThis is not censorship; it is the publication boundary. The method can be reused; the profile cannot. The synthetic examples above show the format, not anyone's real work.
\nraw.md — this document: method, prompts, schema, and code.summary.md — a short human-facing brief.REDACTIONS.md — what was removed and why.The original logs and the final profile stay private. If you repeat the method, start with one project and one source of consequences; do not publish raw logs and do not turn the profile into a single score.
\n", "brief_html": "The pitch. HR is right to distrust AI-polished resumes. Your resume says you \"led development\"; your logs show what you actually did: cut the scope, rejected two designs, shipped the third behind a rollback gate. This dump turns those traces into claims a stranger can check — without publishing the raw logs.
\nWhat you get. A working script for a resume from OpenCode, plus a pack of recipes. Hand them to your agent: it can easily adapt the script to your environment — Slack, Mattermost, Jira, or whatever you already use — while keeping the same evidence rules. The output is a resume built from what you actually did, with evidence behind each claim.
\nWhy the person would want it. The first reader is you. A resume is a persuasion document; a work trace is a mirror with receipts. It shows the work you normalized and discounted — and the gaps you avoided — before you decide what to show anyone else. The goal is calibration, not inflation.
\nThe bigger idea. A resume could become a bundle of signed proof: instead of \"led development\", a recruiter sees \"cut scope by 40%, shipped behind a rollback gate\" with a signature from the repository that saw it. Each source signs only what it saw; you choose what to disclose; the reader checks the signature and evidence. This dump sketches that contract and the private growth report that can come with it.
\nWhat to watch out for. This is a field report, not a personality test. Logs favour people who write a lot; silent veto and glue work are hard to see; a model will flatter unless you force counterevidence. The script was smoke-tested on synthetic data, then run end-to-end on a real OpenCode database and a live provider (one project on deepseek-v4.1-flash, about a cent); the redaction scan still flagged possible phone numbers, so review before publishing.
(This is the human door into the raw dump. The body stays machine-first.)
\n" }