flywire-coding-cortex 0.1.0__py3-none-any.whl

flywire_coding_cortex/assets/manifest.json

@@ -0,0 +1,54 @@
+{
+  "version": 1,
+  "active_key": "active_profile",
+  "profiles": {
+    "seed": {
+      "label": "Curated circuit (shipped seed)",
+      "approx_size": "~1–5 MB",
+      "description": "FlyWire-derived escape/steering subgraph ready for LIF. Offline after install.",
+      "kind": "seed",
+      "files": []
+    },
+    "codex": {
+      "label": "Codex FAFB v783 CSV dumps + ETL",
+      "approx_size": "~60–300 MB",
+      "description": "Download public Codex gzipped CSVs and rebuild circuit.json via ETL.",
+      "kind": "codex_etl",
+      "base_url": "https://storage.googleapis.com/flywire-data/codex/data/fafb/783",
+      "files": [
+        {"name": "classification.csv.gz", "path": "classification.csv.gz"},
+        {"name": "coordinates.csv.gz", "path": "coordinates.csv.gz"},
+        {"name": "connections.csv.gz", "path": "connections.csv.gz"},
+        {"name": "consolidated_cell_types.csv.gz", "path": "consolidated_cell_types.csv.gz"}
+      ]
+    },
+    "full": {
+      "label": "Zenodo connectivity Feathers (~10.6 GB) + ETL",
+      "approx_size": "~10.6 GB",
+      "description": "Heavy synapse/connectivity Feather tables. Explicit YES confirmation required.",
+      "kind": "zenodo_feather",
+      "confirm": true,
+      "record_url": "https://zenodo.org/records/10676866",
+      "files": [
+        {
+          "name": "proofread_connections_783.feather",
+          "url": "https://zenodo.org/records/10676866/files/proofread_connections_783.feather?download=1",
+          "approx_bytes": 893000000
+        },
+        {
+          "name": "proofread_root_ids_783.npy",
+          "url": "https://zenodo.org/records/10676866/files/proofread_root_ids_783.npy?download=1",
+          "approx_bytes": 1100000
+        },
+        {
+          "name": "flywire_synapses_783.feather",
+          "url": "https://zenodo.org/records/10676866/files/flywire_synapses_783.feather?download=1",
+          "approx_bytes": 9500000000,
+          "optional": true,
+          "note": "Largest file (~9.5 GB). Skipped unless --include-synapses."
+        }
+      ],
+      "requires_extras": ["pandas", "pyarrow"]
+    }
+  }
+}

flywire_coding_cortex/assets/seed-graph.json

@@ -0,0 +1,18 @@
+{
+  "nodes": [
+    {"id": "role:dnp09", "label": "Forward implement", "kind": "role", "lastSeen": 0},
+    {"id": "role:gf", "label": "Stop / escape", "kind": "role", "lastSeen": 0},
+    {"id": "role:mdn", "label": "Reverse / revert", "kind": "role", "lastSeen": 0},
+    {"id": "role:lc4", "label": "Risk detector", "kind": "role", "lastSeen": 0},
+    {"id": "role:ascending", "label": "Read conventions", "kind": "role", "lastSeen": 0},
+    {"id": "concept:tests", "label": "Automated tests", "kind": "concept", "lastSeen": 0},
+    {"id": "concept:api-boundary", "label": "API boundary", "kind": "concept", "lastSeen": 0},
+    {"id": "concept:migration", "label": "Data migration", "kind": "concept", "lastSeen": 0}
+  ],
+  "edges": [
+    {"pre": "role:ascending", "post": "role:dnp09", "weight": 1.0, "why": "read before write", "evidence": []},
+    {"pre": "role:lc4", "post": "role:gf", "weight": 1.2, "why": "high risk can stop ship", "evidence": []},
+    {"pre": "concept:tests", "post": "role:dnp09", "weight": 1.0, "why": "verify after implement", "evidence": []},
+    {"pre": "concept:migration", "post": "role:lc4", "weight": 1.1, "why": "migrations are risky", "evidence": []}
+  ]
+}

flywire_coding_cortex/assets/skill/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: flywire-coding-cortex
+description: >-
+  Runs FlyWire-derived LIF neurons via the flywire-cortex connector and maps
+  population rates to coding drives. Use when coding, debugging, or when the
+  user mentions FlyWire cortex, connectome thinking, or flywire-cortex.
+---
+
+# FlyWire Coding Cortex
+
+Install once (`pip install flywire-coding-cortex`), then use
+`flywire-cortex` / MCP in every session.
+
+**This is not a metaphor-only skill.** You must call the CLI (or MCP tools)
+so real connectome edges are stepped. Do not invent biological fidelity.
+
+## Ensure installed
+
+If `flywire-cortex` is missing:
+
+```bash
+pip install flywire-coding-cortex
+# or from a clone: pip install -e .
+flywire-cortex fetch --profile seed
+flywire-cortex install
+```
+
+Never auto-run `--profile full` (~10.6 GB). Ask the user before `codex` or `full`.
+
+## Every coding turn
+
+1. `flywire-cortex status` — auto-hint if circuit missing; `fetch --profile seed` if needed
+2. `flywire-cortex sense --text "<task>"` — task → sensory currents
+3. `flywire-cortex step --ms 50` — run LIF on real edges
+4. `flywire-cortex signals` — read primary drive + clamps
+5. **Act only under the primary drive** (see [roles.md](roles.md))
+6. Follow [practices.md](practices.md) (winner-take-most, inhibition delay, sparse diffs)
+7. After verify: `flywire-cortex remember strengthen|weaken …`
+
+Optional MCP tools: `cortex_status`, `cortex_sense`, `cortex_step`, `cortex_stimulate`, `cortex_signals`, `cortex_remember`.
+
+## Profiles
+
+| Profile | Size | Command |
+|---|---|---|
+| seed | ~MB | `flywire-cortex fetch` |
+| codex | ~60–300 MB | `flywire-cortex fetch --profile codex` |
+| full | ~10.6 GB | `flywire-cortex fetch --profile full --yes` |
+
+## Hard rules
+
+- One primary drive per turn
+- After high risk / `gf` stop: list blast radius before edits
+- Strengthen memory only when tests/user verification pass
+- Cite FlyWire data as CC BY-NC derived; dynamics are a model

flywire_coding_cortex/assets/skill/practices.md

@@ -0,0 +1,14 @@
+# Thinking practices
+
+Apply on top of real LIF rates:
+
+1. **Winner-take-most** — Exactly one primary role; no feature+refactor+rename in one turn.
+2. **Inhibition delay** — If risk/loom is hot, list blast radius and invariants *before* edits.
+3. **Recurrent working set** — Keep ≤5 active files/APIs; re-touch them each turn.
+4. **Hebbian writeback** — `remember strengthen` only after verify; `weaken` on failure.
+5. **Sparse coding** — Smallest change that satisfies the primary drive.
+6. **Bilateral steer** — Design forks: one paragraph L vs R, then pick (`dna01`/`dna02`).
+7. **Proprioception first** — Read neighbors/conventions (`ascending`) before new patterns.
+8. **Refractory** — After `gf` stop or `mdn` reverse, no new feature drive that turn.
+9. **Population scores** — Prefer CLI sense scores over vibes.
+10. **Consolidate** — End of session: 3 new synapses + 1 weakened belief into memory.

flywire_coding_cortex/assets/skill/roles.md

@@ -0,0 +1,17 @@
+# Role → coding drive map
+
+FlyWire-style role names are **coding lenses** driven by real population rates.
+
+| Role | Drive | Agent action |
+|---|---|---|
+| `lc4` / `lplc2` | risk / loom | Scan blast radius, security, regressions |
+| `gf` | escape / stop | Do not ship; unblocker; halt feature work |
+| `dnp09` | forward | Implement the requested change |
+| `mdn` | reverse | Revert / undo bad direction |
+| `dna01` / `dna02` | steer | Write L vs R design tradeoff, then choose |
+| `dng11` | groom | Cleanup, rename, lint-only |
+| `escw` | effort under pressure | Polish without scope creep |
+| `ascending` | proprioception | Read local conventions before inventing |
+| `sensory` | external constraint | Honor ticket / failing test / user constraint |
+
+Primary drive comes from `flywire-cortex signals` (`primary` field). Support roles may advise but must not override.

flywire_coding_cortex/bridge.py

@@ -0,0 +1,85 @@
+"""Clamp LIF population rates into coding-agent drives (SignalBuilder analogue)."""
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass
+class CodingSignals:
+    primary: str = "dnp09"
+    escape: bool = False
+    stop: bool = False
+    reverse: bool = False
+    walk_drive: float = 0.0
+    groom_drive: float = 0.0
+    wing_drive: float = 0.0
+    nervous: float = 0.0
+    turn_bias: float = 0.0
+    arousal: float = 0.0
+    support: list[str] = field(default_factory=list)
+    rates: dict[str, float] = field(default_factory=dict)
+    rationale: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+def build_signals(
+    rates: dict[str, float],
+    *,
+    gf_spike: bool = False,
+    dna_baseline: float = 0.0,
+) -> CodingSignals:
+    nervous = _clamp(rates.get("loom", 0.0) / 80.0)
+    walk = _clamp(rates.get("fwd", 0.0) / 10.0, 0.0, 1.3)
+    groom = rates.get("groom", 0.0) / 8.0
+    wing = _clamp(rates.get("escw", 0.0) / 10.0, 0.0, 1.3)
+    arousal = _clamp(rates.get("pop", 0.0) / 20.0)
+    diff = rates.get("dna_l", 0.0) - rates.get("dna_r", 0.0)
+    turn = _clamp((diff - dna_baseline) * 0.04, -1.0, 1.0)
+    reverse = rates.get("mdn", 0.0) > 8.0
+    escape = bool(gf_spike)
+    stop = escape or nervous > 0.85
+
+    scores = {
+        "gf": 1.0 if escape or stop else nervous * 0.5,
+        "mdn": 0.9 if reverse else 0.0,
+        "dng11": _clamp(groom / 1.5),
+        "dnp09": _clamp(walk / 1.3) + 0.05,
+        "dna": abs(turn),
+        "escw": wing,
+        "lc4": nervous,
+    }
+    primary = max(scores, key=scores.get)
+    if primary == "dna":
+        primary = "dna01"
+    if primary == "lc4" and not stop:
+        primary = "dnp09" if walk >= 0.15 else "ascending"
+
+    support = [
+        k for k, v in sorted(scores.items(), key=lambda kv: -kv[1]) if k != primary and v > 0.2
+    ][:3]
+    rationale = (
+        f"primary={primary} walk={walk:.2f} nervous={nervous:.2f} "
+        f"mdn={rates.get('mdn', 0):.1f} gf={escape}"
+    )
+    return CodingSignals(
+        primary=primary,
+        escape=escape,
+        stop=stop,
+        reverse=reverse,
+        walk_drive=walk,
+        groom_drive=groom,
+        wing_drive=wing,
+        nervous=nervous,
+        turn_bias=turn,
+        arousal=arousal,
+        support=support,
+        rates=dict(rates),
+        rationale=rationale,
+    )
+
+
+def _clamp(x: float, lo: float = 0.0, hi: float = 1.0) -> float:
+    return max(lo, min(hi, float(x)))

flywire_coding_cortex/cli.py

@@ -0,0 +1,304 @@
+"""CLI: fetch, status, sense, step, stimulate, signals, remember, install, mcp."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import bridge, memory, sense
+from .etl import download as dl
+from .lif import Circuit, LIFSim
+from .paths import (
+    active_profile,
+    circuit_path,
+    home,
+    load_config,
+    set_active_profile,
+    state_path,
+)
+
+
+def _sim(profile: str | None = None) -> LIFSim:
+    path = circuit_path(profile)
+    if not path.exists():
+        if (profile or active_profile()) == "seed":
+            dl.fetch_seed()
+        else:
+            raise SystemExit(
+                f"No circuit for profile {profile or active_profile()}. "
+                f"Run: flywire-cortex fetch --profile {profile or active_profile()}"
+            )
+    return LIFSim(Circuit.load(circuit_path(profile)))
+
+
+_SIM: LIFSim | None = None
+
+
+def _save_sim(sim: LIFSim) -> None:
+    state_path().write_text(json.dumps(sim.to_state()) + "\n", encoding="utf-8")
+
+
+def get_sim(reload: bool = False) -> LIFSim:
+    global _SIM
+    if _SIM is None or reload:
+        _SIM = _sim()
+        sp = state_path()
+        if sp.exists() and not reload:
+            try:
+                _SIM.load_state(json.loads(sp.read_text(encoding="utf-8")))
+            except (json.JSONDecodeError, ValueError, KeyError):
+                pass
+    return _SIM
+
+
+def cmd_fetch(args: argparse.Namespace) -> int:
+    if args.list_profiles:
+        profiles = dl.list_profiles()
+        active = active_profile()
+        for name, meta in profiles.items():
+            mark = " (active)" if name == active else ""
+            print(f"{name}{mark}: {meta.get('approx_size')} — {meta.get('label')}")
+            print(f"  {meta.get('description')}")
+        return 0
+
+    profile = args.profile or "seed"
+    if profile == "seed":
+        path = dl.fetch_seed(force=args.force)
+    elif profile == "codex":
+        path = dl.fetch_codex(force=args.force)
+    elif profile == "full":
+        path = dl.fetch_full(
+            force=args.force,
+            include_synapses=args.include_synapses,
+            yes=args.yes,
+        )
+    else:
+        raise SystemExit(f"Unknown profile: {profile}")
+    set_active_profile(profile)
+    # new circuit → clear LIF state
+    global _SIM
+    _SIM = None
+    sp = state_path()
+    if sp.exists():
+        sp.unlink()
+    data = json.loads(path.read_text(encoding="utf-8"))
+    print(
+        json.dumps(
+            {
+                "ok": True,
+                "profile": profile,
+                "circuit": str(path),
+                "neurons": len(data["neurons"]),
+                "edges": len(data["edges"]),
+            },
+            indent=2,
+        )
+    )
+    return 0
+
+
+def cmd_status(_: argparse.Namespace) -> int:
+    cfg = load_config()
+    profile = cfg.get("active_profile", "seed")
+    path = circuit_path(profile)
+    info: dict = {
+        "home": str(home()),
+        "active_profile": profile,
+        "circuit": str(path),
+        "circuit_exists": path.exists(),
+    }
+    if path.exists():
+        data = json.loads(path.read_text(encoding="utf-8"))
+        roles: dict[str, int] = {}
+        for n in data["neurons"]:
+            roles[n.get("role", "?")] = roles.get(n.get("role", "?"), 0) + 1
+        info.update(
+            {
+                "neurons": len(data["neurons"]),
+                "edges": len(data["edges"]),
+                "source": data.get("source"),
+                "roles": roles,
+            }
+        )
+    else:
+        info["hint"] = "flywire-cortex fetch --profile seed"
+    print(json.dumps(info, indent=2))
+    return 0
+
+
+def cmd_sense(args: argparse.Namespace) -> int:
+    text = args.text or " ".join(args.words) or ""
+    scores = sense.sense_text(
+        text,
+        risk=args.risk,
+        ambiguity=args.ambiguity,
+        test_red=args.test_red,
+        urgency=args.urgency,
+    )
+    sim = get_sim()
+    sim.set_inputs(**scores.as_inputs())
+    _save_sim(sim)
+    print(json.dumps({"text": text, "inputs": scores.as_inputs()}, indent=2))
+    return 0
+
+
+def cmd_step(args: argparse.Namespace) -> int:
+    sim = get_sim()
+    if args.text:
+        scores = sense.sense_text(args.text)
+        sim.set_inputs(**scores.as_inputs())
+    out = sim.step(args.ms)
+    _save_sim(sim)
+    print(json.dumps(out, indent=2))
+    return 0
+
+
+def cmd_stimulate(args: argparse.Namespace) -> int:
+    sim = get_sim()
+    n = sim.stimulate_group(args.group, strength=args.strength, duration_ms=args.ms)
+    if n == 0:
+        raise SystemExit(f"Unknown or empty group: {args.group}. Try: {list(sim.groups)}")
+    _save_sim(sim)
+    print(json.dumps({"group": args.group, "neurons": n, "strength": args.strength, "ms": args.ms}, indent=2))
+    return 0
+
+
+def cmd_signals(args: argparse.Namespace) -> int:
+    sim = get_sim()
+    if args.ms:
+        sim.step(args.ms)
+    gf = sim.consume_gf()
+    diff = sim.rates["dna_l"] - sim.rates["dna_r"]
+    base = float(getattr(sim, "dna_baseline", 0.0))
+    base += (diff - base) * (1.0 / 8.0)
+    sim.dna_baseline = base
+    sig = bridge.build_signals(sim.rates, gf_spike=gf, dna_baseline=base)
+    _save_sim(sim)
+    print(json.dumps(sig.to_dict(), indent=2))
+    return 0
+
+
+def cmd_reset(_: argparse.Namespace) -> int:
+    global _SIM
+    _SIM = None
+    sp = state_path()
+    if sp.exists():
+        sp.unlink()
+    print(json.dumps({"ok": True, "reset": True}, indent=2))
+    return 0
+
+
+def cmd_remember(args: argparse.Namespace) -> int:
+    if args.action == "query":
+        print(json.dumps(memory.query(args.text or ""), indent=2))
+    elif args.action == "strengthen":
+        print(json.dumps(memory.strengthen(args.pre, args.post, why=args.why or ""), indent=2))
+    elif args.action == "weaken":
+        print(json.dumps(memory.weaken(args.pre, args.post, why=args.why or ""), indent=2))
+    elif args.action == "add-node":
+        print(json.dumps(memory.add_node(args.pre, args.label or args.pre, args.kind or "concept"), indent=2))
+    elif args.action == "add-edge":
+        print(json.dumps(memory.add_edge(args.pre, args.post, why=args.why or ""), indent=2))
+    else:
+        raise SystemExit(f"Unknown remember action: {args.action}")
+    return 0
+
+
+def cmd_install(args: argparse.Namespace) -> int:
+    from .install_skills import install_all
+
+    result = install_all(targets=args.targets)
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+def cmd_mcp(_: argparse.Namespace) -> int:
+    from .mcp_server import run_stdio
+
+    run_stdio()
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="flywire-cortex",
+        description="Run FlyWire-derived LIF neurons and map rates to coding-agent drives.",
+    )
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    f = sub.add_parser("fetch", help="Download / activate a circuit profile")
+    f.add_argument("--profile", choices=["seed", "codex", "full"], default="seed")
+    f.add_argument("--list-profiles", action="store_true")
+    f.add_argument("--force", action="store_true")
+    f.add_argument("--yes", action="store_true", help="Confirm full (~10.6 GB) download")
+    f.add_argument("--include-synapses", action="store_true", help="Also fetch ~9.5 GB synapse Feather")
+    f.set_defaults(func=cmd_fetch)
+
+    s = sub.add_parser("status", help="Show active profile and circuit stats")
+    s.set_defaults(func=cmd_status)
+
+    se = sub.add_parser("sense", help="Encode a coding task into sensory currents")
+    se.add_argument("words", nargs="*", help="Task text")
+    se.add_argument("--text", default="")
+    se.add_argument("--risk", type=float, default=None)
+    se.add_argument("--ambiguity", type=float, default=None)
+    se.add_argument("--test-red", dest="test_red", type=float, default=None)
+    se.add_argument("--urgency", type=float, default=None)
+    se.set_defaults(func=cmd_sense)
+
+    st = sub.add_parser("step", help="Advance LIF simulation")
+    st.add_argument("--ms", type=int, default=50)
+    st.add_argument("--text", default="", help="Optional sense text before stepping")
+    st.set_defaults(func=cmd_step)
+
+    sm = sub.add_parser("stimulate", help="Optogenetic-style population stim")
+    sm.add_argument("group", help="Role group: gf, dnp09, mdn, lc4, …")
+    sm.add_argument("--strength", type=float, default=0.25)
+    sm.add_argument("--ms", type=int, default=400)
+    sm.set_defaults(func=cmd_stimulate)
+
+    sg = sub.add_parser("signals", help="Emit clamped coding drives from rates")
+    sg.add_argument("--ms", type=int, default=0, help="Optional step before reading")
+    sg.set_defaults(func=cmd_signals)
+
+    rs = sub.add_parser("reset", help="Clear persisted LIF state")
+    rs.set_defaults(func=cmd_reset)
+
+    rm = sub.add_parser("remember", help="Hebbian coding-memory graph")
+    rm.add_argument("action", choices=["query", "strengthen", "weaken", "add-node", "add-edge"])
+    rm.add_argument("--text", default="")
+    rm.add_argument("--pre", default="")
+    rm.add_argument("--post", default="")
+    rm.add_argument("--why", default="")
+    rm.add_argument("--label", default="")
+    rm.add_argument("--kind", default="concept")
+    rm.set_defaults(func=cmd_remember)
+
+    ins = sub.add_parser("install", help="Wire Cursor / OpenClaw / Claude skills + print MCP snippet")
+    ins.add_argument(
+        "--targets",
+        nargs="*",
+        default=["cursor", "openclaw", "claude"],
+        help="Subset of: cursor openclaw claude",
+    )
+    ins.set_defaults(func=cmd_install)
+
+    m = sub.add_parser("mcp", help="Run MCP stdio connector")
+    m.set_defaults(func=cmd_mcp)
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        code = args.func(args)
+    except BrokenPipeError:
+        code = 0
+    sys.exit(code or 0)
+
+
+if __name__ == "__main__":
+    main()

flywire_coding_cortex/etl/__init__.py

@@ -0,0 +1 @@
+"""ETL package."""