@oneie/claude 0.5.0 → 0.7.0

package/scripts/typedb-probes/containment-probe.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""Settles the doc's UNCONFIRMED claim:
+
+    "Do NOT run `match (container: $x, contained: $x) isa containment;` — the
+     same variable in two roles. It appeared to kill the cluster outright
+     rather than return empty."
+
+Same oracle as the unicode panic probe: docker restart count before/after.
+Runs against a scratch db with a containment relation defined and a couple of
+real (non-self) edges, so an empty result is a meaningful empty.
+"""
+import json, subprocess, sys, time, urllib.request, urllib.error
+
+URL = "http://127.0.0.1:8000"
+DB = "selfrole"
+
+
+def restarts():
+    return subprocess.run(["docker", "inspect", "typedb", "--format", "{{.RestartCount}}"],
+                          capture_output=True, text=True).stdout.strip()
+
+
+def signin(tries=25):
+    for _ in range(tries):
+        try:
+            req = urllib.request.Request(URL + "/v1/signin", method="POST",
+                                         headers={"Content-Type": "application/json"})
+            with urllib.request.urlopen(req, json.dumps(
+                    {"username": "admin", "password": "password"}).encode(), timeout=5) as r:
+                return json.load(r)["token"]
+        except Exception:
+            time.sleep(1)
+    sys.exit("could not sign in")
+
+
+def send(tok, q, kind="read"):
+    req = urllib.request.Request(URL + "/v1/query", method="POST", headers={
+        "Content-Type": "application/json", "Authorization": "Bearer " + tok})
+    body = json.dumps({"databaseName": DB, "transactionType": kind, "query": q},
+                      ensure_ascii=False).encode("utf-8")
+    t0 = time.time()
+    try:
+        with urllib.request.urlopen(req, body, timeout=60) as r:
+            d = json.load(r)
+            n = len(d.get("answers") or [])
+            return f"200 ({n} answers)", time.time() - t0
+    except urllib.error.HTTPError as e:
+        return f"{e.code} {e.read()[:60].decode('utf-8','replace')}", time.time() - t0
+    except Exception as e:
+        return f"DROPPED({type(e).__name__})", time.time() - t0
+
+
+tok = signin()
+try:
+    urllib.request.urlopen(urllib.request.Request(
+        URL + f"/v1/databases/{DB}", method="POST",
+        headers={"Authorization": "Bearer " + tok}), b"", timeout=15).read()
+except Exception:
+    pass
+
+send(tok, """define
+  attribute nid, value string;
+  entity node, owns nid @key, plays containment:container, plays containment:contained;
+  relation containment, relates container, relates contained;""", "schema")
+send(tok, 'insert $a isa node, has nid "a"; $b isa node, has nid "b"; $c isa node, has nid "c";', "write")
+send(tok, 'match $a isa node, has nid "a"; $b isa node, has nid "b"; '
+          'insert $r links (container: $a, contained: $b), isa containment;', "write")
+send(tok, 'match $b isa node, has nid "b"; $c isa node, has nid "c"; '
+          'insert $r links (container: $b, contained: $c), isa containment;', "write")
+
+PROBES = [
+    ("sanity: normal containment read", 'match $r links (container: $x, contained: $y), isa containment; select $x, $y;'),
+    ("THE SUSPECT: same var in two roles", 'match $r links (container: $x, contained: $x), isa containment; select $x;'),
+    ("legacy paren syntax, same var",      'match ($x, $x) isa containment; select $x;'),
+    ("recovery: normal read again",        'match $r links (container: $x, contained: $y), isa containment; select $x, $y;'),
+]
+
+print(f"  {'probe':40} {'result':30} {'secs':>6}  restarts")
+prev = restarts()
+print(f"  {'(baseline)':40} {'-':30} {'-':>6}  {prev}")
+for name, q in PROBES:
+    res, secs = send(tok, q)
+    time.sleep(4)
+    r = restarts()
+    flag = "  <-- SERVER KILLED" if r != prev else ""
+    print(f"  {name:40} {res:30} {secs:6.2f}  {r}{flag}")
+    prev = r
+    tok = signin()

package/scripts/typedb-probes/panic-probe-version.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Run both confirmed server-killing query shapes against an arbitrary TypeDB.
+
+Usage: panic-probe-version.py <url> <container-name>
+Oracle is the container restart count, same as the 3.8.3 probes.
+"""
+import json, subprocess, sys, time, urllib.request, urllib.error
+
+URL, CONTAINER = sys.argv[1], sys.argv[2]
+DB = "panicver"
+
+
+def restarts():
+    return subprocess.run(["docker", "inspect", CONTAINER, "--format", "{{.RestartCount}}"],
+                          capture_output=True, text=True).stdout.strip()
+
+
+def alive():
+    try:
+        urllib.request.urlopen(urllib.request.Request(
+            URL + "/v1/signin", method="POST", headers={"Content-Type": "application/json"}),
+            json.dumps({"username": "admin", "password": "password"}).encode(), timeout=3)
+        return True
+    except urllib.error.HTTPError:
+        return True          # answered => process alive
+    except Exception:
+        return False
+
+
+def signin(tries=30):
+    for _ in range(tries):
+        try:
+            req = urllib.request.Request(URL + "/v1/signin", method="POST",
+                                         headers={"Content-Type": "application/json"})
+            with urllib.request.urlopen(req, json.dumps(
+                    {"username": "admin", "password": "password"}).encode(), timeout=5) as r:
+                return json.load(r)["token"]
+        except Exception:
+            time.sleep(1)
+    return None
+
+
+def send(tok, q, kind="write"):
+    req = urllib.request.Request(URL + "/v1/query", method="POST", headers={
+        "Content-Type": "application/json", "Authorization": "Bearer " + tok})
+    body = json.dumps({"databaseName": DB, "transactionType": kind, "query": q},
+                      ensure_ascii=False).encode("utf-8")
+    try:
+        with urllib.request.urlopen(req, body, timeout=30) as r:
+            d = json.load(r)
+            return f"200 ({len(d.get('answers') or [])} answers)"
+    except urllib.error.HTTPError as e:
+        return f"{e.code} {json.loads(e.read()).get('code','')}"
+    except Exception as e:
+        return f"DROPPED({type(e).__name__})"
+
+
+tok = signin()
+try:
+    urllib.request.urlopen(urllib.request.Request(
+        URL + f"/v1/databases/{DB}", method="POST",
+        headers={"Authorization": "Bearer " + tok}), b"", timeout=15).read()
+except Exception:
+    pass
+send(tok, """define
+  attribute note, value string; attribute nid, value string;
+  entity node, owns nid @key, owns note,
+    plays containment:container, plays containment:contained;
+  relation containment, relates container, relates contained;""", "schema")
+send(tok, 'insert $a isa node, has nid "a"; $b isa node, has nid "b";', "write")
+send(tok, 'match $a isa node, has nid "a"; $b isa node, has nid "b"; '
+          'insert $r links (container: $a, contained: $b), isa containment;', "write")
+
+PROBES = [
+    ("control: ASCII insert",             'insert $x isa node, has nid "ctl1", has note "plain";', "write"),
+    ("control: raw UTF-8 insert",         'insert $x isa node, has nid "ctl2", has note "café — ok";', "write"),
+    ("KILLER 1: \\uXXXX in literal",      'insert $x isa node, has nid "u1", has note "caf\\u00e9";', "write"),
+    ("KILLER 2: same var, two roles",     'match $r links (container: $x, contained: $x), isa containment; select $x;', "read"),
+    ("recovery: ASCII read",              'match $x isa node, has nid $n; select $n;', "read"),
+]
+
+print(f"  {'probe':36} {'result':30} restarts  alive")
+prev = restarts()
+print(f"  {'(baseline)':36} {'-':30} {prev:8}  {alive()}")
+for name, q, kind in PROBES:
+    res = send(tok, q, kind)
+    time.sleep(4)
+    r, a = restarts(), alive()
+    flag = "  <-- KILLED" if r != prev else ""
+    print(f"  {name:36} {res:30} {r:8}  {a}{flag}")
+    prev = r
+    tok = signin() or tok

package/scripts/typedb-probes/panic-probe.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""Minimal reproducer: a \\uXXXX escape inside a TypeQL string literal PANICS
+TypeDB 3.8.3 and kills the server process.
+
+Each probe sends one write query and then reads the container's restart count.
+A rising restart count means that query killed the server, not that it errored.
+
+Usage: panic-probe.py [url]
+"""
+import json, subprocess, sys, time, urllib.request, urllib.error
+
+URL = sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:8000"
+DB = "paniclab"
+
+
+def restarts():
+    return subprocess.run(["docker", "inspect", "typedb", "--format", "{{.RestartCount}}"],
+                          capture_output=True, text=True).stdout.strip()
+
+
+def signin(tries=20):
+    for _ in range(tries):
+        try:
+            req = urllib.request.Request(URL + "/v1/signin", method="POST")
+            req.add_header("Content-Type", "application/json")
+            body = json.dumps({"username": "admin", "password": "password"}).encode()
+            with urllib.request.urlopen(req, body, timeout=5) as r:
+                return json.load(r)["token"]
+        except Exception:
+            time.sleep(1)
+    sys.exit("could not sign in")
+
+
+def send(tok, q, kind="write"):
+    req = urllib.request.Request(URL + "/v1/query", method="POST")
+    req.add_header("Content-Type", "application/json")
+    req.add_header("Authorization", "Bearer " + tok)
+    # ensure_ascii=False: the ESCAPE UNDER TEST must reach TypeQL as written,
+    # not be double-escaped by the JSON envelope.
+    body = json.dumps({"databaseName": DB, "transactionType": kind, "query": q},
+                      ensure_ascii=False).encode("utf-8")
+    try:
+        with urllib.request.urlopen(req, body, timeout=15) as r:
+            return str(r.status)
+    except urllib.error.HTTPError as e:
+        return str(e.code)
+    except Exception as e:
+        return f"DROPPED({type(e).__name__})"
+
+
+tok = signin()
+# fresh scratch db
+urllib.request.urlopen(urllib.request.Request(
+    URL + f"/v1/databases/{DB}", method="POST",
+    headers={"Authorization": "Bearer " + tok}), b"", timeout=15).read() if True else None
+send(tok, "define attribute note, value string; entity probe, owns note;", "schema")
+
+PROBES = [
+    ("ASCII literal",                  'insert $x isa probe, has note "plain ascii";'),
+    ("raw UTF-8 (e-acute, em-dash)",   'insert $x isa probe, has note "café — ok";'),
+    ("escaped quote",                  'insert $x isa probe, has note "she said \\"hi\\"";'),
+    ("\\uXXXX escape (e-acute)",       'insert $x isa probe, has note "caf\\u00e9";'),
+    ("\\uXXXX escape (control char)",  'insert $x isa probe, has note "bell\\u0007here";'),
+    ("ASCII again (did it recover?)",  'insert $x isa probe, has note "still alive";'),
+]
+
+print(f"  {'probe':38} {'http':16} restarts")
+before = restarts()
+print(f"  {'(baseline)':38} {'-':16} {before}")
+for name, q in PROBES:
+    code = send(tok, q)
+    time.sleep(4)          # let docker restart-policy settle before reading the count
+    r = restarts()
+    killed = " <-- SERVER KILLED" if r != before else ""
+    print(f"  {name:38} {code:16} {r}{killed}")
+    before = r
+    tok = signin()          # token dies with the process

package/scripts/typedb-scratch.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# typedb-scratch.sh — create (or refresh) a LOCAL scratch database carrying the
+# live `one` schema, for integration tests that must never touch `one`.
+#
+# Why this exists: `factory-check.sh belief-guard` runs a real-substrate test
+# (repo rule: never mock TypeDB) and needs TYPEDB_TEST_DB pointing at a database
+# that already has the schema — the test defines none of its own. Hand-building
+# that db is a step nobody remembers, and an empty db reports as `cannot run`, so
+# the check silently never proves anything.
+#
+# Usage:
+#   bash .claude/scripts/typedb-scratch.sh [name]     # default: belieftest
+#   export TYPEDB_TEST_DB=belieftest                  # then run the checks
+#
+# Refuses anything but a local substrate: this DROPS and recreates the database.
+set -uo pipefail
+ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
+NAME="${1:-belieftest}"
+
+if [ "$NAME" = "one" ]; then
+  echo "refusing: 'one' is the working database, not a scratch db" >&2; exit 2
+fi
+
+# An explicitly-exported TYPEDB_URL wins over .env. Without this the eval below
+# silently overwrites it, which makes the local-only guard untestable and means a
+# caller who thinks they are pointing somewhere else is not.
+_ENV_URL="${TYPEDB_URL:-}"
+eval "$(python3 - "$ROOT/one.ie/web/.env" <<'PY'
+import re,sys,shlex
+for line in open(sys.argv[1], errors="replace"):
+    m = re.match(r'^\s*(TYPEDB_(?:URL|DATABASE|USERNAME|PASSWORD))\s*=\s*(.*?)\s*$', line)
+    if m: print(f"{m.group(1)}={shlex.quote(m.group(2).strip(chr(34)+chr(39)))}")
+PY
+)"
+: "${TYPEDB_URL:=}" "${TYPEDB_DATABASE:=one}" "${TYPEDB_USERNAME:=admin}" "${TYPEDB_PASSWORD:=}"
+[ -n "$_ENV_URL" ] && TYPEDB_URL="$_ENV_URL"
+
+case "$TYPEDB_URL" in
+  *127.0.0.1*|*localhost*) ;;
+  *) echo "refusing: TYPEDB_URL is not local ($TYPEDB_URL). Run typedb-env.sh dev first." >&2; exit 2 ;;
+esac
+
+TOK=$(curl -s -m 15 -X POST "$TYPEDB_URL/v1/signin" -H 'Content-Type: application/json' \
+  -d "{\"username\":\"$TYPEDB_USERNAME\",\"password\":\"$TYPEDB_PASSWORD\"}" \
+  | python3 -c 'import sys,json;print(json.load(sys.stdin).get("token",""))' 2>/dev/null)
+[ -z "$TOK" ] && { echo "cannot run: local TypeDB signin failed at $TYPEDB_URL" >&2; exit 3; }
+
+SCHEMA=$(mktemp); trap 'rm -f "$SCHEMA" "$REQ"' EXIT
+curl -s -m 30 -H "Authorization: Bearer $TOK" "$TYPEDB_URL/v1/databases/$TYPEDB_DATABASE/schema" > "$SCHEMA"
+[ -s "$SCHEMA" ] || { echo "cannot run: could not read the $TYPEDB_DATABASE schema" >&2; exit 3; }
+
+curl -s -o /dev/null -X DELETE "$TYPEDB_URL/v1/databases/$NAME" -H "Authorization: Bearer $TOK"
+curl -s -o /dev/null -X POST   "$TYPEDB_URL/v1/databases/$NAME" -H "Authorization: Bearer $TOK"
+
+# ensure_ascii=False is load-bearing: json.dumps' default escapes non-ASCII to
+# \uXXXX, and a \uXXXX inside TypeQL PANICS TypeDB 3.8.3 — it kills the server
+# process rather than returning an error. See
+# text/typedb-production-problem-solutions.md § Two queries that kill a 3.8.3 server.
+REQ=$(mktemp)
+python3 - "$SCHEMA" "$NAME" > "$REQ" <<'PY'
+import json,sys
+print(json.dumps({"databaseName": sys.argv[2], "transactionType": "schema",
+                  "query": open(sys.argv[1]).read()}, ensure_ascii=False))
+PY
+RES=$(curl -s -m 60 -X POST "$TYPEDB_URL/v1/query" -H "Authorization: Bearer $TOK" \
+      -H 'Content-Type: application/json' --data-binary @"$REQ")
+
+case "$RES" in
+  *'"answerType":"ok"'*)
+    echo "scratch db '$NAME' ready — $(wc -c < "$SCHEMA" | tr -d ' ') chars of schema"
+    echo "  export TYPEDB_TEST_DB=$NAME" ;;
+  *) echo "failed to define schema in '$NAME': ${RES:0:300}" >&2; exit 1 ;;
+esac

package/scripts/urls-lint.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+# urls-lint.sh — shrink-only root lint (text/urls.md § reserved prefix set).
+#
+# one.ie's root-level src/pages/*.astro is frozen at the set below (verified
+# 2026-07-20). A new top-level page must be added to this allowlist by hand —
+# an amendment to the law, never a silent file drop. The set can only shrink
+# (a deletion needs no allowlist change); any file NOT on the list fails.
+set -euo pipefail
+
+PAGES_DIR="one.ie/web/src/pages"
+
+# The frozen baseline — every root .astro page that existed at promise-making,
+# grouped by text/urls-plan.md's route-classification buckets (platform /
+# console-slugless / identity / system / redirect-pending-deletion / dead).
+FROZEN_ROOT_PAGES=(
+  # platform — marketing/product
+  index pricing agents agency affiliates brand chatbots components contracts
+  crm-platform design developers "enterprise-license" "free-license" "get-yours"
+  join leaderboard license marketing "marketing-studio" marketplace models
+  partners playbook proof scale security showcase speed sui teams tools
+  upgrade "thankyou-playbook"
+  # console-slugless
+  dashboard settings analytics chat skills build create editor in memory
+  profile credits payments rewards tracking watch stream meet classroom
+  learning activity do cc device motion "self-improving"
+  # identity
+  signin signup recover "recovery-codes" "auth-security" unsubscribe
+  # system
+  404 500
+  # redirect — superseded, C4 deletes these; kept on the allowlist so the lint
+  # is green both before and after that deletion (shrinking, never growing)
+  "index-new" "index-open" home
+  # dead — unreferenced, flagged for a future lever-4 cycle, not this promise
+  dotsdemo
+)
+
+is_allowed() {
+  local name="$1"
+  for allowed in "${FROZEN_ROOT_PAGES[@]}"; do
+    [ "$name" = "$allowed" ] && return 0
+  done
+  return 1
+}
+
+fail=0
+for file in "$PAGES_DIR"/*.astro; do
+  [ -e "$file" ] || continue
+  base="$(basename "$file" .astro)"
+  if ! is_allowed "$base"; then
+    echo "urls-lint: FAIL — '$base.astro' is not on the frozen root allowlist (text/urls.md § reserved prefix set). Root can only shrink." >&2
+    fail=1
+  fi
+done
+
+if [ "$fail" -eq 0 ]; then
+  echo "urls-lint: OK — every root page is accounted for."
+fi
+exit "$fail"

package/scripts/w1-recon.ts

@@ -1,139 +1,6 @@
 #!/usr/bin/env bun
-/**
- * w1-recon.ts — W1 recon with Anthropic SDK prompt caching
- *
- * Caches the static rules + agent-prompt block so repeated W1 calls on the
- * same codebase skip re-tokenizing those layers (~1k tokens / call).
- * Also writes findings to .w1-cache/ (sha-keyed) so the next cycle is free.
- *
- * Usage:
- *   bun .claude/scripts/w1-recon.ts --targets <file,...> [--mode RECON|SURVEY|INVESTIGATE]
- *
- * Falls back gracefully: if ANTHROPIC_API_KEY is missing, exits 2 (caller uses Agent spawn).
- */
-
-import Anthropic from "@anthropic-ai/sdk";
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
-import { execFileSync } from "child_process";
-import { join } from "path";
-
-const SCRIPTS_DIR = new URL(".", import.meta.url).pathname;
-const AGENTS_DIR = join(SCRIPTS_DIR, "../agents");
-const RULES_DIR = join(SCRIPTS_DIR, "../rules");
-const CACHE_DIR = ".w1-cache";
-
-if (!process.env.ANTHROPIC_API_KEY) {
-  process.stderr.write("[w1-recon] no ANTHROPIC_API_KEY — falling back to agent spawn\n");
-  process.exit(2);
-}
-
-function parseArgs() {
-  const args = process.argv.slice(2);
-  const out = { targets: [] as string[], mode: "RECON" };
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--targets" && args[i + 1]) out.targets = args[++i].split(",").filter(Boolean);
-    if (args[i] === "--mode" && args[i + 1]) out.mode = args[++i].toUpperCase();
-  }
-  return out;
-}
-
-// Recon is read-only mapping — it needs the locked-rule vocabulary (engine) and
-// doc conventions, NOT the UI rules (astro/react/ui/design) that guide W3 edits.
-// Curating here cuts ~7k tokens of irrelevant context from every recon call AND
-// keeps the merged static block comfortably above Haiku's 4,096-token cache floor.
-const W1_RULES = ["engine.md", "documentation.md"];
-
-function loadRules(): string {
-  return W1_RULES
-    .map(f => join(RULES_DIR, f))
-    .filter(existsSync)
-    .map(p => readFileSync(p, "utf8"))
-    .join("\n\n---\n\n");
-}
-
-function loadAgentPrompt(): string {
-  const path = join(AGENTS_DIR, "w1-recon.md");
-  if (!existsSync(path)) return "";
-  return readFileSync(path, "utf8").replace(/^---[\s\S]*?---\n/, "").trim();
-}
-
-function fileSha(path: string): string {
-  try { return execFileSync("git", ["hash-object", path], { encoding: "utf8" }).trim(); }
-  catch { return ""; }
-}
-
-function checkCache(shas: string[]): string | null {
-  if (!existsSync(CACHE_DIR) || shas.some(s => !s)) return null;
-  const entries: string[] = [];
-  for (const sha of shas) {
-    const p = join(CACHE_DIR, `${sha}.json`);
-    if (!existsSync(p)) return null;
-    entries.push(readFileSync(p, "utf8"));
-  }
-  return entries.join("\n\n");
-}
-
-function writeCache(sha: string, findings: string) {
-  mkdirSync(CACHE_DIR, { recursive: true });
-  writeFileSync(join(CACHE_DIR, `${sha}.json`), findings);
-}
-
-async function main() {
-  const { targets, mode } = parseArgs();
-  if (!targets.length) { process.stderr.write("--targets required\n"); process.exit(1); }
-
-  const shas = targets.map(fileSha);
-  const hit = checkCache(shas);
-  if (hit) {
-    process.stderr.write(`[w1-recon] cache hit (${targets.length} file(s))\n`);
-    process.stdout.write(hit);
-    return;
-  }
-
-  const client = new Anthropic();
-  const rulesText = loadRules();
-  const agentPrompt = loadAgentPrompt();
-
-  const targetContents = targets
-    .map(t => {
-      try { return `### ${t}\n\`\`\`\n${readFileSync(t, "utf8").slice(0, 4000)}\n\`\`\``; }
-      catch { return `### ${t}\n[not found]`; }
-    })
-    .join("\n\n");
-
-  const improvements = existsSync(".w4-improvements.json")
-    ? `\n\n## Open improvements\n\`\`\`json\n${readFileSync(".w4-improvements.json", "utf8")}\n\`\`\``
-    : "";
-
-  // ONE merged cached block. Rules + agent prompt are both static, so a single
-  // breakpoint at the end caches the whole prefix. Splitting them would leave the
-  // ~1.4k-token agent block below Haiku's 4,096 cache floor — it would never cache.
-  const staticPrefix = [rulesText && `# Rules\n\n${rulesText}`, agentPrompt]
-    .filter(Boolean)
-    .join("\n\n---\n\n");
-  const system: Anthropic.TextBlockParam[] = [
-    { type: "text", text: staticPrefix, cache_control: { type: "ephemeral" } } as any,
-  ];
-
-  const res = await client.messages.create({
-    model: "claude-haiku-4-5-20251001",
-    max_tokens: 1024,
-    system: system as any,
-    messages: [{
-      role: "user",
-      content: `Mode: ${mode}\n\nTarget files:\n${targetContents}${improvements}\n\nProduce the findings report. Under 400 words. End with the W1 receipt line.`,
-    }],
-  });
-
-  const findings = res.content.filter(b => b.type === "text").map(b => (b as Anthropic.TextBlock).text).join("\n");
-
-  // Write to sha-keyed cache
-  shas.filter(Boolean).forEach(sha => writeCache(sha, findings));
-
-  const u = res.usage as any;
-  process.stderr.write(`[w1-recon] tokens in=${u.input_tokens} cache_write=${u.cache_creation_input_tokens ?? 0} cache_read=${u.cache_read_input_tokens ?? 0}\n`);
-
-  process.stdout.write(findings);
-}
-
-main().catch(e => { process.stderr.write(`[w1-recon] error: ${e}\n`); process.exit(1); });
+// w1-recon.ts — defers to Claude Code agent spawn (Max subscription path).
+// Direct SDK caching only matters on API billing; exit 2 sends the caller to
+// the Agent tool which uses the active Claude Code session.
+process.stderr.write("[w1-recon] using agent spawn\n");
+process.exit(2);