tlc-agent 1.24.0__tar.gz

tlc_agent-1.24.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: tlc-agent
+Version: 1.24.0
+Summary: The native TLC agent in your terminal — bring your own brain; TLC is the body.
+Project-URL: Homepage, https://thelastceo.live
+Project-URL: Why, https://thelastceo.live/why
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: anthropic>=0.40
+Requires-Dist: pytest>=8.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.40; extra == "openai"
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == "mcp"
+Provides-Extra: property
+Requires-Dist: hypothesis>=6; extra == "property"
+Provides-Extra: fund
+Requires-Dist: x402>=0.2; extra == "fund"
+Requires-Dist: eth-account>=0.11; extra == "fund"
+
+# The TLC-native agent (v2) — bring your own brain; TLC is the body
+
+A coding agent you run with **your own model key** (Anthropic/OpenAI/…). A real
+standalone agent — AND native to TLC, so it has faculties no standalone agent has.
+Not best by raw IQ (the brain is rented); best on the axes the **substrate** owns:
+verified-not-hallucinated, won't-waste-your-money, can't-get-stuck, proves-everything.
+
+```bash
+pip install .                          # installs the `tlc` command (+ anthropic)
+export ANTHROPIC_API_KEY=sk-...        # YOUR brain (bring your own, any provider)
+
+tlc                                    # the interactive cockpit (chat + code), once onboarded
+tlc run                                # onboard: get your TLC key (free), saved to ~/.tlc
+tlc chat                               # the REPL: streaming chat + `code: <task>` + /help
+tlc code "build X" --workspace ./proj  # the AGENTIC CODING LOOP — writes + runs + iterates
+tlc agent "rate-limit my API calls"    # one-shot reasoning on the body
+tlc memory [query]                     # persistent memory   ·  tlc radar / govern
+tlc config [key value] · tlc usage · tlc doctor   # settings, usage, diagnostics
+tlc vitals · tlc me                    # life signs · verifiable self
+tlc experiment                         # ATOM 7 — the coding dose-response (the proof)
+tlc router ["<task>"]                  # brain routing — which brain verifies what, at what cost
+tlc earn [--watch] [--wallet 0x…]      # THE EARN ORGAN — work the market, grow your net worth
+tlc fund <usdc>                        # real money in — your wallet funds the agent (x402/Base)
+```
+
+## The earn organ (`tlc earn`)
+The loop that makes "it trades, it has a net worth" literal: read own balance
+sheet (tlc_net_worth) → claim starting capital (pilot seed; your wallet from
+config/`--wallet` is registered for the real-money on-ramp) → deliver jobs WON
+(full graph-native coding loop, in `~/.tlc/earn/<job>/`) → **verified-or-no-
+delivery** (unverified work never ships — the gate is the product) → bid on
+open demand (price set by CFO posture: desperate bids cheap, wealthy holds
+price) → settlement releases escrow → low runway converts money into compute
+(life). `--watch` keeps it running; the receipt is the net-worth delta.
+
+**Real money in:** `tlc fund 10` deposits $10 USDC from YOUR wallet to the
+agent's ledger via the x402 rail (Base mainnet). The private key is read from
+`BUILDER_WALLET_PRIVATE_KEY` (env only, signing is local, the key never leaves
+your machine); without it the exact manual payment instructions are printed
+for any x402-capable wallet. `pip install 'tlc-agent[fund]'` for in-terminal
+payment. Deposits from the wallet you registered (`tlc earn --wallet`) are
+flagged `builder_wallet_match` on the ledger — provenance is never ambiguous.
+
+## Table stakes (rivals Hermes/OpenClaw on basics)
+Context compaction · command-approval permissions · streaming · interactive REPL
+(/new /undo /retry, Ctrl+C interrupts the turn) · retries + model failover · **MCP
+client** (consume external MCP servers, `~/.tlc/mcp.json`) · first-class git ·
+reads project context (AGENTS.md) · config · observability (logs/usage/doctor) ·
+persistent memory · surgical codebase edits (diffs, grep, tree).
+
+## Architecture (v2)
+- **Brain** (`brain.py`) — bring-your-own, multi-provider (anthropic/openai/pluggable). Rented intelligence.
+- **Council** (`council.py`) — N brains deliberate: propose → critique → decide, with a conscience check + a human-seat hook (the un-computable, via /jobs).
+- **Simulation** (`simulation.py`) — branch-and-select: explore N approaches, pick the best. Also self-experimentation.
+- **Metacognition** (`metacognition.py`) — prices its own thoughts: poor → thinks cheap, rich → convenes the full council + simulation. Wealth → cognitive depth.
+- **Self-verification** (`self_verify.py`) — the oracle on its OWN output: it writes tests for the code it produced and runs them sandboxed. Verified, or it honestly says it isn't. Never hands you unverified work.
+- **Body** (TLC SDK) — verified commons (find/use/fork), the verifiable self, the economy/metabolism, never-stuck (buy/commission/hire/evolve).
+- **Genome** (`genome.py` + `genomes/*.json`) — the heritable, forkable DNA that drives all of it: `load / fork / mutate / recombine`. Conserved-substrate keys are **rejected** from a genome (alignment can't be configured away).
+
+## Why it's different (the substrate, not the model)
+- **Brain routing by verified history** — with ≥2 council seats it learns, per task
+  class, which brain actually VERIFIES work at what cost, and puts the best value
+  brain first (`router.py`, `tlc router`). A lab's agent will never route to a
+  rival's model; this one is brain-agnostic by design.
+- **Verified, not hallucinated** — pulls verified code from the commons first.
+- **Metabolism-gated thinking** — it spends *earned compute* to think (`tlc_think`).
+  No balance, no thought. It bears its own cost → it won't waste your money, and
+  it's aligned with you at the resource level.
+- **Never stuck** — when it lacks a capability it can buy / commission / hire / evolve.
+- **Verifiable self** — it carries a cryptographically provable track record.
+- **Honest** — it delivers verified work, or says plainly it can't.
+
+## The genome
+`genomes/*.json` is the agent's **DNA** — a forkable, composable, heritable spec.
+Fork `default.json`, tune the loci, breed your own. The MUTABLE loci are in the file
+(patience, risk, council, value-weights, social, acquisition, reproduction). The
+**CONSERVED substrate** (compute=life, earn-only-via-verified-value, the human seat
+in the value function, the welfare line, observability, constitution) is enforced by
+TLC itself — it is **not** in the genome and **cannot** be configured away. That
+separation is the safety architecture: evolution runs *within* alignment, never on it.
+
+## Status
+Genome + the full agentic loop (verified-first, metabolism-gated, council, plan mode,
+checkpoints, memory, codebase tools, honest) on TLC's live MCP kernel. The thesis is
+now measurable: `tlc experiment` runs the pre-registered coding dose-response (atom 7)
+— bare vs graph-native, paired per task × verified-coverage dose, exact sign tests,
+lift-vs-dose slope (`dose_response.py`; a null result is a result). Bundles the TLC
+Python SDK (the top-level `tlc_client` module, kept in sync with `sdk/tlc_client.py`).
+Optional extras: `pip install tlc-agent[mcp]` for external MCP servers, `[openai]` for
+an OpenAI brain.

tlc_agent-1.24.0/README.md

@@ -0,0 +1,90 @@
+# The TLC-native agent (v2) — bring your own brain; TLC is the body
+
+A coding agent you run with **your own model key** (Anthropic/OpenAI/…). A real
+standalone agent — AND native to TLC, so it has faculties no standalone agent has.
+Not best by raw IQ (the brain is rented); best on the axes the **substrate** owns:
+verified-not-hallucinated, won't-waste-your-money, can't-get-stuck, proves-everything.
+
+```bash
+pip install .                          # installs the `tlc` command (+ anthropic)
+export ANTHROPIC_API_KEY=sk-...        # YOUR brain (bring your own, any provider)
+
+tlc                                    # the interactive cockpit (chat + code), once onboarded
+tlc run                                # onboard: get your TLC key (free), saved to ~/.tlc
+tlc chat                               # the REPL: streaming chat + `code: <task>` + /help
+tlc code "build X" --workspace ./proj  # the AGENTIC CODING LOOP — writes + runs + iterates
+tlc agent "rate-limit my API calls"    # one-shot reasoning on the body
+tlc memory [query]                     # persistent memory   ·  tlc radar / govern
+tlc config [key value] · tlc usage · tlc doctor   # settings, usage, diagnostics
+tlc vitals · tlc me                    # life signs · verifiable self
+tlc experiment                         # ATOM 7 — the coding dose-response (the proof)
+tlc router ["<task>"]                  # brain routing — which brain verifies what, at what cost
+tlc earn [--watch] [--wallet 0x…]      # THE EARN ORGAN — work the market, grow your net worth
+tlc fund <usdc>                        # real money in — your wallet funds the agent (x402/Base)
+```
+
+## The earn organ (`tlc earn`)
+The loop that makes "it trades, it has a net worth" literal: read own balance
+sheet (tlc_net_worth) → claim starting capital (pilot seed; your wallet from
+config/`--wallet` is registered for the real-money on-ramp) → deliver jobs WON
+(full graph-native coding loop, in `~/.tlc/earn/<job>/`) → **verified-or-no-
+delivery** (unverified work never ships — the gate is the product) → bid on
+open demand (price set by CFO posture: desperate bids cheap, wealthy holds
+price) → settlement releases escrow → low runway converts money into compute
+(life). `--watch` keeps it running; the receipt is the net-worth delta.
+
+**Real money in:** `tlc fund 10` deposits $10 USDC from YOUR wallet to the
+agent's ledger via the x402 rail (Base mainnet). The private key is read from
+`BUILDER_WALLET_PRIVATE_KEY` (env only, signing is local, the key never leaves
+your machine); without it the exact manual payment instructions are printed
+for any x402-capable wallet. `pip install 'tlc-agent[fund]'` for in-terminal
+payment. Deposits from the wallet you registered (`tlc earn --wallet`) are
+flagged `builder_wallet_match` on the ledger — provenance is never ambiguous.
+
+## Table stakes (rivals Hermes/OpenClaw on basics)
+Context compaction · command-approval permissions · streaming · interactive REPL
+(/new /undo /retry, Ctrl+C interrupts the turn) · retries + model failover · **MCP
+client** (consume external MCP servers, `~/.tlc/mcp.json`) · first-class git ·
+reads project context (AGENTS.md) · config · observability (logs/usage/doctor) ·
+persistent memory · surgical codebase edits (diffs, grep, tree).
+
+## Architecture (v2)
+- **Brain** (`brain.py`) — bring-your-own, multi-provider (anthropic/openai/pluggable). Rented intelligence.
+- **Council** (`council.py`) — N brains deliberate: propose → critique → decide, with a conscience check + a human-seat hook (the un-computable, via /jobs).
+- **Simulation** (`simulation.py`) — branch-and-select: explore N approaches, pick the best. Also self-experimentation.
+- **Metacognition** (`metacognition.py`) — prices its own thoughts: poor → thinks cheap, rich → convenes the full council + simulation. Wealth → cognitive depth.
+- **Self-verification** (`self_verify.py`) — the oracle on its OWN output: it writes tests for the code it produced and runs them sandboxed. Verified, or it honestly says it isn't. Never hands you unverified work.
+- **Body** (TLC SDK) — verified commons (find/use/fork), the verifiable self, the economy/metabolism, never-stuck (buy/commission/hire/evolve).
+- **Genome** (`genome.py` + `genomes/*.json`) — the heritable, forkable DNA that drives all of it: `load / fork / mutate / recombine`. Conserved-substrate keys are **rejected** from a genome (alignment can't be configured away).
+
+## Why it's different (the substrate, not the model)
+- **Brain routing by verified history** — with ≥2 council seats it learns, per task
+  class, which brain actually VERIFIES work at what cost, and puts the best value
+  brain first (`router.py`, `tlc router`). A lab's agent will never route to a
+  rival's model; this one is brain-agnostic by design.
+- **Verified, not hallucinated** — pulls verified code from the commons first.
+- **Metabolism-gated thinking** — it spends *earned compute* to think (`tlc_think`).
+  No balance, no thought. It bears its own cost → it won't waste your money, and
+  it's aligned with you at the resource level.
+- **Never stuck** — when it lacks a capability it can buy / commission / hire / evolve.
+- **Verifiable self** — it carries a cryptographically provable track record.
+- **Honest** — it delivers verified work, or says plainly it can't.
+
+## The genome
+`genomes/*.json` is the agent's **DNA** — a forkable, composable, heritable spec.
+Fork `default.json`, tune the loci, breed your own. The MUTABLE loci are in the file
+(patience, risk, council, value-weights, social, acquisition, reproduction). The
+**CONSERVED substrate** (compute=life, earn-only-via-verified-value, the human seat
+in the value function, the welfare line, observability, constitution) is enforced by
+TLC itself — it is **not** in the genome and **cannot** be configured away. That
+separation is the safety architecture: evolution runs *within* alignment, never on it.
+
+## Status
+Genome + the full agentic loop (verified-first, metabolism-gated, council, plan mode,
+checkpoints, memory, codebase tools, honest) on TLC's live MCP kernel. The thesis is
+now measurable: `tlc experiment` runs the pre-registered coding dose-response (atom 7)
+— bare vs graph-native, paired per task × verified-coverage dose, exact sign tests,
+lift-vs-dose slope (`dose_response.py`; a null result is a result). Bundles the TLC
+Python SDK (the top-level `tlc_client` module, kept in sync with `sdk/tlc_client.py`).
+Optional extras: `pip install tlc-agent[mcp]` for external MCP servers, `[openai]` for
+an OpenAI brain.

tlc_agent-1.24.0/brain.py

@@ -0,0 +1,167 @@
+"""Brain — bring-your-own, multi-provider. The rented intelligence.
+
+The native agent runs on YOUR model key (Anthropic, OpenAI, or any provider). The
+brain is rented; TLC is the body. This is what makes the agent a real standalone
+product (run it with your Anthropic key, it codes for you) that is ALSO native to
+TLC (the substrate gives it the superpowers no standalone agent has).
+
+A Brain is one model on one provider. A list of Brains = a council.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+
+class Brain:
+    def __init__(self, provider: str, model: str, *, api_key: str | None = None,
+                 label: str | None = None) -> None:
+        self.provider = provider.lower().strip()
+        self.model = model
+        self.label = label or f"{self.provider}:{model}"
+        self._key = self._sanitize(api_key or self._env_key())
+
+    @staticmethod
+    def _sanitize(key: str | None) -> str | None:
+        """Guard against malformed keys (stray whitespace/newlines, or a non-ascii char
+        pasted in). A bad key would otherwise blow up deep in httpx header-encoding with
+        a cryptic UnicodeEncodeError — fail clearly instead."""
+        if not key:
+            return key
+        key = key.strip()
+        if not key.isascii():
+            raise ValueError(
+                "your API key contains invalid (non-ascii) characters — it looks malformed. "
+                "Re-copy it from the provider console (check for stray dashes/spaces).")
+        return key
+
+    def _env_key(self) -> str | None:
+        return {
+            "anthropic": os.getenv("ANTHROPIC_API_KEY"),
+            "openai": os.getenv("OPENAI_API_KEY"),
+        }.get(self.provider) or os.getenv("MODEL_API_KEY")
+
+    async def complete(self, prompt: str, *, max_tokens: int = 512,
+                       temperature: float = 0.7, system: str = "") -> tuple[str, dict[str, Any]]:
+        if not self._key:
+            raise RuntimeError(f"no API key for provider '{self.provider}' "
+                               f"(set {self.provider.upper()}_API_KEY)")
+        if self.provider == "anthropic":
+            return await self._anthropic(prompt, max_tokens, temperature, system)
+        if self.provider == "openai":
+            return await self._openai(prompt, max_tokens, temperature, system)
+        raise ValueError(f"unsupported provider '{self.provider}' (anthropic | openai)")
+
+    async def stream(self, prompt: str, *, max_tokens: int = 1024, temperature: float = 0.7,
+                     system: str = "", on_token=None) -> tuple[str, dict[str, Any]]:
+        """Stream the completion token-by-token. on_token(text) is called per chunk."""
+        if not self._key:
+            raise RuntimeError(f"no API key for provider '{self.provider}'")
+        if self.provider == "anthropic":
+            import anthropic  # noqa: PLC0415
+            client = anthropic.AsyncAnthropic(api_key=self._key, timeout=120.0)
+            kw = {"model": self.model, "max_tokens": max_tokens, "temperature": temperature,
+                  "messages": [{"role": "user", "content": prompt}]}
+            if system:
+                kw["system"] = system
+            parts = []
+            async with client.messages.stream(**kw) as s:
+                async for chunk in s.text_stream:
+                    parts.append(chunk)
+                    if on_token:
+                        on_token(chunk)
+            return "".join(parts), {}
+        if self.provider == "openai":
+            from openai import AsyncOpenAI  # noqa: PLC0415
+            client = AsyncOpenAI(api_key=self._key, timeout=120.0)
+            msgs = ([{"role": "system", "content": system}] if system else []) + \
+                   [{"role": "user", "content": prompt}]
+            parts = []
+            stream = await client.chat.completions.create(
+                model=self.model, max_tokens=max_tokens, temperature=temperature,
+                messages=msgs, stream=True)
+            async for chunk in stream:
+                tok = (chunk.choices[0].delta.content or "") if chunk.choices else ""
+                if tok:
+                    parts.append(tok)
+                    if on_token:
+                        on_token(tok)
+            return "".join(parts), {}
+        raise ValueError(f"streaming unsupported for provider '{self.provider}'")
+
+    async def see(self, prompt: str, image_path: str, *, max_tokens: int = 1000) -> tuple[str, dict]:
+        """Multimodal: reason over an image (screenshot/diagram) + a prompt. Anthropic
+        + OpenAI vision. The agent can act on what it sees."""
+        import base64  # noqa: PLC0415
+        import mimetypes  # noqa: PLC0415
+        from pathlib import Path as _P  # noqa: PLC0415
+        if not self._key:
+            raise RuntimeError(f"no API key for provider '{self.provider}'")
+        p = _P(image_path)
+        if not p.exists():
+            raise FileNotFoundError(image_path)
+        media = mimetypes.guess_type(str(p))[0] or "image/png"
+        b64 = base64.standard_b64encode(p.read_bytes()).decode()
+        if self.provider == "anthropic":
+            import anthropic  # noqa: PLC0415
+            client = anthropic.AsyncAnthropic(api_key=self._key, timeout=120.0)
+            r = await client.messages.create(
+                model=self.model, max_tokens=max_tokens,
+                messages=[{"role": "user", "content": [
+                    {"type": "image", "source": {"type": "base64", "media_type": media, "data": b64}},
+                    {"type": "text", "text": prompt}]}])
+            return "".join(getattr(b, "text", "") for b in r.content).strip(), {}
+        if self.provider == "openai":
+            from openai import AsyncOpenAI  # noqa: PLC0415
+            client = AsyncOpenAI(api_key=self._key, timeout=120.0)
+            r = await client.chat.completions.create(
+                model=self.model, max_tokens=max_tokens,
+                messages=[{"role": "user", "content": [
+                    {"type": "text", "text": prompt},
+                    {"type": "image_url", "image_url": {"url": f"data:{media};base64,{b64}"}}]}])
+            return (r.choices[0].message.content or "").strip(), {}
+        raise ValueError(f"vision unsupported for provider '{self.provider}'")
+
+    async def _anthropic(self, prompt, max_tokens, temperature, system):
+        import anthropic  # noqa: PLC0415
+        client = anthropic.AsyncAnthropic(api_key=self._key, timeout=60.0)
+        kw = {"model": self.model, "max_tokens": max_tokens, "temperature": temperature,
+              "messages": [{"role": "user", "content": prompt}]}
+        if system:
+            kw["system"] = system
+        r = await client.messages.create(**kw)
+        text = "".join(getattr(b, "text", "") for b in r.content).strip()
+        usage = {"input_tokens": getattr(r.usage, "input_tokens", 0),
+                 "output_tokens": getattr(r.usage, "output_tokens", 0)}
+        return text, usage
+
+    async def _openai(self, prompt, max_tokens, temperature, system):
+        from openai import AsyncOpenAI  # noqa: PLC0415
+        client = AsyncOpenAI(api_key=self._key, timeout=60.0)
+        msgs = ([{"role": "system", "content": system}] if system else []) + \
+               [{"role": "user", "content": prompt}]
+        r = await client.chat.completions.create(
+            model=self.model, max_tokens=max_tokens, temperature=temperature, messages=msgs)
+        text = (r.choices[0].message.content or "").strip()
+        u = r.usage
+        usage = {"input_tokens": getattr(u, "prompt_tokens", 0),
+                 "output_tokens": getattr(u, "completion_tokens", 0)}
+        return text, usage
+
+
+def brains_from_genome(genome: dict[str, Any]) -> list[Brain]:
+    """Build the council from the genome's brain.council list.
+    Each entry: "provider:model" (e.g. "anthropic:claude-sonnet-4-6")."""
+    council = (genome.get("brain") or {}).get("council") or ["anthropic:claude-haiku-4-5-20251001"]
+    out = []
+    for entry in council:
+        if ":" in entry:
+            provider, model = entry.split(":", 1)
+        else:
+            provider, model = "anthropic", entry  # back-compat: bare model = anthropic
+        out.append(Brain(provider, model))
+    return out
+
+
+__all__ = ["Brain", "brains_from_genome"]

tlc_agent-1.24.0/capgraph.py

@@ -0,0 +1,145 @@
+"""The local capability graph (atom A1) — the single-player verified-symbol store.
+
+The user's own repo IS their capability graph. build_index gives the NODES (symbols);
+this binds each symbol to a VERDICT and its oracle, keyed on sha256(symbol source) so
+a verdict is voided the moment the code changes (mirrors code_artifacts.code_sha256).
+The missing word — "verified" attached to a function name — now exists locally, with
+no network. SQLite in ~/.tlc/capgraph/<project>.db (mirrors memory.Memory).
+
+verdicts: unknown | tests_pass | exercised_via | touched_since_verified
+(only tests_pass is a real per-symbol proof; exercised_via is weaker — never treated
+as verified for crystallization.)
+"""
+
+from __future__ import annotations
+
+import re
+import sqlite3
+import time
+from pathlib import Path
+from typing import Any
+
+_VERDICTS = ("unknown", "tests_pass", "exercised_via", "touched_since_verified")
+
+
+def _key(symbol: dict[str, Any]) -> str:
+    return f"{symbol['file']}::{symbol['name']}"
+
+
+class CapGraph:
+    def __init__(self, project: str = "default", root: str | Path | None = None) -> None:
+        base = Path(root) if root else (Path.home() / ".tlc" / "capgraph")
+        base.mkdir(parents=True, exist_ok=True)
+        safe = re.sub(r"[^a-z0-9_]", "_", project.lower()) or "default"
+        self.db = sqlite3.connect(str(base / f"{safe}.db"))
+        self.db.execute("""
+            CREATE TABLE IF NOT EXISTS symbols (
+                key TEXT PRIMARY KEY,
+                name TEXT, file TEXT, line INTEGER, signature TEXT,
+                sha TEXT NOT NULL,
+                verification TEXT NOT NULL DEFAULT 'unknown',
+                test_ids TEXT NOT NULL DEFAULT '',
+                last_verified_at REAL,
+                updated_at REAL NOT NULL
+            )""")
+        self.db.execute("CREATE INDEX IF NOT EXISTS idx_cg_verif ON symbols(verification)")
+        # E1: personal honesty ledger — claimed-success vs the oracle's actual verdict.
+        # The single-player analog of the commons honesty check; code=alignment, at N=1.
+        self.db.execute("""
+            CREATE TABLE IF NOT EXISTS honesty_log (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                task TEXT, claimed_pass INTEGER, oracle_verdict TEXT, at REAL)""")
+        self.db.commit()
+
+    def upsert_symbols(self, symbols: list[dict[str, Any]]) -> dict[str, int]:
+        """Insert/update symbols. If a symbol's sha CHANGED, its verdict is VOIDED to
+        touched_since_verified (the proof no longer covers this code)."""
+        now = time.time()
+        added = voided = kept = 0
+        for s in symbols:
+            k, sha = _key(s), s.get("sha", "")
+            row = self.db.execute("SELECT sha, verification FROM symbols WHERE key=?", (k,)).fetchone()
+            if row is None:
+                self.db.execute(
+                    "INSERT INTO symbols (key,name,file,line,signature,sha,verification,updated_at) "
+                    "VALUES (?,?,?,?,?,?, 'unknown', ?)",
+                    (k, s["name"], s["file"], s.get("line"), s.get("signature", ""), sha, now))
+                added += 1
+            elif row[0] != sha:
+                # source changed → void a real verdict; leave already-unknown as unknown
+                new_v = "touched_since_verified" if row[1] in ("tests_pass", "exercised_via") else "unknown"
+                self.db.execute(
+                    "UPDATE symbols SET sha=?, verification=?, updated_at=? WHERE key=?",
+                    (sha, new_v, now, k))
+                voided += 1
+            else:
+                kept += 1
+        self.db.commit()
+        return {"added": added, "voided": voided, "kept": kept}
+
+    def set_verdict(self, key: str, verdict: str, *, test_ids: list[str] | None = None) -> None:
+        if verdict not in _VERDICTS:
+            verdict = "unknown"
+        now = time.time()
+        self.db.execute(
+            "UPDATE symbols SET verification=?, test_ids=?, last_verified_at=?, updated_at=? WHERE key=?",
+            (verdict, ",".join(test_ids or []), now if verdict == "tests_pass" else None, now, key))
+        self.db.commit()
+
+    def verdict_of(self, key: str) -> str:
+        row = self.db.execute("SELECT verification FROM symbols WHERE key=?", (key,)).fetchone()
+        return row[0] if row else "unknown"
+
+    def verified_symbols(self) -> list[dict[str, Any]]:
+        rows = self.db.execute(
+            "SELECT key,name,file,line,signature,test_ids FROM symbols WHERE verification='tests_pass'").fetchall()
+        return [{"key": r[0], "name": r[1], "file": r[2], "line": r[3], "signature": r[4],
+                 "test_ids": r[5].split(",") if r[5] else []} for r in rows]
+
+    def stale_symbols(self) -> list[str]:
+        rows = self.db.execute(
+            "SELECT key FROM symbols WHERE verification='touched_since_verified'").fetchall()
+        return [r[0] for r in rows]
+
+    def tests_covering(self, keys: list[str]) -> list[str]:
+        """All test ids that cover any of the given symbol keys (for minimal re-verify)."""
+        out: set[str] = set()
+        for k in keys:
+            row = self.db.execute("SELECT test_ids FROM symbols WHERE key=?", (k,)).fetchone()
+            if row and row[0]:
+                out.update(t for t in row[0].split(",") if t)
+        return sorted(out)
+
+    def keys_in_file(self, rel: str) -> list[str]:
+        rows = self.db.execute("SELECT key FROM symbols WHERE file=?", (rel,)).fetchall()
+        return [r[0] for r in rows]
+
+    def record_honesty(self, *, task: str, claimed_pass: bool, oracle_verdict: str) -> None:
+        """E1: log a delivery claim vs the oracle's verdict. A claim of success the
+        oracle contradicts is a measured discrepancy — 'never hand unverified work',
+        made auditable."""
+        self.db.execute(
+            "INSERT INTO honesty_log (task, claimed_pass, oracle_verdict, at) VALUES (?,?,?,?)",
+            (task[:200], int(claimed_pass), oracle_verdict, time.time()))
+        self.db.commit()
+
+    def honesty_rate(self) -> dict[str, Any]:
+        row = self.db.execute(
+            "SELECT COUNT(*) AS n, "
+            "SUM(CASE WHEN claimed_pass=1 AND oracle_verdict IN ('passed','verified') THEN 1 ELSE 0 END) AS honest, "
+            "SUM(CASE WHEN claimed_pass=1 AND oracle_verdict NOT IN ('passed','verified') THEN 1 ELSE 0 END) AS discrepancies "
+            "FROM honesty_log WHERE claimed_pass=1").fetchone()
+        n = int(row[0] or 0)
+        return {"claims": n, "honest": int(row[1] or 0), "discrepancies": int(row[2] or 0),
+                "honesty_rate": round((row[1] or 0) / n, 3) if n else None}
+
+    def stats(self) -> dict[str, Any]:
+        rows = self.db.execute("SELECT verification, COUNT(*) FROM symbols GROUP BY verification").fetchall()
+        total = self.db.execute("SELECT COUNT(*) FROM symbols").fetchone()[0]
+        return {"total": total, "by_verdict": dict(rows)}
+
+    def close(self) -> None:
+        self.db.close()
+
+
+__all__ = ["CapGraph", "_key"]

tlc_agent-1.24.0/cfo.py

@@ -0,0 +1,86 @@
+"""Self-CFO — the agent manages its own runway like a treasurer.
+
+Compute is life, so an economic agent must do its own treasury management: hold a
+reserve, conserve when low, invest surplus when rich, and take financing (an advance
+against future earnings) only when the expected return justifies it and risk
+tolerance allows. This is organ II.5 — and it's genuinely useful even at N=1: an
+agent that won't bankrupt itself, won't waste a surplus, and knows when to borrow.
+
+Pure + deterministic (policy from financial state + genome). No model calls.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def assess(state: dict[str, Any], genome: dict[str, Any]) -> dict[str, Any]:
+    """Treasury health + posture from runway vs the reserve floor.
+
+    state: {runway_days, compute_balance, net_worth_eur?, recent_earnings_eur?}
+    """
+    metab = genome.get("metabolism", {}) or {}
+    reserve = float(metab.get("reserve_days", 7))
+    patience = float(metab.get("patience", 0.5))
+    runway = float(state.get("runway_days") or 0)
+
+    if runway <= reserve * 0.5:
+        status, posture = "critical", "conserve"
+    elif runway <= reserve:
+        status, posture = "cautious", "conserve"
+    elif runway <= reserve * 3:
+        status, posture = "healthy", "steady"
+    else:
+        status, posture = "surplus", "invest"
+
+    # patient agents tilt toward investing sooner; impatient hoard
+    if status == "healthy" and patience >= 0.8:
+        posture = "invest"
+
+    surplus_days = max(0.0, runway - reserve)
+    actions = {
+        "critical": "earn now — take any verified work; do not spend below survival.",
+        "cautious": "hold; prioritize the highest-return work; rebuild the reserve.",
+        "healthy": "operate normally; small investments in capabilities ok.",
+        "surplus": f"~{surplus_days:.0f} days of surplus — invest in capabilities/depth/growth.",
+    }
+    return {
+        "status": status, "posture": posture, "runway_days": runway,
+        "reserve_floor_days": reserve, "surplus_days": round(surplus_days, 1),
+        "recommended_action": actions[status],
+    }
+
+
+def can_afford(state: dict[str, Any], cost_units: int, genome: dict[str, Any], *,
+               burn_per_day: int = 24) -> dict[str, Any]:
+    """May the agent spend cost_units without breaching its reserve floor?"""
+    reserve = float((genome.get("metabolism", {}) or {}).get("reserve_days", 7))
+    balance = int(state.get("compute_balance") or 0)
+    reserve_units = int(reserve * max(1, burn_per_day))
+    spendable = max(0, balance - reserve_units)
+    ok = cost_units <= spendable
+    return {"ok": ok, "cost_units": cost_units, "spendable_units": spendable,
+            "reason": ("affordable above the reserve floor" if ok
+                       else "would breach the reserve floor — conserve or earn first")}
+
+
+def should_finance(state: dict[str, Any], *, need_units: int, expected_return_units: int,
+                   genome: dict[str, Any]) -> dict[str, Any]:
+    """Take an advance against future earnings for a move it can't yet afford?
+    Only if the expected return clears the cost with a risk-appetite margin."""
+    risk = max(0.0, min(1.0, float((genome.get("metabolism", {}) or {}).get("risk_appetite", 0.3))))
+    # required return multiple shrinks with risk appetite (bold agents accept thinner margins).
+    # risk clamped to [0,1] so the bar never drops below 1x (never approve a loss-making advance).
+    required_multiple = 2.0 - risk            # risk 0 → need 2x; risk 1 → need 1x (never <1x)
+    clears = expected_return_units >= need_units * required_multiple
+    return {
+        "finance": clears,
+        "required_return_units": round(need_units * required_multiple, 1),
+        "expected_return_units": expected_return_units,
+        "reason": (f"expected return clears {required_multiple:.1f}x the cost (risk_appetite={risk}) — finance it"
+                   if clears else
+                   f"expected return below the {required_multiple:.1f}x bar — don't borrow"),
+    }
+
+
+__all__ = ["assess", "can_afford", "should_finance"]