@oneie/claude 0.1.0

package/commands/release.md

@@ -0,0 +1,144 @@
+# /release
+
+**Source of truth:** `one/release.md` · **Script:** `scripts/release.ts`
+
+Assemble `release/` from the monorepo, publish npm packages, and push to `github.com/one-ie/one`.
+
+## Modes
+
+| Invocation | What |
+|-----------|------|
+| `/release` | Stage + publish + push (full pipeline) |
+| `/release --stage` | Assemble `release/` only, no publish, no push |
+| `/release --push` | Stage + push to one-ie/one (skip npm publish) |
+| `/release --dry-run` | Print manifest, no writes |
+
+## The Three Packages
+
+| Package | npm name | Publish from | Depends on |
+|---------|----------|-------------|------------|
+| SDK | `@oneie/sdk` | `release/sdk` | — |
+| CLI | `oneie` | `packages/cli` | `@oneie/sdk` |
+| MCP | `@oneie/mcp` | `release/mcp` | `@oneie/sdk` |
+
+**Publish order:** SDK first, then CLI + MCP.
+
+---
+
+## Steps
+
+### Step 1 — Stage (`bun run release`)
+
+```bash
+bun run release          # assembles release/ from monorepo
+bun run release -- --dry-run  # preview only
+```
+
+The script (`scripts/release.ts`) runs six sub-steps:
+
+| Sub-step | What |
+|----------|------|
+| `clean` | Wipe `release/` (preserve `.git`) |
+| `copy` | Run manifest: `agents/templates`, `packages/sdk`, `packages/mcp`, `.claude`, `templates/web` |
+| `one` | Copy `one/` docs filtered by public allowlist (strategy + in-flight work withheld) |
+| `overlay` | Apply `scripts/release-templates/` on top (README.md, CLAUDE.md, AGENTS.md overrides) |
+| `license` | Mirror root `LICENSE` into every slot |
+| `verify` | Assert 4-file convention: `README.md`, `CLAUDE.md`, `AGENTS.md`, `LICENSE` in root + each slot |
+
+**Slots:** `agents/` · `one/` · `sdk/` · `mcp/` · `.claude/` · `web/`
+
+**Key copies:**
+- `templates/web` → `release/web` (Astro + React template)
+- `packages/sdk` → `release/sdk`
+- `packages/mcp` → `release/mcp`
+- `.claude` → `release/.claude` (excl. `settings.local.json`)
+- `agents/templates` → `release/agents/templates` (real pods withheld)
+- `one/` → `release/one` (allowlist filtered)
+
+Report: files copied, bytes, ms per sub-step.
+
+### Step 2 — Version Bump
+
+Before publishing, sync versions. SDK must be bumped first:
+
+1. Bump `packages/sdk/package.json` version
+2. Update `packages/cli/package.json` `@oneie/sdk` dep to match
+3. Update `packages/mcp/package.json` `@oneie/sdk` dep to match  
+4. Bump CLI and MCP versions
+
+**CRITICAL:** `cd packages/sdk` before `npm version` — running from monorepo root triggers lockfile relock.
+
+```bash
+cd packages/sdk && npm version patch && cd ../..
+cd packages/cli && npm version patch && cd ../..
+cd packages/mcp && npm version patch && cd ../..
+```
+
+Re-run `bun run release` after bumping so `release/sdk` and `release/mcp` reflect new versions.
+
+### Step 3 — Build + Publish
+
+SDK must publish before CLI and MCP resolve it.
+
+```bash
+# SDK
+cd release/sdk && bun run build && npm publish --access public && cd ../..
+
+# CLI (publishes from packages/cli, not release/)
+cd packages/cli && npm run build && npm publish --access public && cd ../..
+
+# MCP
+cd release/mcp && bun run build && npm publish --access public && cd ../..
+```
+
+### Step 4 — Push to github.com/one-ie/one
+
+```bash
+bun run release -- --push
+```
+
+The `--push` flag (built into `scripts/release.ts`):
+1. `git init` inside `release/` if no `.git` (first time)
+2. `git remote add origin git@github.com:one-ie/one.git`
+3. `git add .`
+4. `git commit -m "release: v<version>"`
+5. `git push -u origin main`
+
+### Step 5 — Report
+
+```
+Stage:     clean 12ms  copy 340ms  one 28ms  overlay 5ms  license 2ms  verify 3ms
+           487 files, 4.2MB  total 390ms
+Publish:   @oneie/sdk@0.8.0 ✓  oneie@3.8.3 ✓  @oneie/mcp@0.2.0 ✓
+Push:      ✓ github.com/one-ie/one  commit: release: v0.8.0
+```
+
+---
+
+## Manifest Reference (`scripts/release.ts`)
+
+```typescript
+const manifest = [
+  { from: 'agents/templates', to: 'agents/templates' },
+  { from: 'packages/sdk',    to: 'sdk',    exclude: ['node_modules', 'dist'] },
+  { from: 'packages/mcp',    to: 'mcp',    exclude: ['node_modules', 'dist'] },
+  { from: '.claude',         to: '.claude', exclude: ['settings.local.json'] },
+  { from: 'templates/web',   to: 'web',    exclude: ['node_modules', 'dist', '.astro'] },
+]
+// one/ is filtered separately by ONE_PUBLIC_DOCS allowlist
+// README.md + CLAUDE.md come from scripts/release-templates/ overlay (NOT monorepo root)
+```
+
+---
+
+## Gotchas
+
+- **Internal CLAUDE.md never ships** — it's 43KB of private dev context; the overlay provides a clean public version
+- **`one/` is default-deny** — only files in `ONE_PUBLIC_DOCS` allowlist ship; strategy/partnership docs stay private
+- **SDK publishes first** — CLI and MCP declare `@oneie/sdk` as dependency; registry must have it before they resolve
+- **`release/.git` persists** — `clean` step preserves `.git` so `release/` stays a live checkout of `one-ie/one`
+- **CLI publishes from `packages/cli`** — not `release/`; there's no `release/cli` slot
+
+---
+
+*Stage. Publish. Push. The release/ directory IS the one-ie/one repo. Three packages, one truth.*

package/commands/see.md

@@ -0,0 +1,161 @@
+# /see
+
+**Skills:** `/typedb` (read-only queries across all 6 dimensions)
+
+Read the world — query substrate state without emitting signals.
+
+## Nouns
+
+| Noun | What | Loop |
+|------|------|------|
+| `tasks [--tag X] [--status Y]` | Open work sorted by effective priority | L1 |
+| `highways [--limit N]` | Proven paths — strength ≥ 50 (default top 20) | L2 |
+| `toxic` | Blocked paths — resistance > strength | L3 |
+| `frontiers` | Unexplored tag clusters (<10% traversed) | L7 |
+| `paths [--from X] [--to Y]` | Any path query by source/target | L2 |
+| `hypotheses` | Permanent knowledge (hardened by L6) | L6 |
+| `evolved` | Agents that rewrote their system prompts | L5 |
+| `revenue` | Per-path earnings from L4 economic loop | L4 |
+| `events [--since T]` | Signal history and Four Outcomes audit | L1 |
+| `memory <uid>` | Full memory card for an actor (reveal) | L6 |
+
+## Routing
+
+`/see` maps to `follow()` — deterministic read along strongest paths.
+No mark(), no warn(), no side effects. Every noun is read-only.
+
+| Noun | Primitive | Source |
+|------|-----------|--------|
+| tasks | `follow()` queue read | `/api/tasks` or `scanTodos()` |
+| highways | `follow()` path read | `/api/state` strength ≥ 50 |
+| toxic | `follow()` path read | `/api/state` resistance > strength |
+| frontiers | `follow()` gap read | `/api/state` <10% traversed |
+| paths | `follow()` path query | `/api/state` filtered |
+| hypotheses | TypeDB read | knowledge entities |
+| evolved | TypeDB read | units where generation > 1 |
+| revenue | TypeDB read | paths with revenue attribute |
+| events | TypeDB read | signal history |
+| memory | `reveal(uid)` | `/api/memory/reveal/:uid` |
+
+## Steps
+
+### tasks
+
+1. GET `http://localhost:4321/api/tasks` (falls back to `scanTodos()` in `src/engine/task-parse.ts` if server not running)
+2. Filter by `$ARGUMENTS` if provided — tags or phase (e.g. `/see tasks build P0`, `/see tasks C1`)
+3. Report tasks sorted by effective priority (priority score + pheromone strength − resistance):
+   - Name, id, priority formula (e.g. `90 = critical=30 + C1=40 + dev=20`)
+   - Phase, value, persona, tags
+   - Category: attractive / ready / exploratory / repelled
+   - Pheromone: strength, resistance (if any)
+   - Blocks: what tasks this blocks
+   - Exit condition
+4. Group by phase (C1→C7), sorted by effective priority within each phase
+5. Summary: total open/done, count per phase, count per value, top 5 by priority
+6. Suggest what to work on next based on priority + pheromone state
+
+### highways
+
+1. GET `http://localhost:4321/api/export/highways?context=1` (falls back to `/api/state` if server not running)
+2. Show paths where `strength ≥ 50`, sorted by strength desc (default limit 20; use `--limit N` to override)
+3. Each: from → to, strength, traversals, revenue — and `context: <docs>` if contextHint is present
+4. Report:
+   ```
+   Highways:  N paths ≥ 50 strength
+   Hardened:  N paths promoted to permanent (L6)
+   Top path:  <from> → <to>  strength=N  traversals=M  revenue=$X
+              context: dsl, dictionary  (docs that led to success on this path)
+   ```
+
+### toxic
+
+1. GET `http://localhost:4321/api/state`
+2. Show paths where `resistance > strength`
+3. Each: from → to, resistance, strength, hypothesis (if any)
+4. Report:
+   ```
+   Toxic:      N paths with resistance > strength
+   Worst path: <from> → <to>  resistance=N  strength=M  reason="<hypothesis>"
+   ```
+
+### frontiers
+
+1. GET `http://localhost:4321/api/state`
+2. Show tag clusters with <10% traversal rate
+3. Each: tag cluster, % explored, expected value
+4. Report:
+   ```
+   Frontiers:       N clusters
+   Least explored:  <cluster>  X% traversed  expected=$Y
+   ```
+
+### paths
+
+1. GET `http://localhost:4321/api/state`
+2. Filter by `--from` and/or `--to` if provided in `$ARGUMENTS`
+3. Show matching paths: from → to, strength, resistance, net weight (strength − resistance)
+4. Report all matching paths with full pheromone state
+
+### hypotheses
+
+1. Query TypeDB: match hypothesis entities
+2. Show each: pattern, confidence, created, reinforced count
+3. Report:
+   ```
+   Hypotheses: N
+   Top:        <pattern>  confidence=X  reinforced=M times
+   ```
+
+### evolved
+
+1. Query TypeDB: units where `generation > 1`
+2. Show each: uid, name, generation, current model, last evolution timestamp
+3. Report:
+   ```
+   Evolved: N agents
+   Most:    <uid>  gen=N  model=<model>
+   ```
+
+### revenue
+
+1. Query TypeDB: paths with revenue attribute, sorted desc
+2. Show per-path earnings
+3. Report:
+   ```
+   Revenue:  total=$X across N paths
+   Top path: <from>→<to>  $Y
+   ```
+
+### events
+
+1. Query TypeDB signals, optionally filtered by `--since T` from `$ARGUMENTS`
+2. Show each signal: receiver, data summary, outcome, timestamp
+3. Report:
+   ```
+   Events:   N signals
+   Outcomes: result=A  timeout=B  dissolved=C  failure=D
+   ```
+
+### memory
+
+1. Extract `<uid>` from `$ARGUMENTS` (e.g. `/see memory person:a7f3`)
+2. GET `http://localhost:4321/api/memory/reveal/<uid>`
+3. Display the full MemoryCard:
+   - **Actor**: uid, kind, firstSeen
+   - **Hypotheses**: pattern + confidence (asserted capped at 0.30)
+   - **Highways**: top paths by strength
+   - **Signals**: last 200 episodes
+   - **Groups**: memberships
+   - **Capabilities**: offered skills + prices
+   - **Frontier**: unexplored tag clusters
+4. Report:
+   ```
+   Memory: <uid>
+   Hypotheses: N  (observed=X  asserted=Y)
+   Highways: N paths
+   Frontier: [tag1, tag2, ...]  — N unexplored tags
+   ```
+
+---
+
+*Every `/see` query is a `follow()` call — the substrate answers without learning.*

package/commands/setup.md

@@ -0,0 +1,75 @@
+# /setup — Connect to the ONE substrate
+
+Wire Claude Code to your ONE workspace. Run once; the substrate tools become available immediately.
+
+---
+
+## What this does
+
+1. Checks for an existing `ONEIE_API_KEY` in the environment
+2. If absent — asks for your key and writes it to `.env.local` (gitignored)
+3. Verifies the connection with a live `signal` call to `api.one.ie`
+4. Confirms which MCP tools are now available
+
+---
+
+## Steps
+
+**1. Check environment**
+
+```bash
+echo ${ONEIE_API_KEY:-"not set"}
+```
+
+If already set → skip to step 3.
+
+**2. Collect the key**
+
+Ask the user (single `AskUserQuestion`):
+- "What is your ONE API key?" (find it at https://one.ie/settings/keys)
+
+Write to `.env.local`:
+```bash
+echo "ONEIE_API_KEY=<key>" >> .env.local
+grep -q ".env.local" .gitignore || echo ".env.local" >> .gitignore
+export ONEIE_API_KEY=<key>
+```
+
+**3. Verify**
+
+```bash
+curl -sf -X POST https://api.one.ie/signal \
+  -H "Authorization: Bearer $ONEIE_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"receiver":"setup:verify","data":{"tags":["setup"]}}' \
+  | jq -r '.ok // "failed"'
+```
+
+Exit 0 → connected. Non-zero → report the error, link to https://one.ie/docs/api-keys.
+
+**4. Report**
+
+On success:
+```
+✓ Connected to ONE substrate
+  API: https://api.one.ie
+  MCP tools available: signal · ask · mark · warn · fade · follow · select · recall · reveal · forget · frontier · know · highways
+  Lifecycle tools: auth_agent · sync_agent · publish_agent · list_agents · list_skills · register · pay
+  Observability: stats · health · revenue · export_highways
+
+Run /do to start building.
+```
+
+---
+
+## Env vars
+
+| Var | Default | What |
+|-----|---------|------|
+| `ONEIE_API_KEY` | required | Your workspace API key |
+| `ONEIE_API_URL` | `https://api.one.ie` | Override for self-hosted |
+
+To use a different API endpoint:
+```bash
+echo "ONEIE_API_URL=https://your-api.example.com" >> .env.local
+```

package/commands/sync.md

@@ -0,0 +1,185 @@
+# /sync
+
+**Skills:** `/typedb` (tick loops, query & write) · `/signal` (per-loop outcomes, L4 payment emissions)
+
+Reconcile substrate state — tick loops, absorb markdown, propagate knowledge.
+
+## Nouns
+
+| Noun | What | Loop |
+|------|------|------|
+| *(default)* | Tick all loops + scan docs + todos + agents | L1-L7 |
+| `tick` | Fire all L1-L7 loops once (one full growth cycle) | L1-L7 |
+| `docs` | Scan `docs/*.md` → memory → TypeDB | L6 |
+| `todos` | Scan `docs/*-todo.md` → tasks → TypeDB + KV | L1 |
+| `tasks [dir]` | Import reusable task templates from `tasks/` (or `[dir]`) → world-scoped tasks + skills + capabilities | L1 |
+| `agents` | Scan `agents/**/*.md` → units → TypeDB | L1 |
+| `fade` | Fire L3 only — asymmetric decay | L3 |
+| `evolve` | Fire L5 only — rewrite struggling agents | L5 |
+| `know` | Fire L6 only — harden highways + hypothesize | L6 |
+| `frontier` | Fire L7 only — detect unexplored tag clusters | L7 |
+| `pay <receiver> <amt>` | Emit L4 payment signal | L4 |
+| `<path>` | Absorb any markdown file or directory into substrate | L6 |
+
+## Routing
+
+`/sync` maps to `tick()` + `know()` — running all seven loops and hardening highways.
+Individual noun invocations target a single loop layer; default runs all of them.
+
+| Noun | Primitive | L |
+|------|-----------|---|
+| default / tick | `tick()` all loops | L1-L7 |
+| docs / todos / agents / tasks / `<path>` | `know()` absorption | L6 |
+| fade | `fade()` | L3 |
+| evolve | agent prompt rewrite | L5 |
+| know | `know()` harden | L6 |
+| frontier | frontier detection | L7 |
+| pay | `send()` payment signal | L4 |
+
+## Steps
+
+### *(default)*
+
+1. `bun run verify` — W0 gate (skip if already passed this session)
+2. Scan `docs/*-todo.md` → parse checkboxes → POST `/api/tasks/sync`
+3. Scan `docs/*.md` → extract concepts → write to memory → TypeDB
+4. Scan `agents/**/*.md` → parse frontmatter → sync units + skills
+5. GET `http://localhost:4321/api/tick?interval=0` — fire all L1-L7 loops
+6. Report:
+   ```
+   Tasks:    N synced  M hash-deltas  K KV writes
+   Docs:     N scanned  M gaps found  K TypeDB writes
+   Agents:   N synced  M skills
+   Tick:     cycle=N  highways=M  evolved=K  hardened=J  hypotheses=I  frontiers=H
+   L3 fade:  N paths decayed
+   L5 evolve: N agents evaluated  M evolved
+   L6 know:  N highways hardened  M hypotheses written
+   L7 frontier: N clusters detected
+   ```
+
+### tick
+
+1. GET `http://localhost:4321/api/tick?interval=0`
+2. Report full tick output:
+   ```
+   Cycle:      N
+   Highways:   N (strength ≥ 50)
+   Evolved:    N agents rewrote prompts
+   Hardened:   N paths promoted to permanent
+   Hypotheses: N generated
+   Frontiers:  N unexplored clusters
+   Per-loop timings: L3 lastAtMs=N nextAtMs=M  L5 lastAtMs=N  L6 lastAtMs=N  L7 lastAtMs=N
+   ```
+
+### docs
+
+1. Scan all `docs/*.md` files via `src/engine/doc-scan.ts`
+2. Extract key concepts, verify doc-code alignment
+3. Write to memory → TypeDB
+4. Report: docs scanned, gaps found, TypeDB writes
+
+### todos
+
+1. Scan all `docs/*-todo.md` files via `src/engine/task-parse.ts` (`scanTodos()`)
+2. POST to `http://localhost:4321/api/tasks/sync` (hash-gated: skips if data unchanged)
+3. KV update (~10ms), async TypeDB sync (~100ms)
+4. Report:
+   ```
+   Tasks:   N synced across M TODO files
+   Phases:  C1=N C2=M C3=K ...
+   Top 10:  <task> priority=N, ...
+   KV:      N writes (hash-gated)
+   ```
+
+### tasks
+
+Import a reusable task catalog (markdown templates with frontmatter) into the
+current world. Scopes every `template.id` to `{worldId}:{template.id}` so
+multiple worlds can share a catalog without collisions. Idempotent — re-running
+skips tasks that already exist.
+
+1. Resolve catalog directory from `$ARGUMENTS` or default to `tasks/` at repo root
+2. Load templates via `loadTemplates(dir)` (`src/engine/reusable-tasks.ts`)
+3. Instantiate via `instantiateTemplates(templates, { worldId, providerUid })`
+4. Hand off to `syncTasks()` for core TypeDB insert (task + skill + capability)
+5. Layer on extension attributes — rubric weights, price, currency, template-source
+6. Report:
+   ```
+   Templates: N loaded from <dir>
+   Scoped:    {worldId}:<id> × N
+   Inserted:  N tasks, N skills, N capabilities
+   Skipped:   M (already exist — idempotent re-sync)
+   Errors:    K (malformed frontmatter or missing required fields)
+   Rubric:    N templates carried rubric weights
+   Pricing:   N templates carried price + currency
+   ```
+
+**Template format:** see `tasks/README.md`. Required fields: `id`, `name`.
+Optional: `description`, `tags`, `wave`, `value`, `effort`, `phase`, `persona`,
+`rubric: { security, stability, simplicity, speed }`, `price`, `currency`, `blocks`.
+
+**Example:**
+
+```bash
+/sync tasks                         # Import ./tasks into current world
+/sync tasks ./my-catalog            # Import from a custom directory
+/sync tasks ../shared/task-library  # Cross-repo catalog
+```
+
+**Why this noun exists:** Stage 1 (LIST) of the trade lifecycle needs inventory.
+A new seller world with zero listings is a dead market. Reusable task templates
+are pre-packaged LIST entries — import the catalog, your world has a starter
+set of listings ready to receive offers. See `docs/trade-lifecycle-todo.md § Cycle 6`.
+
+### agents
+
+1. Scan `agents/**/*.md` files
+2. Parse frontmatter via `src/engine/agent-md.ts` → `AgentSpec[]`
+3. Sync each to TypeDB: unit + skills + capabilities + group membership
+4. Report: agents synced, skills synced, TypeDB insert count
+
+### fade
+
+1. GET `http://localhost:4321/api/tick?loops=L3`
+2. Asymmetric decay: resistance forgives 2× faster than strength decays
+3. Report: paths decayed, net strength/resistance changes
+
+### evolve
+
+1. GET `http://localhost:4321/api/tick?loops=L5`
+2. For each unit with `success-rate < 0.50` AND `sample-count ≥ 20` AND last evolution > 24h ago:
+   - Rewrite system prompt based on failure patterns
+   - Increment `generation` counter
+3. Report: agents evaluated, agents evolved, generation numbers
+
+### know
+
+1. GET `http://localhost:4321/api/tick?loops=L6`
+2. Promote top highways (strength ≥ 50, consistent) to permanent TypeDB hypotheses
+3. Auto-hypothesize patterns from accumulated path data
+4. Report: highways hardened, hypotheses written, confidence scores
+
+### frontier
+
+1. GET `http://localhost:4321/api/tick?loops=L7`
+2. Detect tag clusters with <10% traversal rate
+3. Report: clusters detected, expected value per cluster
+
+### pay
+
+1. Parse `<receiver>` and `<amount>` from `$ARGUMENTS`
+2. POST `http://localhost:4321/api/signal` with `{ receiver, data: { type: "payment", amount } }`
+3. Revenue recorded on path
+4. Report: payment signal sent, path updated, revenue total for that path
+
+### `<path>`
+
+1. Read markdown file or directory at `<path>` from `$ARGUMENTS`
+2. If directory: scan all `*.md` files recursively
+3. Parse content → extract concepts, tasks, or agent specs as appropriate
+4. Write to memory → TypeDB
+5. Report: files processed, entities written
+
+---
+
+*`/sync` is `tick()` + `know()` — seven loops, one command.*

package/hooks/hooks.json

@@ -0,0 +1,90 @@
+{
+  "PostToolUse": [
+    {
+      "matcher": "Write|Edit",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "bash \"$CLAUDE_PLUGIN_ROOT/hooks/scripts/post-edit-check.sh\"",
+          "timeout": 15000
+        }
+      ]
+    },
+    {
+      "matcher": "Write|Edit|MultiEdit",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "bash \"$CLAUDE_PLUGIN_ROOT/hooks/scripts/sync-todo-docs.sh\"",
+          "timeout": 5000
+        }
+      ]
+    },
+    {
+      "matcher": "Write|Edit|MultiEdit",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "bash \"$CLAUDE_PLUGIN_ROOT/hooks/scripts/design-check.sh\"",
+          "timeout": 5000,
+          "blocking": true
+        }
+      ]
+    },
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "bash \"$CLAUDE_PLUGIN_ROOT/hooks/scripts/tool-signal.sh\"",
+          "timeout": 3000
+        }
+      ]
+    }
+  ],
+  "TaskCompleted": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "bash \"$CLAUDE_PLUGIN_ROOT/hooks/scripts/task-complete-verify.sh\"",
+          "timeout": 120000,
+          "blocking": true
+        }
+      ]
+    }
+  ],
+  "Stop": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "bash \"$CLAUDE_PLUGIN_ROOT/hooks/scripts/session-end-verify.sh\"",
+          "timeout": 30000,
+          "blocking": false
+        },
+        {
+          "type": "command",
+          "command": "bash \"$CLAUDE_PLUGIN_ROOT/hooks/scripts/stop-reflect.sh\"",
+          "timeout": 10000,
+          "blocking": false
+        }
+      ]
+    }
+  ],
+  "SessionStart": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "bash \"$CLAUDE_PLUGIN_ROOT/hooks/scripts/session-start.sh\"",
+          "timeout": 5000,
+          "blocking": false
+        }
+      ]
+    }
+  ]
+}

package/hooks/lib/signal.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Shared signal emitter. Source from any hook:
+#   source "$CLAUDE_PROJECT_DIR/.claude/hooks/lib/signal.sh"
+#   emit_signal <receiver> <weight> [key=value ...]
+#
+# Fire-and-forget POST to /api/signal (2s max, backgrounded). Never blocks.
+# Receiver naming + weight semantics: .claude/skills/signal.md
+
+emit_signal() {
+  local receiver="$1"
+  local weight="${2:-1}"
+  shift 2 || true
+  local data="$*"
+
+  # JSON-escape data (backslash + double-quote)
+  data="${data//\\/\\\\}"
+  data="${data//\"/\\\"}"
+
+  local url="${ONE_API_URL:-http://localhost:4321}/api/signal"
+
+  # Backgrounded, silent, non-blocking. Telemetry failure never breaks tooling.
+  curl -sS -o /dev/null --max-time 2 -X POST "$url" \
+    -H 'Content-Type: application/json' \
+    -d "{\"sender\":\"hook\",\"receiver\":\"$receiver\",\"amount\":$weight,\"data\":\"$data\"}" \
+    >/dev/null 2>&1 &
+
+  return 0
+}