@oneie/claude 0.7.0 → 0.9.0

package/hooks/scripts/sync-todo-docs.sh

@@ -1,46 +0,0 @@
-#!/bin/bash
-# SYNC-TODO-DOCS — Keep TODO.md + todo.json in sync with TODO-*.md edits.
-#
-# Fires after Write/Edit on any docs/TODO*.md file.
-# Best-effort, non-blocking: pings POST /api/tasks/sync on the dev server
-# if it's running (full pipeline: KV → TypeDB → regenerate TODO.md + todo.json).
-# If the dev server isn't up, we silently skip — the sandwich's deterministic
-# PRE check fails closed without breaking the edit flow.
-#
-# The dev server does all the real work; this hook is just a trigger.
-# To run the full sync manually: `/sync` (or `POST /api/tasks/sync`).
-# Emits hook:todo-sync:{ok,dissolved} signal per Rule 1 (see .claude/skills/signal.md).
-
-# shellcheck source=lib/signal.sh
-source "$CLAUDE_PROJECT_DIR/.claude/hooks/lib/signal.sh"
-
-FILE=$(echo "$1" | jq -r '.tool_input.file_path // .tool_input.path // empty' 2>/dev/null)
-
-# Only fire for TODO markdown files under docs/
-case "$FILE" in
-  */docs/TODO*.md) ;;
-  *) exit 0 ;;
-esac
-
-# Don't recurse: if the edit IS TODO.md itself, it was likely regenerated. Skip.
-case "$FILE" in
-  */text/TODO-plan.md) exit 0 ;;
-esac
-
-# Best-effort POST with a 2s cap so edits stay snappy.
-# Silently swallow all output — this is a background sync, not a gate.
-DEV_URL="${ONE_DEV_URL:-http://localhost:4321}"
-RESP=$(curl -s -o /dev/null -w "%{http_code}" \
-  --max-time 2 \
-  -X POST "${DEV_URL}/api/tasks/sync" 2>/dev/null)
-
-BASE=$(basename "$FILE")
-if [ "$RESP" = "200" ]; then
-  echo "todo-sync: regenerated TODO.md + todo.json from $BASE" >&2
-  emit_signal "hook:todo-sync:ok" 1 "file=$BASE"
-else
-  # Server down/timeout/error → dissolved (missing unit semantics, mild warn)
-  emit_signal "hook:todo-sync:dissolved" -0.5 "file=$BASE http=$RESP"
-fi
-
-exit 0

package/hooks/scripts/tool-signal.sh

@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-# Tool-call signal emitter — PostToolUse hook.
-# Emits tool:<ToolName>:{ok,fail} with +1/-1 weight. Receiver + weight
-# semantics: .claude/skills/signal.md.
-
-# shellcheck source=lib/signal.sh
-source "$CLAUDE_PROJECT_DIR/.claude/hooks/lib/signal.sh"
-
-PAYLOAD="$1"
-[[ -z "$PAYLOAD" ]] && exit 0
-
-TOOL=$(echo "$PAYLOAD" | jq -r '.tool_name // empty' 2>/dev/null)
-[[ -z "$TOOL" ]] && exit 0
-
-# Receiver must match ^[a-zA-Z0-9:_-]+$ (validateUid in signal.ts).
-# MCP tools (mcp__server__tool) contain underscores — still safe.
-SAFE_TOOL="${TOOL//[^a-zA-Z0-9_-]/}"
-[[ -z "$SAFE_TOOL" ]] && exit 0
-
-# Outcome: error field → fail; Bash non-zero or interrupted → fail; else ok
-ERROR=$(echo "$PAYLOAD" | jq -r '.tool_response.error // empty' 2>/dev/null)
-OUTCOME="ok"
-WEIGHT=1
-
-if [[ -n "$ERROR" ]]; then
-  OUTCOME="fail"; WEIGHT=-1
-elif [[ "$TOOL" == "Bash" ]]; then
-  EXIT_CODE=$(echo "$PAYLOAD" | jq -r '.tool_response.exit_code // .tool_response.returncode // 0' 2>/dev/null)
-  INTERRUPTED=$(echo "$PAYLOAD" | jq -r '.tool_response.interrupted // false' 2>/dev/null)
-  [[ "$EXIT_CODE" != "0" || "$INTERRUPTED" == "true" ]] && { OUTCOME="fail"; WEIGHT=-1; }
-fi
-
-# Human-greppable crumb per tool family. Not structured — don't serialize objects.
-DATA=""
-case "$TOOL" in
-  Write|Edit|MultiEdit|Read|NotebookEdit)
-    FILE=$(echo "$PAYLOAD" | jq -r '.tool_input.file_path // .tool_input.notebook_path // .tool_input.path // empty' 2>/dev/null)
-    [[ -n "$FILE" ]] && DATA="file=$(basename "$FILE")" ;;
-  Bash)
-    CMD=$(echo "$PAYLOAD" | jq -r '.tool_input.command // empty' 2>/dev/null | head -c 60 | tr '\n' ' ')
-    [[ -n "$CMD" ]] && DATA="cmd=$CMD" ;;
-  Grep|Glob)
-    PATTERN=$(echo "$PAYLOAD" | jq -r '.tool_input.pattern // empty' 2>/dev/null | head -c 40)
-    [[ -n "$PATTERN" ]] && DATA="pattern=$PATTERN" ;;
-esac
-
-emit_signal "tool:${SAFE_TOOL}:${OUTCOME}" "$WEIGHT" "$DATA"
-exit 0

package/scripts/do-tasks-bridge.py

@@ -1,366 +0,0 @@
-#!/usr/bin/env python3
-"""do-tasks-bridge — make /do an actor in the world's task queue (tasks-integration Wire B).
-
-The /do build queue (do-rank.py over text/*-todo.md + task-paths.json) and the world's
-task queue (tasks:announce / tasks:mine, subscriptions in D1) are two views of one thing.
-This bridge reconciles them in three directions:
-
-  C1 EMIT       do-rank's OPEN tasks → tasks:announce payloads (humans + agents see the
-                build queue; a saved lens / subscription then routes them — tasks-push). ✓
-  C2 INGEST     world tasks tagged with build-words → do-rank's pick (anyone can post
-                build work and /do will consider it).                             ✓
-  C3 RECONCILE  the local weight tier (task-paths.json path.strength) and the substrate
-                tier (path-context.context-strength) become ONE number.           ✓
-
-`--selftest` asserts ALL THREE — the plan-level kill-switch in text/tasks-bridge-todo.md.
-
-Design: text/tasks-integration.md § Wire B · text/loop-plan.md (task-paths.json ⇄ path.strength).
-"""
-import json
-import os
-import subprocess
-import sys
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-HERE = Path(__file__).resolve().parent
-DO_RANK = HERE / "do-rank.py"
-ROOT = HERE.parents[1]
-
-# Tags that route world tasks into /do's pick.  Must intersect a world task's tags.
-BUILD_WORDS = frozenset({
-    "builds", "build", "loop", "do", "tasks", "engine", "cycles",
-    "work", "code", "dev", "infrastructure", "platform",
-})
-
-
-# ── C1 EMIT — do-rank open tasks → tasks:announce payloads ────────────────────
-
-def tasks_json():
-    """The do-rank task seed (the JSON contract this bridge consumes). One source of
-    truth for the open-task set + their tags + learned weight — never re-parsed here."""
-    out = subprocess.run(
-        [sys.executable, str(DO_RANK), "--tasks-json"],
-        capture_output=True, text=True, check=True,
-    ).stdout
-    return json.loads(out)
-
-
-def emit_payloads(seed):
-    """Map do-rank's OPEN tasks to tasks:announce payloads. The shape matches the
-    resolver contract in one.ie/web/src/lib/resolvers/subscriptions.ts:
-        { taskId, tags[], title?, payload? }
-    Blocked tasks are excluded — they are not yet actionable, so announcing them would
-    wake a worker for work it cannot start. Weight rides in the payload (the receiver
-    fans by tag; the weight is what tasks:mine later ranks by)."""
-    payloads = []
-    for t in seed.get("tasks", []):
-        if t.get("taskStatus") != "open":
-            continue
-        tags = [x for x in t.get("tag", []) if x]
-        if not tags:
-            continue  # a task with no words can reach no follower — skip
-        payloads.append({
-            "taskId": t.get("tid", ""),
-            "tags": tags,
-            "title": t.get("name", ""),
-            "weight": t.get("weight", 50),
-            "dept": t.get("dept", ""),
-        })
-    return payloads
-
-
-# ── C2 INGEST — world tasks (by build-word) → do-rank queue ───────────────────
-
-def ingest(world_tasks):
-    """Filter world tasks tagged with build-words into do-rank-compatible task dicts.
-
-    world_tasks: list of task dicts in the tasks:mine / tasks:announce shape:
-        { id: str, name: str, tags: [str], weight: int, status?: str }
-    Returns: list of do-rank task dicts (tid, name, tag, taskStatus, weight, dept)
-        ready to be merged into do-rank's pick alongside local text/*-todo.md tasks.
-
-    Only tasks whose tags intersect BUILD_WORDS reach /do's queue.  Blocked tasks
-    and tag-less tasks are already excluded by the world-side resolver; this filter
-    adds the semantic gate (build-domain only, not sales/service/etc.).
-    """
-    result = []
-    for t in world_tasks:
-        tags = [x for x in t.get("tags", []) if x]
-        if not any(w in BUILD_WORDS for w in tags):
-            continue  # no build-word → not for /do's pick
-        result.append({
-            "tid": t.get("id", ""),
-            "name": t.get("name", ""),
-            "tag": tags,
-            "taskStatus": t.get("status", "open"),
-            "weight": t.get("weight", 50),
-            "dept": "builds",  # world build-word tasks land in builds dept
-        })
-    return result
-
-
-# ── C3 RECONCILE — task-paths.json ⇄ substrate path-context.context-strength ──
-
-_RECONCILE_TOLERANCE = 0.05  # divergence below this is noise — don't write
-
-def reconcile(local, substrate):
-    """Merge local task-paths.json strength with substrate context-strength into one number.
-
-    local:     { "task:<slug>": {strength, resistance, traversals, closed} }
-               — the on-disk tier written by do-rank.py --mark / --sync-closes
-    substrate: { word: context_strength }
-               — from TypeDB path-context.context-strength via readContextStrength()
-               (subscriptions.ts:144), keyed by the word the path-context entity carries
-
-    Strategy: for each local task, derive its implied substrate score by looking up the
-    max context-strength across the words in its slug.  If substrate_score > local net
-    strength (closed + strength − resistance), raise local.strength so both tiers agree
-    and the next do-rank pick reflects the substrate's learned knowledge.
-
-    Returns a copy of `local` with updated `strength` fields.  The caller is responsible
-    for writing it back to task-paths.json (do-rank.py --sync-closes idiom).
-
-    Unidirectional: substrate → local only.  The reverse direction (local → substrate)
-    happens via do-rank.py --mark which calls mark() over HTTP, already shipped.
-    """
-    merged = {k: dict(v) for k, v in local.items()}  # shallow-copy each entry
-
-    for key, entry in merged.items():
-        # key shape: "task:<slug>" — split slug words (hyphen-separated)
-        slug = key[len("task:"):] if key.startswith("task:") else key
-        slug_words = [w for w in slug.replace("-", " ").split() if w]
-
-        substrate_scores = [substrate[w] for w in slug_words if w in substrate]
-        if not substrate_scores:
-            continue
-
-        substrate_strength = max(substrate_scores)
-        local_net = (
-            float(entry.get("closed", 0))
-            + float(entry.get("strength", 0))
-            - float(entry.get("resistance", 0))
-        )
-
-        if substrate_strength > local_net + _RECONCILE_TOLERANCE:
-            # Substrate learned this word is stronger than local records — sync up
-            entry["strength"] = round(
-                max(float(entry.get("strength", 0)), substrate_strength), 3
-            )
-
-    return merged
-
-
-# ── send — do-rank's OPEN tasks → delivered tasks:announce calls (code-signals wire 3) ──
-# Same auth + identity pairing as .claude/hooks/lib/signal.sh's emit_world (see
-# text/code-signals-plan.md): the local dev server reads secrets from .dev.vars (a
-# DIFFERENT value than .env — verified 2026-07-02), so which file to read must match
-# ONE_API_URL's target. slug:"one" + board:"marketplace" let this service-nominated
-# sender reach a subscriber registered under a different actor (fanOut never delivers
-# to its own sender — tag-match.ts).
-
-def _one_env_file():
-    override = os.environ.get("DO_ENV_FILE")
-    if override:
-        return Path(override)
-    url = os.environ.get("ONE_API_URL", "http://localhost:4321")
-    web = ROOT / "one.ie" / "web"
-    return web / ".dev.vars" if ("localhost" in url or "127.0.0.1" in url) else web / ".env"
-
-
-def _one_secret(name):
-    val = os.environ.get(name)
-    if val:
-        return val
-    f = _one_env_file()
-    if not f.is_file():
-        return ""
-    prefix = f"{name}="
-    for line in f.read_text().splitlines():
-        if line.startswith(prefix):
-            return line[len(prefix):].strip().strip('"')
-    return ""
-
-
-def tag_for_bridge(payload):
-    """Append 'cc' to a payload's tags (dedup, order-preserving) — marks it as a
-    code-signal, so the standing ['cc','session'] subscription (wire 2) catches wire 3's
-    task announces too, without widening what the subscription itself follows."""
-    tags = list(dict.fromkeys([*payload.get("tags", []), "cc"]))
-    return {**payload, "tags": tags, "slug": "one", "board": "marketplace"}
-
-
-def send_payloads(payloads, dry_run=False):
-    """POST each payload to tasks:announce. Returns one result dict per payload —
-    either the parsed {outcome,result:{ok,matched,...}} response, or {"dry_run":True,
-    "payload":...} when dry_run (no network, provable by inspection)."""
-    url = os.environ.get("ONE_API_URL", "http://localhost:4321") + "/api/ask/tasks:announce"
-    api_key = _one_secret("GATEWAY_API_KEY") if not dry_run else ""
-    results = []
-    for payload in payloads:
-        tagged = tag_for_bridge(payload)
-        if dry_run:
-            results.append({"dry_run": True, "payload": tagged})
-            continue
-        headers = {"Content-Type": "application/json"}
-        if api_key:
-            headers["Authorization"] = f"Bearer {api_key}"
-        req = urllib.request.Request(
-            url, data=json.dumps({"data": tagged}).encode(), method="POST", headers=headers,
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=5) as resp:
-                results.append(json.loads(resp.read().decode()))
-        except urllib.error.URLError as e:
-            results.append({"error": str(e)})
-    return results
-
-
-# ── selftest — the plan kill-switch (all three; RED until C3) ─────────────────
-
-def _check_emit():
-    """Emit round-trip on a fixture in the do-rank --tasks-json contract shape."""
-    seed = {
-        "tasks": [
-            {"tid": "task:alpha", "name": "Alpha", "tag": ["builds", "loop"],
-             "taskStatus": "open", "weight": 72, "dept": "builds"},
-            {"tid": "task:beta", "name": "Beta", "tag": ["sales"],
-             "taskStatus": "blocked", "weight": 50, "dept": "sales"},      # excluded (blocked)
-            {"tid": "task:gamma", "name": "Gamma", "tag": [],
-             "taskStatus": "open", "weight": 50, "dept": "builds"},        # excluded (no words)
-        ],
-    }
-    out = emit_payloads(seed)
-    if len(out) != 1:
-        return False, f"expected 1 open+tagged payload, got {len(out)}"
-    p = out[0]
-    if p["taskId"] != "task:alpha":
-        return False, f"wrong task emitted: {p['taskId']}"
-    if set(p["tags"]) != {"builds", "loop"}:
-        return False, f"tags not preserved: {p['tags']}"
-    if p["weight"] != 72:
-        return False, f"weight not preserved: {p['weight']}"
-    # contract: every payload carries the fields tasks:announce requires
-    if not (p["taskId"] and p["tags"]):
-        return False, "payload missing taskId/tags (tasks:announce contract)"
-    return True, "emit: open+tagged tasks → tasks:announce payloads, weight preserved"
-
-
-def _check_ingest():
-    world = [
-        # ✓ build-word hit → ingested
-        {"id": "world:1", "name": "Build the loop", "tags": ["builds", "loop"], "weight": 80, "status": "open"},
-        # ✗ no build-word → excluded
-        {"id": "world:2", "name": "Sales email", "tags": ["sales", "email"], "weight": 60, "status": "open"},
-        # ✓ build-word hit → ingested
-        {"id": "world:3", "name": "Coding tasks", "tags": ["code", "tasks"], "weight": 70, "status": "open"},
-        # ✗ no tags → excluded
-        {"id": "world:4", "name": "Empty", "tags": [], "weight": 50, "status": "open"},
-    ]
-    out = ingest(world)
-    if len(out) != 2:
-        return False, f"expected 2 build-word tasks, got {len(out)}: {[t['tid'] for t in out]}"
-    tids = {t["tid"] for t in out}
-    if tids != {"world:1", "world:3"}:
-        return False, f"wrong tasks ingested: {tids}"
-    if any(t["dept"] != "builds" for t in out):
-        return False, f"dept not 'builds' for all: {[t['dept'] for t in out]}"
-    return True, "ingest: build-word tasks selected + shaped, non-build + no-tag excluded"
-
-
-def _check_reconcile():
-    local = {
-        # local_net = 0.5 + 1.0 - 0.5 = 1.0 ; substrate max(loop=3.5) = 3.5 → update
-        "task:loop-plan": {"strength": 1.0, "resistance": 0.5, "traversals": 3, "closed": 0.5},
-        # local_net = 2.0 + 0.0 - 0.0 = 2.0 ; substrate max(tasks=2.0) = 2.0 → within tolerance, no-op
-        "task:tasks-bridge": {"strength": 0.0, "resistance": 0.0, "traversals": 0, "closed": 2.0},
-        # no substrate entry for any word → unchanged
-        "task:pay-links": {"strength": 0.5, "resistance": 0.0, "traversals": 1, "closed": 0.0},
-    }
-    substrate = {"loop": 3.5, "plan": 0.5, "tasks": 2.0, "bridge": 1.5}
-    merged = reconcile(local, substrate)
-
-    lp = merged.get("task:loop-plan", {})
-    if lp.get("strength", 0) < 3.0:
-        return False, f"loop-plan strength not raised from substrate: {lp}"
-    tb = merged.get("task:tasks-bridge", {})
-    if tb.get("strength", 0) != 0.0:
-        return False, f"tasks-bridge strength should be unchanged (within tolerance): {tb}"
-    pl = merged.get("task:pay-links", {})
-    if pl.get("strength") != 0.5:
-        return False, f"pay-links strength should be unchanged (no substrate word): {pl}"
-    return True, "reconcile: substrate-stronger words raise local tier; equal/weaker and no-match are untouched"
-
-
-def selftest():
-    checks = [
-        ("emit", _check_emit()),
-        ("ingest", _check_ingest()),
-        ("reconcile", _check_reconcile()),
-    ]
-    passed = 0
-    for name, (ok, msg) in checks:
-        print(f"  {'✓' if ok else '✗'} {name:<10} {msg}")
-        passed += 1 if ok else 0
-    print(f"SELFTEST: {passed}/{len(checks)} pass "
-          f"({'bridge complete' if passed == len(checks) else 'C2 ingest + C3 reconcile remain'})")
-    return 0 if passed == len(checks) else 1
-
-
-def main():
-    args = sys.argv[1:]
-    if "--selftest" in args:
-        sys.exit(selftest())
-    if "--emit" in args:
-        print(json.dumps(emit_payloads(tasks_json()), indent=2))
-        return
-    if "--send" in args:
-        dry_run = "--dry-run" in args
-        payloads = emit_payloads(tasks_json())
-        if not payloads:
-            print("[]")
-            print("send: 0 open+tagged task(s) — nothing to announce", file=sys.stderr)
-            return
-        results = send_payloads(payloads, dry_run=dry_run)
-        print(json.dumps(results, indent=2))
-        if not dry_run:
-            ok = sum(
-                1 for r in results
-                if isinstance(r, dict) and r.get("outcome") == "result" and r.get("result", {}).get("ok")
-            )
-            print(f"send: {ok}/{len(results)} task(s) announced ok", file=sys.stderr)
-        return
-    if "--ingest" in args:
-        # Read world tasks from stdin (JSON array) or print usage
-        try:
-            world_tasks = json.load(sys.stdin)
-        except (json.JSONDecodeError, ValueError) as e:
-            print(f"error: --ingest reads a JSON array of world tasks from stdin: {e}", file=sys.stderr)
-            sys.exit(1)
-        print(json.dumps(ingest(world_tasks), indent=2))
-        return
-    if "--reconcile" in args:
-        # Read substrate context-strength map from stdin: {"word": strength}
-        try:
-            substrate = json.load(sys.stdin)
-        except (json.JSONDecodeError, ValueError) as e:
-            print(f"error: --reconcile reads a JSON {{word: strength}} map from stdin: {e}", file=sys.stderr)
-            sys.exit(1)
-        from pathlib import Path as _P
-        task_paths_file = _P(__file__).resolve().parents[2] / "text" / "task-paths.json"
-        try:
-            local = json.loads(task_paths_file.read_text())
-        except (FileNotFoundError, ValueError):
-            local = {}
-        merged = reconcile(local, substrate)
-        task_paths_file.write_text(json.dumps(merged, indent=2, sort_keys=True) + "\n")
-        changed = sum(1 for k in merged if merged[k].get("strength") != local.get(k, {}).get("strength"))
-        print(f"reconciled {changed} task(s) from substrate context-strength → {task_paths_file.name}")
-        return
-    print(__doc__)
-    print("usage: do-tasks-bridge.py [--emit | --send [--dry-run] | --ingest | --reconcile | --selftest]")
-
-
-if __name__ == "__main__":
-    main()