@oneie/claude 0.6.0 → 0.7.0

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/w4-rubric.ts

@@ -1,5 +1,15 @@
 #!/usr/bin/env bun
-// w4-rubric.ts — real rubric judge for /do W4.
+// w4-rubric.ts — the TASK rubric judge (5 axes, no goal-fit).
+//
+// This computes the `task` rubric, NOT the in-cycle W4 cycle gate. The two are
+// different by design: a diff handed to this script carries no plan context, so
+// goal-fit cannot be scored here. The cycle gate adds goal-fit at 0.30 and gates
+// on it at >= 0.50 — see .claude/commands/do.md § W4. Its output is labelled
+// `task-composite` so it can never be read as a cycle verdict.
+//
+// Weights and axis definitions come from rubric-weights.json — the single
+// source. Do not restate them here.
+//
 // Usage: w4-rubric.ts [edge] [--self-test] [--gate 0.65]
 // Reads diff from stdin. Exits 0=pass, 1=fail, 2=defer-to-agent.
 import { readFileSync, existsSync } from 'fs'
@@ -7,30 +17,76 @@ import { readFileSync, existsSync } from 'fs'
 const args = process.argv.slice(2)
 const selfTest = args.includes('--self-test')
 const edge = args.find(a => !a.startsWith('--')) ?? (process.env.DO_SLUG ? `do/${process.env.DO_SLUG}` : 'do/unknown')
-const gate = parseFloat(args.find(a => a.startsWith('--gate='))?.slice(7) ?? '0.65')
+
+// The weights file sits beside this script. A missing or malformed file is a
+// hard failure, never a fallback to inlined numbers — a silent divergence
+// between the file and a hardcoded copy is the exact drift this file removes.
+const WEIGHTS_PATH = new URL('./rubric-weights.json', import.meta.url).pathname
+type Rubric = {
+  gate: number
+  task: { weights: Record<string, number> }
+  definitions: Record<string, string>
+}
+function loadRubric(): Rubric {
+  try {
+    return JSON.parse(readFileSync(WEIGHTS_PATH, 'utf8')) as Rubric
+  } catch (e) {
+    process.stderr.write(`[w4-rubric] cannot read ${WEIGHTS_PATH}: ${(e as Error).message}\n`)
+    process.exit(1)
+    throw e // unreachable — process.exit never returns; satisfies the checker without @types/node
+  }
+}
+const RUBRIC = loadRubric()
+const W = RUBRIC.task.weights
+const AXES = Object.keys(W)
+const wSum = AXES.reduce((n, k) => n + W[k], 0)
+if (Math.abs(wSum - 1) > 1e-9) {
+  process.stderr.write(`[w4-rubric] task weights sum to ${wSum}, not 1.00 — refusing to score\n`)
+  process.exit(1)
+}
+
+const gate = parseFloat(args.find(a => a.startsWith('--gate='))?.slice(7) ?? String(RUBRIC.gate))
 // integration is deterministic when the caller knows it (W4 computes it from
 // .w2-surface-checklist.json + do-reconcile.sh sdk|navigation|docs and passes
 // --integration=0.NN); only when absent does the LLM score it from the diff.
 const integrationArg = args.find(a => a.startsWith('--integration='))?.slice(14)
-const W = { security: 0.30, stability: 0.25, simplicity: 0.20, integration: 0.15, speed: 0.10 }
 
 function composite(s: Record<string,number>) {
-  return s.security*W.security + s.stability*W.stability + s.simplicity*W.simplicity + s.integration*W.integration + s.speed*W.speed
+  return AXES.reduce((n, k) => n + s[k] * W[k], 0)
 }
 
+// --self-test vectors. `pass` is the historical fixture; `fail` exists so the
+// gate can be shown going RED. A gate that has only ever been observed passing
+// is indistinguishable from a gate that cannot fail.
+const SELF_TEST_SCORES: Record<string, number> =
+  { security: 0.90, stability: 1.00, simplicity: 0.80, integration: 0.85, speed: 0.75 }
+const SELF_TEST_FAIL: Record<string, number> =
+  { security: 0.40, stability: 0.40, simplicity: 0.40, integration: 0.40, speed: 0.40 }
+
 async function judge(diff: string): Promise<Record<string,number>> {
-  const envFile = process.env.DO_ENV_FILE ?? 'one.ie/web/.env'
+  const envFile = process.env.ONE_ENV_FILE ?? process.env.DO_ENV_FILE ?? 'one.ie/web/.env'
   let key = process.env.OPENROUTER_API_KEY ?? ''
   if (!key && existsSync(envFile)) {
     const m = readFileSync(envFile,'utf8').split('\n').find(l => l.startsWith('OPENROUTER_API_KEY='))
     if (m) key = m.slice(m.indexOf('=')+1).replace(/^["']|["']$/g,'')
   }
   if (!key) { process.stderr.write('[w4-rubric] no OPENROUTER_API_KEY — deferring\n'); process.exit(2) }
-  const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+  const gwAccount = process.env.CF_AI_GATEWAY_ACCOUNT_ID
+  const gwId = process.env.CF_AI_GATEWAY_ID
+  const orBase = gwAccount && gwId
+    ? `https://gateway.ai.cloudflare.com/v1/${gwAccount}/${gwId}/openrouter`
+    : 'https://openrouter.ai/api/v1'
+  const res = await fetch(`${orBase}/chat/completions`, {
     method:'POST', headers:{'Authorization':`Bearer ${key}`,'Content-Type':'application/json'},
     body:JSON.stringify({ model:'anthropic/claude-haiku-4-5', max_tokens:80,
       messages:[
-        {role:'system',content:'Score this diff on security/stability/simplicity/integration/speed (0-1). integration = the change is wired into its surroundings (imports/exports used, routes registered, links added, docs synced), not orphaned. JSON only: {"security":0.9,"stability":0.8,"simplicity":0.7,"integration":0.8,"speed":0.8}'},
+        // Every axis carries its definition from rubric-weights.json. An axis
+        // scored without one is scored against whatever the model invents that
+        // run — `stability` carried 0.25 weight undefined until 2026-08-02.
+        {role:'system',content:
+          `Score this diff on ${AXES.join('/')} (0-1). Definitions:\n`
+          + AXES.map(k => `- ${k}: ${RUBRIC.definitions[k] ?? '(UNDEFINED — score 0 and say so)'}`).join('\n')
+          + `\nJSON only, exactly these keys: {${AXES.map(k => `"${k}":0.8`).join(',')}}`},
         {role:'user',content:diff.slice(0,3000)}
       ]})
   })
@@ -39,21 +95,49 @@ async function judge(diff: string): Promise<Record<string,number>> {
   if (!m2) { process.stderr.write('[w4-rubric] bad LLM response — deferring\n'); process.exit(2) }
   const d = JSON.parse(m2[0]) as Record<string,unknown>
   const c = (v:unknown) => Math.max(0, Math.min(1, Number(v)||0))
-  return { security:c(d.security), stability:c(d.stability), simplicity:c(d.simplicity), integration:c(d.integration), speed:c(d.speed) }
+  // An axis the model omitted must not silently become 0 inside a weighted sum —
+  // that reads as "scored badly" when it means "not scored at all".
+  const missing = AXES.filter(k => d[k] === undefined)
+  if (missing.length) {
+    process.stderr.write(`[w4-rubric] LLM omitted ${missing.join(',')} — deferring\n`)
+    process.exit(2)
+  }
+  return Object.fromEntries(AXES.map(k => [k, c(d[k])])) as Record<string, number>
 }
 
 async function main() {
-  const scores = selfTest
-    ? { security:0.90, stability:1.00, simplicity:0.80, integration:0.85, speed:0.75 }
+  const failFixture = args.includes('--self-test-fail')
+  const scores: Record<string, number> = (selfTest || failFixture)
+    ? Object.fromEntries(AXES.map(k => [k, (failFixture ? SELF_TEST_FAIL : SELF_TEST_SCORES)[k] ?? 0.80]))
     : await judge(await new Promise<string>(r => { let s=''; process.stdin.on('data',c=>s+=c); process.stdin.on('end',()=>r(s)) }))
   // deterministic override wins: the surface checklist is truth, not vibes
   if (integrationArg !== undefined) scores.integration = Math.max(0, Math.min(1, parseFloat(integrationArg)||0))
   const comp = composite(scores)
   const baseUrl = process.env.DO_SIGNAL_URL ?? 'https://one.ie'
   if (!selfTest && edge !== 'do/unknown') {
-    await fetch(`${baseUrl}/api/mark-dims`, {method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({edge,dims:scores})}).catch(()=>{})
+    // /api/mark-dims is gate()-guarded (security-gates #5) — it authenticates a service
+    // caller by Bearer === GATEWAY_API_KEY. Resolve it the same way judge() resolves the
+    // OpenRouter key (process.env → DO_ENV_FILE). Without it the marks silently 401 and
+    // the /do rubric-learning signal stops landing — a break the #5 gate introduced.
+    const envFile = process.env.ONE_ENV_FILE ?? process.env.DO_ENV_FILE ?? 'one.ie/web/.env'
+    let gwKey = process.env.GATEWAY_API_KEY ?? ''
+    if (!gwKey && existsSync(envFile)) {
+      const m = readFileSync(envFile,'utf8').split('\n').find(l => l.startsWith('GATEWAY_API_KEY='))
+      if (m) gwKey = m.slice(m.indexOf('=')+1).replace(/^["']|["']$/g,'')
+    }
+    await fetch(`${baseUrl}/api/mark-dims`, {
+      method:'POST',
+      headers:{'Content-Type':'application/json', ...(gwKey ? {'Authorization':`Bearer ${gwKey}`} : {})},
+      body:JSON.stringify({edge,dims:scores}),
+    }).catch(()=>{})
   }
-  process.stdout.write(`[w4-rubric] composite=${comp.toFixed(2)} security=${scores.security.toFixed(2)} stability=${scores.stability.toFixed(2)} simplicity=${scores.simplicity.toFixed(2)} integration=${scores.integration.toFixed(2)} speed=${scores.speed.toFixed(2)} gate=${gate} ${comp>=gate?'PASS':'FAIL'}\n`)
+  // `task-composite`, never bare `composite` — the cycle gate carries goal-fit
+  // at 0.30 and this number does not. Anything that logs, compares, or ratchets
+  // on it is comparing a task score, and the label has to say so.
+  const dims = AXES.map(k => `${k}=${scores[k].toFixed(2)}`).join(' ')
+  process.stdout.write(
+    `[w4-rubric] task-composite=${comp.toFixed(2)} ${dims} gate=${gate} ${comp>=gate?'PASS':'FAIL'}`
+    + ` (task rubric — no goal-fit; NOT the in-cycle W4 verdict)\n`)
   process.exit(comp >= gate ? 0 : 1)
 }
 

package/scripts/wf-check.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// wf-check — syntax-check dynamic workflow scripts the way the RUNTIME parses them.
+//
+// Why this exists: a syntax error in a workflow script doesn't fail loudly, it stops
+// the workflow from launching at all. do-engine.js already carries a scar comment
+// about one such case (a second top-level `export` is illegal in a workflow body).
+//
+// Why the obvious checkers are wrong for this file shape:
+//   node --check <f>.js   → silently exits 0 for ANY file starting with `export`
+//                           (verified on node v24.15.0 — the ESM path is a no-op).
+//   node --check <f>.mjs  → real ESM parse, but rejects the top-level `return` and
+//                           `await` that every workflow body legitimately uses.
+// The runtime wraps the body in an async function, so that is what we parse it as.
+//
+// Usage:  node .claude/scripts/wf-check.mjs [file ...]
+//         (no args → every .js under .claude/workflows/)
+// Exit 0 = all green. Exit 1 = at least one script would fail to launch.
+
+import { readFileSync, readdirSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+
+const WF_DIR = '.claude/workflows'
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor
+const HOOKS = ['args', 'budget', 'agent', 'parallel', 'pipeline', 'log', 'phase', 'workflow']
+
+function check(file) {
+  let src
+  try {
+    src = readFileSync(file, 'utf8')
+  } catch (e) {
+    return { file, ok: false, msg: `unreadable: ${e.message}` }
+  }
+
+  // The loader permits exactly one top-level export: the leading `export const meta`.
+  const exports = src.match(/^export\s/gm) ?? []
+  if (exports.length > 1) {
+    return { file, ok: false, msg: `${exports.length} top-level exports — only the leading \`export const meta\` is permitted` }
+  }
+  if (!/^export\s+const\s+meta\s*=/m.test(src)) {
+    return { file, ok: false, msg: 'missing the required leading `export const meta = {...}`' }
+  }
+
+  try {
+    new AsyncFunction(...HOOKS, src.replace(/^export\s+const\s+meta/m, 'const meta'))
+    return { file, ok: true }
+  } catch (e) {
+    return { file, ok: false, msg: e.message }
+  }
+}
+
+const args = process.argv.slice(2)
+const files = args.length
+  ? args
+  : existsSync(WF_DIR)
+    ? readdirSync(WF_DIR).filter((f) => f.endsWith('.js')).map((f) => join(WF_DIR, f))
+    : []
+
+if (!files.length) {
+  console.log('wf-check: no workflow scripts found')
+  process.exit(0)
+}
+
+let failed = 0
+for (const f of files) {
+  const r = check(f)
+  if (r.ok) {
+    console.log(`  ok    ${r.file}`)
+  } else {
+    failed++
+    console.log(`  FAIL  ${r.file}: ${r.msg}`)
+  }
+}
+
+console.log(`wf-check: ${files.length - failed}/${files.length} green`)
+process.exit(failed ? 1 : 0)

package/skills/ai-ui/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: ai-elements
+name: ai-ui
 description: Build advanced AI UIs with agent reasoning, tool visualization, generative UI components, and composable AI Elements for agentic interfaces
 ---