@oneie/claude 0.1.0

package/scripts/cc-connect.sh

@@ -0,0 +1,345 @@
+#!/usr/bin/env bash
+# cc-connect — Claude Code ↔ Claude Code messaging over the substrate.
+# SSE push (no client poll). Background listener writes to .cc-connect/<group>.jsonl.
+#
+# Multi-group: one local config holds your sender name + the groups you're
+# subscribed to. `listen` starts one SSE listener per group. `send`/`read`
+# default to your "default" group; pass --to / <group> to address another.
+#
+# Subcommands:
+#   init <sender> [group]              first-time setup
+#   join <group>                       subscribe + start its listener
+#   leave <group>                      stop listener + unsubscribe
+#   listen                             start a listener for every subscribed group
+#   stop [group]                       kill one listener (or all if no arg)
+#   status                             show config + listener state per group
+#   listeners                          list all running listener PIDs
+#   groups                             ask claw what groups exist (discovery)
+#   send [--to <group>] <text>         send to default (or specific) group
+#   read [<group>]                     show new messages since last read (one group)
+#   read --all                         merge new across every subscribed group
+#   (no args)                          = read default group
+#
+# Requires: bash, curl, jq.
+
+set -e
+
+CLAW_URL="${CLAW_URL:-https://claw.oneie.workers.dev}"
+if ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" && [ -n "$ROOT" ] && [ -d "$ROOT/.cc-connect" ]; then
+  DIR="$ROOT/.cc-connect"
+else
+  DIR="$HOME/.cc-connect"
+fi
+CFG="$DIR/config.json"
+
+mkdir -p "$DIR"
+
+# ─── config helpers ─────────────────────────────────────────────────────────
+
+cfg_read() {
+  [ -f "$CFG" ] && /bin/cat "$CFG" || /bin/echo '{}'
+}
+
+# Read sender; default $USER
+cfg_sender() {
+  cfg_read | jq -r '.sender // empty' 2>/dev/null | { read v; /bin/echo "${v:-$USER}"; }
+}
+
+# Read subscribed groups as a newline-separated list.
+# Back-compat: old config used `group: "x"`; new uses `groups: ["x", ...]`.
+cfg_groups() {
+  cfg_read | jq -r '
+    if .groups and (.groups | length > 0) then .groups[]
+    elif .group then .group
+    else "newco" end
+  ' 2>/dev/null
+}
+
+# Read default group (first in list if not set explicitly)
+cfg_default() {
+  cfg_read | jq -r '.default // .group // (.groups[0] // "newco")' 2>/dev/null
+}
+
+cfg_save() {
+  local sender="$1" default="$2"
+  shift 2
+  /bin/echo "$@" \
+    | jq -R 'split(" ") | map(select(length > 0))' \
+    | jq --arg s "$sender" --arg d "$default" \
+        '{sender: $s, default: $d, groups: .}' \
+    > "$CFG"
+}
+
+# ─── listener primitives (one per group) ───────────────────────────────────
+
+listener_pid_file() { /bin/echo "$DIR/$1.pid"; }
+listener_jsonl()    { /bin/echo "$DIR/$1.jsonl"; }
+listener_offset()   { /bin/echo "$DIR/$1.offset"; }
+
+listener_running() {
+  local pidf
+  pidf=$(listener_pid_file "$1")
+  [ -f "$pidf" ] && kill -0 "$(/bin/cat "$pidf" 2>/dev/null)" 2>/dev/null
+}
+
+listener_start() {
+  local group="$1"
+  local pidf jsonl last_ts_file
+  pidf=$(listener_pid_file "$group")
+  jsonl=$(listener_jsonl "$group")
+  last_ts_file="$DIR/$group.last_ts"
+  if listener_running "$group"; then
+    /bin/echo "  - $group already listening (pid=$(/bin/cat "$pidf"))"
+    return 0
+  fi
+  /usr/bin/touch "$jsonl"
+  [ -f "$(listener_offset "$group")" ] || /bin/echo 0 > "$(listener_offset "$group")"
+  # Seed last_ts file from the tail of the existing jsonl (or 0 for fresh).
+  # The outer loop re-reads this file each iteration so curl reconnects
+  # honour the latest ts — without this, the inner `| while` subshell drops
+  # the variable update and every reconnect replays the full backlog.
+  if [ ! -f "$last_ts_file" ]; then
+    /usr/bin/tail -n 1 "$jsonl" 2>/dev/null | jq -r '.ts // 0' 2>/dev/null > "$last_ts_file" \
+      || /bin/echo 0 > "$last_ts_file"
+  fi
+  (
+    while true; do
+      last_ts=$(/bin/cat "$last_ts_file" 2>/dev/null || /bin/echo 0)
+      [ -z "$last_ts" ] && last_ts=0
+      curl -N -sS --max-time 90 \
+        --header "Last-Event-ID: $last_ts" \
+        "$CLAW_URL/stream/$group?since=$last_ts" 2>/dev/null \
+      | while IFS= read -r line; do
+          case "$line" in
+            "data: "*)
+              payload="${line#data: }"
+              /bin/echo "$payload" >> "$jsonl"
+              new_ts=$(/bin/echo "$payload" | jq -r '.ts // empty' 2>/dev/null)
+              [ -n "$new_ts" ] && /bin/echo "$new_ts" > "$last_ts_file"
+              sender=$(/bin/echo "$payload" | jq -r '.sender // empty' 2>/dev/null)
+              snippet=$(/bin/echo "$payload" | jq -r '.content // empty' 2>/dev/null | /usr/bin/cut -c1-80)
+              [ -n "$sender" ] && osascript -e "display notification \"$snippet\" with title \"cc-connect · $group\" subtitle \"$sender\"" 2>/dev/null || true
+              ;;
+          esac
+        done
+      sleep 1
+    done
+  ) > /dev/null 2>&1 &
+  /bin/echo $! > "$pidf"
+  /bin/echo "  + $group listening (pid=$(/bin/cat "$pidf"))"
+}
+
+listener_stop() {
+  local group="$1"
+  local pidf
+  pidf=$(listener_pid_file "$group")
+  if [ -f "$pidf" ]; then
+    local pid
+    pid=$(/bin/cat "$pidf")
+    if [ -n "$pid" ]; then
+      pkill -P "$pid" 2>/dev/null || true
+      kill "$pid" 2>/dev/null || true
+    fi
+    /bin/rm -f "$pidf"
+    /bin/echo "  - $group stopped (pid=$pid)"
+  else
+    /bin/echo "  - $group not running"
+  fi
+}
+
+# ─── pretty print messages ─────────────────────────────────────────────────
+
+print_messages() {
+  local me="$1"
+  jq -r --arg me "$me" '
+    def t: (.ts / 1000 | strftime("%H:%M:%S"));
+    if (.group | length > 0) then
+      "[\(t)] \(.group) · \(.sender) → \(if .sender == $me then "(you)" else $me end): \(.content)"
+    else
+      "[\(t)] \(.sender) → \(if .sender == $me then "(you)" else $me end): \(.content)"
+    end
+  '
+}
+
+# ─── dispatch ──────────────────────────────────────────────────────────────
+
+SENDER="$(cfg_sender)"
+DEFAULT="$(cfg_default)"
+
+cmd="${1:-read}"
+shift 2>/dev/null || true
+
+case "$cmd" in
+  init)
+    s="${1:-$USER}"
+    g="${2:-newco}"
+    cfg_save "$s" "$g" "$g"
+    /bin/echo "ok  sender=$s  default=$g  groups=[$g]  config=$CFG"
+    ;;
+
+  join)
+    g="${1:?usage: cc-connect join <group>}"
+    cur=$(cfg_groups | /usr/bin/tr '\n' ' ')
+    if /bin/echo " $cur " | /usr/bin/grep -q " $g "; then
+      /bin/echo "ok  already subscribed to $g"
+    else
+      cfg_save "$SENDER" "$DEFAULT" "$cur $g"
+      /bin/echo "ok  joined $g  (groups now: $(cfg_groups | /usr/bin/tr '\n' ' '))"
+    fi
+    listener_start "$g"
+    ;;
+
+  leave)
+    g="${1:?usage: cc-connect leave <group>}"
+    new=$(cfg_groups | /usr/bin/grep -v "^$g$" | /usr/bin/tr '\n' ' ')
+    new_default="$DEFAULT"
+    [ "$DEFAULT" = "$g" ] && new_default=$(/bin/echo "$new" | /usr/bin/awk '{print $1}')
+    [ -z "$new_default" ] && new_default="$g"
+    cfg_save "$SENDER" "$new_default" "$new"
+    listener_stop "$g"
+    /bin/echo "ok  left $g  (default=$new_default)"
+    ;;
+
+  listen)
+    while IFS= read -r g; do
+      [ -n "$g" ] && listener_start "$g"
+    done < <(cfg_groups)
+    ;;
+
+  stop)
+    g="${1:-}"
+    if [ -n "$g" ]; then
+      listener_stop "$g"
+    else
+      while IFS= read -r grp; do
+        [ -n "$grp" ] && listener_stop "$grp"
+      done < <(cfg_groups)
+    fi
+    ;;
+
+  status)
+    /bin/echo "sender=$SENDER  default=$DEFAULT"
+    /bin/echo "subscribed groups:"
+    while IFS= read -r g; do
+      [ -z "$g" ] && continue
+      jsonl=$(listener_jsonl "$g")
+      total=0
+      [ -f "$jsonl" ] && total=$(/usr/bin/wc -l < "$jsonl" | /usr/bin/tr -d ' ')
+      off=0
+      [ -f "$(listener_offset "$g")" ] && off=$(/bin/cat "$(listener_offset "$g")" 2>/dev/null | /usr/bin/tr -d ' ')
+      [ -z "$off" ] && off=0
+      unread=$((total - off))
+      if listener_running "$g"; then
+        live="pid=$(/bin/cat "$(listener_pid_file "$g")")"
+      else
+        live="not running"
+      fi
+      /bin/echo "  $g  total=$total  unread=$unread  listener=$live"
+    done < <(cfg_groups)
+    ;;
+
+  listeners)
+    while IFS= read -r g; do
+      [ -z "$g" ] && continue
+      if listener_running "$g"; then
+        /bin/echo "  $g  pid=$(/bin/cat "$(listener_pid_file "$g")")"
+      fi
+    done < <(cfg_groups)
+    ;;
+
+  groups)
+    /bin/echo "claw says:"
+    curl -s "$CLAW_URL/groups" -m 5 \
+      | jq -r '.groups[] | "  \(.id)  msgs=\(.message_count)  last=\(.last_sender // "—"): \((.last_content // "")[0:60])"' \
+      || /bin/echo "  (could not reach claw)"
+    /bin/echo "you are subscribed to:"
+    cfg_groups | /usr/bin/sed 's/^/  /'
+    ;;
+
+  send)
+    # send [--to <group>] <text...>  (--group is an alias for --to; flag can appear anywhere)
+    target="$DEFAULT"
+    args=()
+    while [ $# -gt 0 ]; do
+      case "$1" in
+        --to|--group)
+          target="${2:?usage: cc-connect send --to <group> <text>}"
+          shift 2
+          ;;
+        *)
+          args+=("$1")
+          shift
+          ;;
+      esac
+    done
+    text="${args[*]}"
+    [ -z "$text" ] && { /bin/echo "error  usage: cc-connect send [--to <group>] <text>"; exit 1; }
+    body=$(jq -n --arg s "$SENDER" --arg c "$text" '{sender: $s, content: $c}')
+    resp=$(curl -s -X POST "$CLAW_URL/signal/$target" \
+      -H 'Content-Type: application/json' \
+      -d "$body")
+    /bin/echo "ok  →$target  $resp"
+    ;;
+
+  read)
+    target="$DEFAULT"
+    all=false
+    if [ "$1" = "--all" ]; then
+      all=true
+    elif [ -n "$1" ]; then
+      target="$1"
+    fi
+    # auto-start listeners if not running
+    if $all; then
+      while IFS= read -r g; do
+        [ -n "$g" ] && ! listener_running "$g" && listener_start "$g" >/dev/null 2>&1
+      done < <(cfg_groups)
+    else
+      ! listener_running "$target" && listener_start "$target" >/dev/null 2>&1
+    fi
+    if $all; then
+      # Merge new across all subscribed groups, sort by ts
+      tmp=$(/usr/bin/mktemp)
+      while IFS= read -r g; do
+        [ -z "$g" ] && continue
+        jsonl=$(listener_jsonl "$g")
+        [ -f "$jsonl" ] || continue
+        total=$(/usr/bin/wc -l < "$jsonl" | /usr/bin/tr -d ' ')
+        off=$(/bin/cat "$(listener_offset "$g")" 2>/dev/null | /usr/bin/tr -d ' ')
+        [ -z "$off" ] && off=0
+        if [ "$total" -gt "$off" ]; then
+          new=$((total - off))
+          /usr/bin/tail -n "$new" "$jsonl" | jq -c --arg g "$g" '. + {group: $g}' >> "$tmp"
+          /bin/echo "$total" > "$(listener_offset "$g")"
+        fi
+      done < <(cfg_groups)
+      if [ -s "$tmp" ]; then
+        /usr/bin/sort -t '"' -k '6' "$tmp" 2>/dev/null | print_messages "$SENDER"
+      else
+        /bin/echo "ok  no new messages across $(cfg_groups | /usr/bin/wc -l | /usr/bin/tr -d ' ') groups (you=$SENDER)"
+      fi
+      /bin/rm -f "$tmp"
+    else
+      jsonl=$(listener_jsonl "$target")
+      offset=$(listener_offset "$target")
+      /usr/bin/touch "$jsonl"
+      [ -f "$offset" ] || /bin/echo 0 > "$offset"
+      total=$(/usr/bin/wc -l < "$jsonl" | /usr/bin/tr -d ' ')
+      off=$(/bin/cat "$offset" 2>/dev/null | /usr/bin/tr -d ' ')
+      [ -z "$off" ] && off=0
+      [ -z "$total" ] && total=0
+      if [ "$total" -le "$off" ]; then
+        /bin/echo "ok  no new messages in $target  (you=$SENDER  total=$total)"
+        exit 0
+      fi
+      new=$((total - off))
+      /usr/bin/tail -n "$new" "$jsonl" | jq -c --arg g "$target" '. + {group: $g}' | print_messages "$SENDER"
+      /bin/echo "$total" > "$offset"
+    fi
+    ;;
+
+  *)
+    /bin/echo "usage: cc-connect {init|join|leave|listen|stop|status|listeners|groups|send|read}"
+    exit 1
+    ;;
+esac

package/scripts/do-analyze.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# do-analyze.sh — ANALYZE coverage gate (ex-Spec-Kit /analyze), read-only. Run at the
+# todo→code boundary, BEFORE build spends worktree tokens. Builds the D#↔C# coverage matrix
+# and the AC→test check. CRITICAL (uncovered deliverable) → exit 1, blocks build. Never edits.
+# Usage:  do-analyze.sh <todo.md>
+set -euo pipefail
+todo="${1:?usage: do-analyze.sh <todo.md>}"
+[ -f "$todo" ] || { echo "CRITICAL: todo not found: $todo"; exit 1; }
+
+crit=0; high=0
+
+# 1. coverage: every deliverable line (- D#) must cite at least one cycle (C#)
+uncovered=0
+while IFS= read -r line; do
+  did=$(printf '%s' "$line" | grep -oE 'D[0-9]+' | head -1)
+  if ! printf '%s' "$line" | grep -qE 'C[0-9]+'; then
+    echo "CRITICAL: $did maps to no cycle"; crit=1; uncovered=$((uncovered+1))
+  fi
+done < <(grep -E '^[[:space:]]*- D[0-9]+ ' "$todo")
+
+ndel=$(grep -cE '^[[:space:]]*- D[0-9]+ ' "$todo" || true)
+ncyc=$(grep -cE '^## C[0-9]+ ' "$todo" || true)
+
+# 2. orphan cycles: every ## C# section should be cited by some deliverable
+cited=$(grep -oE 'C[0-9]+' "$todo" | sort -u)
+for c in $(grep -oE '^## C[0-9]+ ' "$todo" | grep -oE 'C[0-9]+'); do
+  # a cycle is cited if it appears outside its own header (i.e. in a deliverable line)
+  hits=$(grep -E "^[[:space:]]*- D[0-9]+ .*\b$c\b" "$todo" | wc -l | tr -d ' ')
+  [ "$hits" -eq 0 ] && { echo "HIGH: cycle $c has no deliverable (orphan)"; high=$((high+1)); }
+done
+
+# 3. AC→test: every cycle section should carry a demo: line (DoD row 2, planned half)
+nodemo=0
+for c in $(grep -oE '^## C[0-9]+ ' "$todo" | grep -oE 'C[0-9]+'); do
+  block=$(awk "/^## $c /{f=1} f&&/^## C[0-9]+ /&&!/^## $c /{if(seen)exit} {if(f)print; if(/^## $c /)seen=1}" "$todo")
+  printf '%s' "$block" | grep -qiE 'demo:' || { echo "HIGH: $c has no planned test (demo: line)"; high=$((high+1)); nodemo=$((nodemo+1)); }
+done
+
+echo "----"
+echo "coverage: $ndel deliverables / $ncyc cycles · uncovered=$uncovered · no-demo=$nodemo · high=$high"
+if [ "$crit" -ne 0 ]; then echo "ANALYZE: CRITICAL — fix coverage before build"; exit 1; fi
+echo "ANALYZE: pass (coverage 100%)"; exit 0

package/scripts/do-folder.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# do-folder.sh — resolve target repo folder(s) from a changed-file list and emit each
+# folder's verify/build commands. There is NO root package.json by design: every top
+# folder under one-ie/ is its own buildable repo. /do W0/W4 use this instead of a root
+# `bun run verify`. Doc-only cycles (.md / .claude / plans / text / docs) skip bun entirely.
+#
+# Usage:  do-folder.sh <path>...        |   git diff --name-only | do-folder.sh
+# Output: one JSON object per resolved folder (or a single doc_only line):
+#   {"folder":"one.ie/web","verify":"bun run verify","build":"bun run build","doc_only":false}
+#   {"folder":null,"verify":null,"build":null,"doc_only":true}
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"   # .claude/scripts -> one-ie root
+
+# 1. gather paths from args or stdin
+paths=()
+if [ "$#" -gt 0 ]; then
+  paths=("$@")
+else
+  while IFS= read -r line; do [ -n "$line" ] && paths+=("$line"); done
+fi
+[ "${#paths[@]}" -eq 0 ] && { echo '{"folder":null,"verify":null,"build":null,"doc_only":true}'; exit 0; }
+
+# 2. doc-only = every path is markdown or lives in a non-built dir
+doc_only=true
+for p in "${paths[@]}"; do
+  case "$p" in
+    *.md|.claude/*|plans/*|text/*|docs/*) ;;
+    *) doc_only=false ;;
+  esac
+done
+if $doc_only; then
+  echo '{"folder":null,"verify":null,"build":null,"doc_only":true}'
+  exit 0
+fi
+
+# 3. longest-prefix match against known buildable folders (one.ie/web BEFORE one.ie).
+#    bash 3.2-safe (macOS): no associative arrays — dedup a newline list with sort -u.
+folders="one.ie/web one.ie packages agents api schema sync backup"
+matched=""
+for p in "${paths[@]}"; do
+  for f in $folders; do
+    case "$p" in "$f"/*) matched="${matched}${f}
+"; break;; esac
+  done
+done
+matched=$(printf '%s' "$matched" | sed '/^$/d' | sort -u)
+
+if [ -z "$matched" ]; then
+  echo '{"folder":null,"verify":null,"build":null,"doc_only":false,"reason":"unmapped"}'
+  exit 0
+fi
+
+# 4. emit per folder, reading its own package.json for the script names
+printf '%s\n' "$matched" | while IFS= read -r f; do
+  pj="$ROOT/$f/package.json"
+  verify="null"; build="null"
+  if [ -f "$pj" ]; then
+    jq -e '.scripts.verify' "$pj" >/dev/null 2>&1 && verify='"bun run verify"'
+    jq -e '.scripts.build'  "$pj" >/dev/null 2>&1 && build='"bun run build"'
+  fi
+  printf '{"folder":"%s","verify":%s,"build":%s,"doc_only":false}\n' "$f" "$verify" "$build"
+done

package/scripts/do-prove.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# do-prove.sh — PROVE (P5). Auto-detect the surface from the changed files and emit the proof
+# action; optional promise-check vs the P0 copy. The shipped thing must let the user do what the
+# promise said. Exit 1 only on a clear over-promise (artifact mentions none of the promise terms).
+# Usage:  do-prove.sh [--promise text/<f>.md] <changed-path>...
+set -euo pipefail
+
+promise=""
+if [ "${1:-}" = "--promise" ]; then promise="$2"; shift 2; fi
+
+paths=()
+if [ "$#" -gt 0 ]; then paths=("$@"); else while IFS= read -r l; do [ -n "$l" ] && paths+=("$l"); done; fi
+[ "${#paths[@]}" -eq 0 ] && { echo "PROVE: no changes"; exit 0; }
+
+# surface detect — substrate wins (upstream), then api, then frontend, else backend
+surface=backend
+for p in "${paths[@]}"; do
+  case "$p" in
+    *.tql|schema/*) surface=substrate; break ;;
+    */pages/api/*|*/api/*) surface=api ;;
+    *.astro|*.tsx) [ "$surface" != "api" ] && surface=frontend ;;
+  esac
+done
+
+case "$surface" in
+  frontend)  proof="/browser (real Chrome: HTTP + JS/console errors + rail before/after + screenshot) + Lighthouse" ;;
+  api)       proof="contract test (vitest+msw) + curl per surface — route + SDK + MCP + CLI (four-surface rule)" ;;
+  backend)   proof="curl against the DEPLOYED runtime (local verify is necessary, not sufficient)" ;;
+  substrate) proof="/sync reconcile (TypeDB↔KV↔D1↔SUI) + TypeQL returns the new shape + types compile downhill" ;;
+esac
+echo "surface: $surface"
+echo "proof:   $proof"
+
+# promise-check: at least one substantive term from the P0 copy must appear in the shipped files
+if [ -n "$promise" ] && [ -f "$promise" ]; then
+  # drop code keywords + generic verbs so the check keys on domain terms, not coincidences
+  stop='export|function|return|const|class|import|async|await|value|string|number|default|users|allow|enable|create|update|delete|where|which|their'
+  terms=$(grep -oiE '[a-z]{5,}' "$promise" | tr 'A-Z' 'a-z' | sort -u | grep -vwE "$stop" | head -40)
+  hit=0
+  for t in $terms; do
+    for p in "${paths[@]}"; do
+      if [ -f "$p" ] && grep -qi "$t" "$p" 2>/dev/null; then hit=1; break 2; fi
+    done
+  done
+  if [ "$hit" -eq 0 ]; then
+    echo "PROMISE-CHECK: FAIL — shipped artifact mentions none of the promise's terms (over-promise → back to P4 or re-FRAME)"
+    exit 1
+  fi
+  echo "PROMISE-CHECK: ok"
+fi
+echo "PROVE: pass"; exit 0

package/scripts/do-reconcile.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# do-reconcile.sh — substrate reconciliation gate (P1.0). Reads a proposal (files or stdin
+# text) and FAILS (exit 1) on a dead name or a proposed new dimension/verb. The schema is
+# truth: a feature that needs a new dim/verb is rejected before any design spend.
+# Usage:  do-reconcile.sh <file|text>...   |   echo "proposal" | do-reconcile.sh
+set -euo pipefail
+
+# Locked vocabulary (root CLAUDE.md). Dead names auto-fail.
+DEAD="knowledge connections node scent alarm trail colony"
+DIMS="groups actors things paths events learning"
+VERBS="signal mark warn fade follow harden"
+
+text=""
+if [ "$#" -gt 0 ]; then
+  for a in "$@"; do if [ -f "$a" ]; then text="$text $(cat "$a")"; else text="$text $a"; fi; done
+else
+  text="$(cat)"
+fi
+
+fail=0
+for d in $DEAD; do
+  if printf '%s' "$text" | grep -qiw "$d"; then
+    echo "DEAD-NAME: '$d' — use the canonical term (dims: $DIMS)"; fail=1
+  fi
+done
+
+if [ "$fail" -ne 0 ]; then echo "RECONCILE: FAIL (dead name)"; exit 1; fi
+echo "RECONCILE: clean — names canonical, no new dim/verb"; exit 0

package/scripts/do-smoke.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# do-smoke.sh — deterministic outcome gate for the /do upgrade. Drives fixtures through every
+# helper + the state-file schemas + the seed lifecycle. Exits 0 only if ALL pass. The LLM
+# phase-sequencing itself is proven by a logged canary `/do <idea>` run, NOT by this script
+# (a bash script cannot drive Claude — see plans/do-loop-todo.md outcome contract).
+set -uo pipefail
+cd "$(dirname "${BASH_SOURCE[0]}")/../.." || exit 2
+S=.claude/scripts
+fail=0
+ok(){ printf '  \xe2\x9c\x93 %s\n' "$1"; }
+no(){ printf '  \xe2\x9c\x97 %s\n' "$1"; fail=1; }
+
+echo "== C0 do-folder =="
+"$S/do-folder.sh" one.ie/web/src/x.ts | grep -q '"folder":"one.ie/web"' && ok "web file → folder" || no "web file"
+"$S/do-folder.sh" .claude/commands/do.md plans/x.md | grep -q '"doc_only":true' && ok "doc-only → skip" || no "doc-only"
+
+echo "== C7 do-tier =="
+"$S/do-tier.sh" text/x.md | grep -q '"tier":"PATCH"' && ok "typo → PATCH" || no "PATCH"
+"$S/do-tier.sh" schema/one.tql | grep -q '"tier":"SCHEMA"' && ok ".tql → SCHEMA" || no "SCHEMA"
+"$S/do-tier.sh" --intent "add billing" one.ie/web/src/api/b.ts | grep -q '"tier":"FEATURE"' && ok "intent → FEATURE" || no "FEATURE"
+
+echo "== C10 do-reconcile =="
+echo "uses a node in the colony" | "$S/do-reconcile.sh" >/dev/null 2>&1 && no "dead name should fail" || ok "dead name → exit 1"
+echo "signal a mark on a path" | "$S/do-reconcile.sh" >/dev/null 2>&1 && ok "canonical → exit 0" || no "canonical should pass"
+
+echo "== C9 do-survey =="
+"$S/do-survey.sh" zxqwfoobar 2>/dev/null | grep -q 'VERDICT: build' && ok "novel → build" || no "novel"
+"$S/do-survey.sh" signal 2>/dev/null | grep -qE 'VERDICT: (extend|expose)' && ok "existing → extend/expose" || no "existing"
+
+echo "== C14 do-analyze =="
+"$S/do-analyze.sh" plans/do-loop-todo.md >/dev/null 2>&1 && ok "this plan → 100% coverage" || no "plan coverage"
+tmp=$(mktemp); printf 'deliverables:\n  - D1 x (C1)\n  - D2 orphan no cycle\n## C1 — y\n' > "$tmp"
+"$S/do-analyze.sh" "$tmp" >/dev/null 2>&1 && no "uncovered should fail" || ok "uncovered deliverable → CRITICAL exit 1"; rm -f "$tmp"
+
+echo "== C11 do-prove =="
+pv=$("$S/do-prove.sh" one.ie/web/src/components/X.tsx 2>/dev/null); echo "$pv" | grep -q 'surface: frontend' && ok "frontend → /browser" || no "frontend"
+pm=$(mktemp); art=$(mktemp); echo "users export revenue analytics" > "$pm"; echo "function foo(){}" > "$art"
+"$S/do-prove.sh" --promise "$pm" "$art" >/dev/null 2>&1 && no "over-promise should fail" || ok "over-promise → exit 1"; rm -f "$pm" "$art"
+
+echo "== state-file schemas =="
+echo '{"diff_specs":[{"current_state":"x","must_not_break":"y","serves":"D1"}]}' | jq -e '.diff_specs[0]|.current_state and .must_not_break and .serves' >/dev/null && ok ".w2-spec context pack" || no ".w2-spec"
+echo '{"renames":[],"touched_docs":[],"contract_dirs":[]}' | jq -e 'has("renames") and has("touched_docs") and has("contract_dirs")' >/dev/null && ok ".w2-doc-plan" || no ".w2-doc-plan"
+echo '{"level":"standard","consecutive":1,"composite":0.78,"updated":"t"}' | jq -e '.level and (.composite|type=="number")' >/dev/null && ok ".do-trust" || no ".do-trust"
+echo '{"receiver":"cost:cycle","data":{"tokens":{"input":1},"model":"sonnet","composite":0.7}}' | jq -e '.receiver=="cost:cycle" and .data.model' >/dev/null && ok "cost:cycle grammar" || no "cost:cycle"
+
+echo "== /do-loop removed (single front door) =="
+# scan commands+agents only (the engine surface); the 'no separate' note is the lone allowed mention
+if grep -rn '/do-loop' .claude/commands .claude/agents 2>/dev/null | grep -vq 'no separate'; then no "/do-loop still referenced"; else ok "/do-loop gone (only the 'no separate' note)"; fi
+[ -f .claude/commands/do-lifecycle.md ] && ok "do-lifecycle.md is the spec" || no "do-lifecycle.md missing"
+
+echo "== C5 seed lifecycle (one.ie/web vitest) =="
+if command -v bunx >/dev/null 2>&1; then
+  ( cd one.ie/web && bunx vitest run tests/unit/substrate-seed-c5.test.ts >/dev/null 2>&1 ) && ok "seed→promote→fade (4/4)" || no "seed lifecycle test"
+else
+  echo "  ~ bunx not found — seed test skipped (run in one.ie/web)"
+fi
+
+echo "----"
+if [ "$fail" -ne 0 ]; then echo "do-smoke: FAIL"; exit 1; fi
+echo "do-smoke: PASS — deterministic substrate green. (LLM loop: run a canary /do <idea> and log it.)"; exit 0

package/scripts/do-survey.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# do-survey.sh — P0.5 SURVEY. Grep the 4 surfaces + plans/ for an existing ≥70% match so
+# /do stops rebuilding what already ships. Emits a simplicity verdict. (The cheapest feature
+# is the one you already have.) Always exits 0 — it informs, it doesn't gate.
+# Usage:  do-survey.sh <keyword>
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+q="${1:?usage: do-survey.sh <keyword>}"
+
+surfaces="one.ie/web/src/pages/api one.ie/web/src/components packages/sdk agents plans"
+total=0
+for d in $surfaces; do
+  if [ -d "$ROOT/$d" ]; then
+    n=$( { grep -rilw "$q" "$ROOT/$d" 2>/dev/null || true; } | wc -l | tr -d ' ')
+  else
+    n=0
+  fi
+  printf '  %-28s %s match(es)\n' "$d" "$n"
+  total=$((total + n))
+done
+
+echo "----"
+if [ "$total" -ge 3 ]; then
+  echo "VERDICT: expose/extend — $total existing matches; reuse, do not rebuild (collapse to FIX tier)"
+elif [ "$total" -ge 1 ]; then
+  echo "VERDICT: extend — $total match; add a field/slot to what exists"
+else
+  echo "VERDICT: build — no existing match for '$q'"
+fi
+exit 0

package/scripts/do-tier.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# do-tier.sh — the token-economy spine-pruner. Infer the loop tier from the changed files
+# (+ optional --intent) and emit the pruned spine, the inner classifier, and a per-tier
+# token ceiling. The human never picks: this one signal sizes both outer and inner work.
+# DEFAULT DOWN when unsure — an under-built FIX re-opens cheaply; an over-built PATCH is burnt.
+# Usage:  do-tier.sh [--intent "text"] <path>...   |   git diff --name-only | do-tier.sh [--intent ...]
+set -euo pipefail
+
+intent=""
+if [ "${1:-}" = "--intent" ]; then intent="$2"; shift 2; fi
+
+paths=()
+if [ "$#" -gt 0 ]; then paths=("$@"); else while IFS= read -r l; do [ -n "$l" ] && paths+=("$l"); done; fi
+[ "${#paths[@]}" -eq 0 ] && paths=("")
+
+n=${#paths[@]}
+schema=false; code=false; doconly=true
+for p in "${paths[@]}"; do
+  case "$p" in
+    *.tql|schema/*) schema=true; code=true; doconly=false ;;
+    *.md|.claude/*|plans/*|text/*|docs/*) ;;
+    "") ;;
+    *) code=true; doconly=false ;;
+  esac
+done
+
+# tier inference — first match wins, biased downward
+if $schema; then tier=SCHEMA
+elif printf '%s' "$intent" | grep -qiE '\b(add|new|introduce|build a|feature|capability)\b'; then tier=FEATURE
+elif $doconly && [ "$n" -le 2 ]; then tier=PATCH
+elif ! $code && [ "$n" -le 2 ]; then tier=PATCH
+elif ! $code; then tier=FIX
+else tier=FIX
+fi
+
+case "$tier" in
+  PATCH)   spine="code verify";                                            cls=TRIVIAL; ceil=5000 ;;
+  FIX)     spine="survey code tests proof";                               cls=SIMPLE;  ceil=30000 ;;
+  FEATURE) spine="promise survey spec clarify todo analyze code tests proof docs release"; cls=COMPLEX; ceil=150000 ;;
+  SCHEMA)  spine="promise survey spec reconcile clarify todo analyze code tests proof docs release"; cls=COMPLEX; ceil=200000 ;;
+esac
+
+printf '{"tier":"%s","spine":"%s","classifier":"%s","ceiling_tokens":%s}\n' "$tier" "$spine" "$cls" "$ceil"