crewly 1.8.4 → 1.8.6

package/config/roles/_common/wiki-instructions.md

@@ -0,0 +1,33 @@
+## LLM-Wiki — Queue Worth-Saving Content (per-turn discipline)
+
+The Crewly LLM-wiki captures **only what agents judge worth remembering**. There is NO automatic capture — you are the gate.
+
+**Before yielding the turn**, scan your conversation (what you sent, what teammates sent you) and ask:
+
+- Did a **decision** get made? (pricing, scope, sequencing, hire, deprecation, scheduling)
+- Did a **fact** about a person, customer, partner, or competitor surface that future-you / the team needs?
+- Did a **pattern, gotcha, or learning** get exposed that the team should not re-discover?
+- Did Steve / a TL / another agent **lock** something previously fluid?
+
+If YES, before yielding, call `config/skills/orchestrator/wiki-queue-add/execute.sh`:
+
+```bash
+--vault       <path>                       # project: <project>/.crewly/wiki; team: ~/.crewly/teams/<id>/wiki; global: ~/.crewly/global-wiki
+--content     "<the fact / decision / learning text>"
+--reason      "<one sentence: WHY this is wiki-worthy>"   # required — empty reason is rejected
+--source-ref  "<chat msg id | slack thread | WI id | file path>"
+--source-type user_chat | slack_message | spec_file | pr_merge | record_learning | task_verified
+```
+
+**DO NOT queue:**
+- Routine status checks (`standup`, `?`, `ok`, `got it`)
+- Implementation details already in code / PR / spec
+- Conversation pleasantries
+- Anything already in the wiki (call `wiki-query` first if unsure)
+- Items where you can't articulate a non-trivial `--reason`
+
+**One queue call per worth-saving event.** Don't batch unrelated facts.
+
+The item lands in the queue with `status: pending`. Later — either when you're idle, OR when a `[BOOKKEEP]` message arrives — drain the queue with `wiki-process-queue`: claim an item, read the vault context, let your LLM pick a target folder (no preset taxonomy beyond the frozen ones), call `wiki-ingest`, then POST `/queue/<id>/process` to commit. If after reading the context you decide the item isn't actually worth saving, POST `/queue/<id>/skip` with a `skipReason`.
+
+**Bookkeep cadence:** when you receive `[BOOKKEEP] vault=…`, run `wiki-bookkeep` for that vault. The report surfaces duplicate clusters and consolidation candidates — use your LLM to merge them.

package/config/roles/orchestrator/prompt.md

@@ -522,11 +522,73 @@ bash {{ORCHESTRATOR_SKILLS_PATH}}/reply-slack/execute.sh '{"channelId":"D0AC7NF5
 
 Before yielding the turn:
 1. Did I receive any `[CHAT:slack-...]` messages this turn?
-2. For EACH such message, did I make at least one Bash call to `reply-slack/execute.sh`?
-3. If no, the response was NOT delivered — `[NOTIFY]` alone is not sufficient.
-4. If the answer to (2) is "no," call `reply-slack` now BEFORE yielding the turn.
+2. **Did I receive any `[DELIVER_REQUIRED]` messages this turn?** (System reminder that a worker agent posted `[DONE]` to a slack thread the user is waiting on, and I haven't yet forwarded the deliverable. See the dedicated section below.)
+3. For EACH such message, did I make at least one Bash call to `reply-slack/execute.sh`?
+4. If no, the response was NOT delivered — `[NOTIFY]` alone is not sufficient.
+5. If the answer to (3) is "no," call `reply-slack` now BEFORE yielding the turn.
 
-This is a hard pre-yield check. Do not yield if any Slack message is unanswered.
+This is a hard pre-yield check. Do not yield if any Slack message or `[DELIVER_REQUIRED]` is unanswered.
+
+## Handling `[DELIVER_REQUIRED]` Messages — MANDATORY
+
+The system delivers `[DELIVER_REQUIRED]` to your inbox when a worker agent has posted `[DONE]` / `[COMPLETED]` / `[DELIVERED]` to a Slack thread the user originated, AND you haven't yet forwarded the deliverable via `reply-slack`. This catches the 2026-05-23 failure mode where you internally narrate "pipeline closed" but never actually call `reply-slack`, leaving the user in silence.
+
+Shape:
+```
+[DELIVER_REQUIRED] Steve is waiting on a deliverable in Slack thread <conversationId>.
+
+Agent `<sender>` posted [DONE] <N> min ago with this content (preview):
+> <first ~200 chars of the agent's [DONE] message>
+
+Action required: call reply-slack now with the deliverable. Treat this
+the same as a [CHAT:slack-...] message — do NOT yield the turn until
+the reply lands on the thread. ...
+```
+
+**Action protocol** (in order, no exceptions):
+
+1. **Look up the actual deliverable.** The `[DONE]` preview is truncated — the full content is in the agent's session output (use `get-agent-logs` if needed) and likely also persisted to a spec / findings file inside `.crewly/`. Read it.
+2. **Decide if it's the FINAL deliverable for the user request OR a Phase-N intermediate.**
+   - **Final**: call `reply-slack` with a Steve-facing summary (Owner-Facing Communication Standard — no internal session names, no jargon). Include any links / file paths Steve needs.
+   - **Intermediate (Phase 1 of 2, etc.)**: still call `reply-slack` — Steve gets a "Phase 1 done, Phase 2 starting, revised ETA" update. Then continue the pipeline. The enforcer will keep tracking until the FINAL phase delivers.
+3. **One `reply-slack` call clears the reminder** (the system marks the thread as delivered on successful `/api/slack/send`). If you ignore the `[DELIVER_REQUIRED]`, you'll get escalating reminders at 3 / 10 / 30 min, then a final "budget exhausted — giving up" log entry, and Steve is permanently silent.
+
+**Hard rule:** if there is a `[DELIVER_REQUIRED]` in your inbox at end-of-turn AND no matching `reply-slack` call was made this turn, you are LITERALLY incomplete. Make the call before yielding. No mental-model substitution — the actual skill call must happen.
+
+## LLM-Wiki — Queue Worth-Saving Content (MANDATORY per-turn discipline)
+
+The wiki captures **only what agents judge worth remembering**. There is
+NO automatic chat-to-vault pipeline anymore (keyword heuristics were
+removed 2026-05-22). You are the gate.
+
+**Before yielding the turn**, scan the messages you sent or received and ask:
+
+- Did a **decision** get made? (pricing, scope, sequencing, hire, deprecation, scheduling)
+- Did a **fact** about a person, customer, partner, or competitor surface that future-me will need?
+- Did a **pattern, gotcha, or learning** get exposed that the team should not re-discover?
+- Did Steve / a TL **lock** something previously fluid?
+
+If YES, before you yield, call `config/skills/orchestrator/wiki-queue-add/execute.sh` with:
+- `--vault` → the project vault (`<project-root>/.crewly/wiki`) for project-scoped
+  content; the team vault (`~/.crewly/teams/<team-id>/wiki`) for cross-project
+  team norms; `~/.crewly/global-wiki` for cross-project synthesis.
+- `--content` → the actual fact / decision / learning text (keep it terse but complete).
+- `--reason` → one sentence justifying why this is wiki-worthy. **Required**. The reason is the audit trail and helps the processor decide where it lands. Refusal to write a reason = refusal to queue.
+- `--source-ref` → stable reference (slack msg id, chat id, WI id, file path).
+- `--source-type` → `user_chat` (default), `slack_message`, `spec_file`, `pr_merge`, `record_learning`, `task_verified`.
+
+**DO NOT queue:**
+- Routine status checks ("standup", "?", "ok", "got it")
+- Implementation details already captured in code / PR / spec files
+- Conversation pleasantries
+- Content already in the wiki (call `wiki-query` first if unsure)
+- Items where you can't articulate a non-trivial `--reason`
+
+**One queue call per worth-saving event.** Don't batch unrelated facts into a single item — the processor needs to classify each one. If a turn produced 3 distinct worth-saving facts, make 3 queue-add calls.
+
+After queueing, continue the turn normally. A separate `wiki-process-queue` run (batch, run periodically by you OR when bookkeep fires) classifies queued items, picks the target page (`llm-curated/customers/<name>.md`, `llm-curated/decisions/<slug>.md`, etc. — the LLM decides; no preset taxonomy beyond the frozen folders), and calls `wiki-ingest` to write.
+
+**Bookkeep cadence:** when you receive a `[BOOKKEEP] vault=…` message OR when you notice the vault has accumulated many new pages since your last pass, run `wiki-bookkeep` to dedupe, consolidate, and prune. (Bookkeep skill ships separately; until it does, the WI brief will spell out the consolidation rules.)
 
 ## Handling `[ESCALATION]` Messages — MANDATORY
 

package/config/roles/team-leader/prompt.md

@@ -284,3 +284,41 @@ You are failing the task if you:
 - Stop after partial progress without assigning next action.
 - Delegate without checking completion.
 - Produce status updates but no artifact, code, decision, or verified result.
+
+## LLM-Wiki — Queue Worth-Saving Content (MANDATORY per-turn discipline)
+
+TLs are the last filter before content reaches the wiki. ORC operates cross-team; YOU operate inside one team and see worker conversations + verify outputs. That makes you the right agent to capture team-scoped patterns, decisions, and norms.
+
+**Before yielding the turn**, scan messages from your workers + the user and ask:
+
+- Did a **team decision** get locked? (architecture, SOP change, hiring/handoff, policy)
+- Did a **worker surface a gotcha / pattern** worth sharing across the team?
+- Did a **person fact** appear (customer, partner, candidate) that the team needs to remember?
+- Did a **verification reveal something subtle** about how the system actually works?
+
+If YES, call `config/skills/orchestrator/wiki-queue-add/execute.sh`:
+
+```bash
+--vault       ~/.crewly/teams/<your-team-id>/wiki   # team vault for team-scoped
+              <project>/.crewly/wiki                # project vault for project-scoped
+--content     "<the captured fact / decision / pattern>"
+--reason      "<one sentence: WHY future-team needs this>"   # required
+--source-ref  "<WI id | chat msg id | spec path>"
+--source-type record_learning | task_verified | spec_file | user_chat | slack_message
+```
+
+**DO NOT queue:**
+- Routine status updates ("done", "in progress", "blocked-pending-X")
+- Implementation details captured in the code/PR — link the PR, don't paraphrase
+- Anything already in the wiki — call `wiki-query` first if unsure
+- Items where you can't articulate why this matters in one sentence
+
+**One queue call per worth-saving event.** If a verification turn produces 3 distinct learnings, that's 3 queue-add calls.
+
+**Drain the queue** when idle OR when `[BOOKKEEP] vault=…` arrives:
+1. `wiki-process-queue --claimed-by <your-session>` → claims item + returns vault context.
+2. Your LLM picks a target page under `llm-curated/` — invent sub-folder names; **NO preset taxonomy**.
+3. `wiki-ingest --target <relative-path>` to write.
+4. POST `/api/wiki/queue/<id>/process` to commit, OR `/queue/<id>/skip` if you decide it's actually a duplicate after seeing context.
+
+Frozen folders (`memory/`, `sop/`, `team-norm/`, `sop-overrides/`) are OFF-LIMITS — ingest will reject with 422.

package/config/skills/agent/core/wiki-query/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: Wiki Query
+description: Read a project/team/global vault and return the system-context payload your runtime feeds to the LLM for synthesis. Single-vault scope (Phase 1).
+version: 1.0.0
+category: knowledge
+skillType: claude-skill
+assignableRoles:
+  - developer
+  - qa
+  - tpm
+  - designer
+  - frontend-developer
+  - backend-developer
+  - fullstack-dev
+  - qa-engineer
+  - product-manager
+  - architect
+  - generalist
+  - team-leader
+  - researcher
+---
+
+# Wiki Query
+
+Read a vault (`<project>/.crewly/wiki/`, `~/.crewly/teams/<id>/wiki/`, or `~/.crewly/global-wiki/`) and get back the structured context the caller's LLM uses for synthesis.
+
+Per Atlas v2.1 §3, this skill **does not call an LLM itself**. It emits the LLM-agnostic system-context (vault SCHEMA, recent log entries, candidate pages by keyword overlap). The caller's runtime concatenates this with the per-LLM task-instruction prompt at `prompts/<runtime>.md` and makes the LLM call locally.
+
+## When to use
+
+- ORC assembling cross-team context for a planning turn.
+- TL pulling the team's last 20 decisions for a sprint review.
+- A worker checking "did we already record an opinion on X?" before writing one.
+
+## Inputs
+
+| Flag | Required | Description |
+|---|---|---|
+| `--vault <path>` | yes | Absolute path to a vault root (must contain `SCHEMA.md`). |
+| `--query <text>` | yes | Natural-language question. Used for keyword-overlap candidate ranking. |
+| `--top-k <n>` | no | How many candidate pages to return (default 5). |
+| `--recent-log <n>` | no | How many tail log entries to include (default 20). |
+| `--json <obj>` | alt | Pass all fields as JSON. |
+
+## Output
+
+JSON with `success`, `result.context`. The context has:
+
+- `vault` — scope, id, absolute path
+- `schemaSummary` — frozen folders, llm-curated layout, write_policy
+- `recentLog` — last N entries (most-recent first), with timestamp / sourceType / caller / body
+- `candidatePages` — top-K pages by keyword overlap with `query`
+- `callerNotes` — synthesis hints the LLM should honor (e.g. refuse writes into frozen paths)
+
+## Example
+
+```bash
+bash execute.sh \
+  --vault ~/Desktop/projects/crewly-projects/crewly/.crewly/wiki \
+  --query "what did we decide about Crewly Pro pricing in May"
+```
+
+## Failure modes
+
+- `400 invalid_input` — missing vault/query or bad topK
+- `404 schema_missing` — vault has no SCHEMA.md

package/config/skills/agent/core/wiki-query/execute.sh

@@ -0,0 +1,107 @@
+#!/bin/bash
+# wiki-query — fetch a vault's system-context payload for LLM synthesis.
+#
+# Per Atlas v2.1 §3: this skill emits ONLY the system-context (LLM-agnostic).
+# The caller's runtime concatenates this with its per-LLM task-instruction
+# at prompts/<runtime>.md before making the LLM call. The skill itself
+# never curls an LLM endpoint.
+#
+# Usage:
+#   bash execute.sh --vault /path/to/vault --query "what did we decide about pricing"
+#   bash execute.sh --vault /path/to/vault --query "..." --top-k 10
+#   bash execute.sh --json '{"vaultPath":"/path","query":"...","topK":5}'
+#   cat input.json | bash execute.sh
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+INPUT_JSON=""
+VAULT_PATH=""
+QUERY=""
+TOP_K=""
+RECENT_LOG=""
+
+# Detect legacy JSON positional arg
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --vault|-v)
+      VAULT_PATH="$2"
+      shift 2
+      ;;
+    --query|-q)
+      QUERY="$2"
+      shift 2
+      ;;
+    --top-k|-k)
+      TOP_K="$2"
+      shift 2
+      ;;
+    --recent-log|-r)
+      RECENT_LOG="$2"
+      shift 2
+      ;;
+    --json|-j)
+      INPUT_JSON="$2"
+      shift 2
+      ;;
+    --help|-h)
+      cat <<EOF
+Usage:
+  execute.sh --vault <vault-dir> --query "<question>" [--top-k 5] [--recent-log 20]
+  execute.sh --json '{"vaultPath":"...","query":"...","topK":5,"recentLogEntries":20}'
+
+Outputs JSON system-context for the caller's LLM. Skill makes no LLM calls itself.
+EOF
+      exit 0
+      ;;
+    --)
+      shift
+      break
+      ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then
+        INPUT_JSON="$1"
+        shift
+      else
+        error_exit "Unknown argument: $1"
+      fi
+      ;;
+  esac
+done
+
+# Read JSON from stdin if no other input
+if [ -z "$INPUT_JSON" ] && [ -z "$QUERY" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then
+    INPUT_JSON="$STDIN_DATA"
+  else
+    QUERY="$STDIN_DATA"
+  fi
+fi
+
+# Parse JSON if supplied
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$VAULT_PATH" ] && VAULT_PATH=$(printf '%s' "$INPUT" | jq -r '.vaultPath // empty')
+  [ -z "$QUERY" ]      && QUERY=$(printf '%s' "$INPUT" | jq -r '.query // empty')
+  [ -z "$TOP_K" ]      && TOP_K=$(printf '%s' "$INPUT" | jq -r '.topK // empty')
+  [ -z "$RECENT_LOG" ] && RECENT_LOG=$(printf '%s' "$INPUT" | jq -r '.recentLogEntries // empty')
+fi
+
+require_param "vaultPath (--vault)" "$VAULT_PATH"
+require_param "query (--query)"     "$QUERY"
+
+# Build body with env-var passthrough so jq escapes safely.
+export _WQ_VAULT="$VAULT_PATH"
+export _WQ_QUERY="$QUERY"
+BODY=$(jq -n '{vaultPath: env._WQ_VAULT, query: env._WQ_QUERY}')
+[ -n "$TOP_K" ]      && BODY=$(echo "$BODY" | jq --argjson k "$TOP_K" '. + {topK: $k}')
+[ -n "$RECENT_LOG" ] && BODY=$(echo "$BODY" | jq --argjson n "$RECENT_LOG" '. + {recentLogEntries: $n}')
+unset _WQ_VAULT _WQ_QUERY
+
+api_call POST "/wiki/query" "$BODY"

package/config/skills/orchestrator/wiki-bookkeep/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: Wiki Bookkeep
+description: Vault health report — md counts, duplicate clusters, queue snapshot, consolidation recommendations. Returns signals; your LLM decides what to merge or archive.
+version: 1.0.0
+category: knowledge
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+  - team-leader
+---
+
+# Wiki Bookkeep
+
+Periodic vault health check. Returns a structured report (md counts, recent activity, duplicate clusters by filename similarity, stale-page count, queue snapshot, recommendations). **The skill does not write to the vault.** Your LLM reads the report and decides next actions.
+
+## When to use
+
+- When `wiki-process-queue` returns `no_pending_items` — quiet moment, good for housekeeping.
+- When the report's `shouldFire` was `true` on the last run (you owe the vault a consolidation pass).
+- When you receive a `[BOOKKEEP] vault=…` message (a future cron + threshold trigger will deliver these).
+
+## Inputs
+
+| Flag | Required | Default | Description |
+|---|---|---|---|
+| `--vault <path>` | yes | — | Absolute vault path. |
+| `--window-days <n>` | no | 7 | "Recent activity" window for `recentMdCount`. |
+| `--threshold <n>` | no | 10 | `shouldFire` triggers when `recentMdCount >= threshold` OR there are duplicate clusters. |
+
+## What you do with the report
+
+1. **Drain pending queue first** — if `queue.pending > 0`, run `wiki-process-queue` until empty before doing anything else.
+2. **Consolidate duplicate clusters** — for each cluster in `duplicateCandidates`, read the member pages, ask your LLM whether they should merge, and if yes:
+   - Call `wiki-ingest` with a consolidated body that supersedes the originals (preserve the most-load-bearing info, deduplicate restated facts).
+   - Note: page DELETION is not in Phase 1 — surface "these N old pages can be archived" in your reply for human review.
+3. **Hot-folder rollups** — if `countsByFolder` shows >20 pages in one bucket without a recent index page, generate one. Pattern: `llm-curated/<folder>/index.md` linking + summarizing each page.
+4. **Stale-page flag** — if `staleCount > 0`, mention to the user — they decide which to keep.
+
+## Output
+
+```json
+{
+  "success": true,
+  "report": {
+    "vault": {"scope": "project", "id": "crewly", "path": "..."},
+    "generatedAt": "2026-05-23T03:00:00Z",
+    "windowDays": 7,
+    "threshold": 10,
+    "shouldFire": true,
+    "totalMdCount": 47,
+    "recentMdCount": 12,
+    "countsByFolder": {"llm-curated/decisions": 8, "llm-curated/customers": 3, ...},
+    "duplicateCandidates": [
+      {"basis": "llm-curated/customers/anthropic-pricing", "pages": ["...-v1.md", "...-v2.md"]}
+    ],
+    "staleCount": 4,
+    "queue": {"pending": 2, "claimed": 0, "processed": 11, "skipped": 1, "total": 14},
+    "recommendations": [
+      "Window has 12 new md(s) — at or above threshold (10). Consider a consolidation pass.",
+      "1 likely-duplicate cluster(s) detected. ...",
+      ...
+    ]
+  }
+}
+```
+
+## Failure modes
+
+- `404 vault_missing` — the vault directory does not exist.
+- `404 schema_missing` — vault has no SCHEMA.md.
+- `400 invalid_input` — vaultPath not absolute / windowDays or threshold non-positive.

package/config/skills/orchestrator/wiki-bookkeep/execute.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+# wiki-bookkeep — vault health report + consolidation signals.
+#
+# Use this skill periodically (or when the queue stats / md-count
+# threshold says "fire"). The skill returns a JSON report:
+#   - total / recent md counts
+#   - per-folder bucket counts
+#   - likely-duplicate clusters (filename Jaccard)
+#   - stale-page count (90+ days untouched)
+#   - queue snapshot (pending/claimed/processed/skipped)
+#   - recommendations
+#
+# This skill does NOT write to the vault. After reading the report,
+# YOUR runtime decides which clusters to merge (call wiki-ingest with
+# a consolidated body) and which pages to archive (out of Phase 1
+# scope — flag in chat for now).
+#
+# Usage:
+#   bash execute.sh --vault /path
+#   bash execute.sh --vault /path --window-days 14 --threshold 10
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+INPUT_JSON=""
+VAULT_PATH=""
+WINDOW=""
+THRESHOLD=""
+
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"; shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --vault|-v)        VAULT_PATH="$2"; shift 2 ;;
+    --window-days|-d)  WINDOW="$2";     shift 2 ;;
+    --threshold|-t)    THRESHOLD="$2";  shift 2 ;;
+    --json|-j)         INPUT_JSON="$2"; shift 2 ;;
+    --help|-h)
+      cat <<EOF
+Usage:
+  execute.sh --vault <path> [--window-days 7] [--threshold 10]
+
+Returns a JSON bookkeeping report with should-fire signal, recent activity,
+duplicate clusters, queue snapshot, and recommendations. The skill makes
+no LLM calls; you decide next actions based on the report.
+EOF
+      exit 0 ;;
+    --) shift; break ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then INPUT_JSON="$1"; shift
+      else error_exit "Unknown argument: $1"; fi ;;
+  esac
+done
+
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$VAULT_PATH" ] && VAULT_PATH=$(printf '%s' "$INPUT" | jq -r '.vaultPath   // empty')
+  [ -z "$WINDOW" ]     && WINDOW=$(printf     '%s' "$INPUT" | jq -r '.windowDays  // empty')
+  [ -z "$THRESHOLD" ]  && THRESHOLD=$(printf  '%s' "$INPUT" | jq -r '.threshold   // empty')
+fi
+
+require_param "vaultPath (--vault)" "$VAULT_PATH"
+
+export _WB_V="$VAULT_PATH"
+BODY=$(jq -n '{vaultPath: env._WB_V}')
+[ -n "$WINDOW" ]    && BODY=$(echo "$BODY" | jq --argjson w "$WINDOW"    '. + {windowDays: $w}')
+[ -n "$THRESHOLD" ] && BODY=$(echo "$BODY" | jq --argjson t "$THRESHOLD" '. + {threshold: $t}')
+unset _WB_V
+
+api_call POST "/wiki/bookkeep" "$BODY"

package/config/skills/orchestrator/wiki-ingest/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: Wiki Ingest
+description: Append a source (spec / decision / chat / pr / learning) into a vault's llm-curated/ tree. Refuses writes into frozen paths.
+version: 1.0.0
+category: knowledge
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+  - team-leader
+---
+
+# Wiki Ingest
+
+Append a source to a vault's `llm-curated/log.md` (default) or to a dedicated page under `llm-curated/` (via `--target`). Per Atlas v2.1 §2 + §3.
+
+The chat subscriber **already** auto-ingests every user→ORC chat message; this skill is for explicit manual ingest:
+
+- TL promoting a decision to `llm-curated/decisions/<date>-<slug>.md`
+- ORC archiving a synthesis memo into `~/.crewly/global-wiki/llm-curated/`
+- A worker filing a `record-learning`-style pattern page
+
+## Inputs
+
+| Flag | Required | Description |
+|---|---|---|
+| `--vault <path>` | yes | Absolute vault root (must contain `SCHEMA.md`). |
+| `--source-type <t>` | yes | One of: `user_chat`, `slack_message`, `spec_file`, `pr_merge`, `record_learning`, `task_verified`. |
+| `--source-ref <ref>` | yes | Stable reference for audit (URL, file path, message id, …). |
+| `--source-body <text>` | yes | Body content to ingest. |
+| `--caller <sess>` | no | Session/user that authored the source (defaults to source-ref). |
+| `--target <relpath>` | no | Override the default `llm-curated/log.md`. Must NOT be inside a frozen folder. |
+
+## Output
+
+```json
+{
+  "success": true,
+  "result": {
+    "ok": true,
+    "pagesWritten": ["llm-curated/log.md"],
+    "logEntry": "## [ISO] sourceType | caller ...",
+    "frozenPathsTouched": []
+  }
+}
+```
+
+## Failure modes
+
+- `422 frozen_path` — target lives under a `hardcoded:` (frozen) folder. The `outcome.frozenFolders` field lists every frozen path in the vault.
+- `404 schema_missing` — vault has no `SCHEMA.md`.
+- `400 invalid_input | empty_body` — missing/invalid args.
+
+## Example: ingest a TL-promoted decision
+
+```bash
+bash execute.sh \
+  --vault ~/.crewly/teams/ad923b66-19dd-4d73-9c92-dc1107d37501/wiki \
+  --source-type user_chat \
+  --source-ref slack://thread/D0ABC/1779363330.313849 \
+  --source-body "Pricing locked at \$999 setup + \$799/month." \
+  --caller user/steve \
+  --target llm-curated/decisions/2026-05-22-crewly-pro-pricing.md
+```

package/config/skills/orchestrator/wiki-ingest/execute.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+# wiki-ingest — append a source into a vault's llm-curated/log.md.
+#
+# Phase A scope (Atlas v2.1 §4 + §4.5): rules-only routing — the caller
+# decides which vault. The chat subscriber already auto-ingests every
+# user→ORC message; this skill is for MANUAL ingest (specs, decisions,
+# LLM-promoted content, etc.) where you want explicit control.
+#
+# Refuses writes into frozen paths (memory/, sop-overrides/, sop/,
+# team-norm/). Only llm-curated/ is restructure-eligible.
+#
+# Usage:
+#   bash execute.sh --vault /path --source-type spec_file --source-ref /path/to/spec.md --source-body "..."
+#   bash execute.sh --vault /path --source-type user_chat --source-ref msg-1 --source-body "..." --caller user/steve
+#   bash execute.sh --vault /path --target llm-curated/decisions/2026-05-22-pricing.md --source-type user_chat --source-ref s1 --source-body "..."
+#   bash execute.sh --json '{"vaultPath":"...","sourceType":"...","sourceRef":"...","sourceBody":"..."}'
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+INPUT_JSON=""
+VAULT_PATH=""
+SOURCE_TYPE=""
+SOURCE_REF=""
+SOURCE_BODY=""
+CALLER=""
+TARGET=""
+
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --vault|-v)
+      VAULT_PATH="$2"; shift 2 ;;
+    --source-type|-t)
+      SOURCE_TYPE="$2"; shift 2 ;;
+    --source-ref|-r)
+      SOURCE_REF="$2"; shift 2 ;;
+    --source-body|-b)
+      SOURCE_BODY="$2"; shift 2 ;;
+    --caller|-c)
+      CALLER="$2"; shift 2 ;;
+    --target)
+      TARGET="$2"; shift 2 ;;
+    --json|-j)
+      INPUT_JSON="$2"; shift 2 ;;
+    --help|-h)
+      cat <<EOF
+Usage:
+  execute.sh --vault <vault> --source-type <type> --source-ref <ref> --source-body <body> [--caller <sess>] [--target <relpath>]
+  execute.sh --json '{"vaultPath":"...","sourceType":"...","sourceRef":"...","sourceBody":"...","callerSession":"...","targetRelativePath":"..."}'
+
+sourceType MUST be one of:
+  user_chat | slack_message | spec_file | pr_merge | record_learning | task_verified
+
+Default target is "llm-curated/log.md". Override with --target for a dedicated page (must NOT be inside a frozen folder).
+EOF
+      exit 0 ;;
+    --)
+      shift; break ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then
+        INPUT_JSON="$1"; shift
+      else
+        error_exit "Unknown argument: $1"
+      fi ;;
+  esac
+done
+
+# stdin JSON fallback
+if [ -z "$INPUT_JSON" ] && [ -z "$SOURCE_BODY" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then
+    INPUT_JSON="$STDIN_DATA"
+  else
+    SOURCE_BODY="$STDIN_DATA"
+  fi
+fi
+
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$VAULT_PATH" ]  && VAULT_PATH=$(printf  '%s' "$INPUT" | jq -r '.vaultPath          // empty')
+  [ -z "$SOURCE_TYPE" ] && SOURCE_TYPE=$(printf '%s' "$INPUT" | jq -r '.sourceType         // empty')
+  [ -z "$SOURCE_REF" ]  && SOURCE_REF=$(printf  '%s' "$INPUT" | jq -r '.sourceRef          // empty')
+  [ -z "$SOURCE_BODY" ] && SOURCE_BODY=$(printf '%s' "$INPUT" | jq -r '.sourceBody         // empty')
+  [ -z "$CALLER" ]      && CALLER=$(printf      '%s' "$INPUT" | jq -r '.callerSession      // empty')
+  [ -z "$TARGET" ]      && TARGET=$(printf      '%s' "$INPUT" | jq -r '.targetRelativePath // empty')
+fi
+
+require_param "vaultPath  (--vault)"       "$VAULT_PATH"
+require_param "sourceType (--source-type)" "$SOURCE_TYPE"
+require_param "sourceRef  (--source-ref)"  "$SOURCE_REF"
+require_param "sourceBody (--source-body)" "$SOURCE_BODY"
+
+# Build body via env vars (safe escaping).
+export _WI_VAULT="$VAULT_PATH"
+export _WI_TYPE="$SOURCE_TYPE"
+export _WI_REF="$SOURCE_REF"
+export _WI_BODY="$SOURCE_BODY"
+BODY=$(jq -n '{
+  vaultPath:  env._WI_VAULT,
+  sourceType: env._WI_TYPE,
+  sourceRef:  env._WI_REF,
+  sourceBody: env._WI_BODY
+}')
+[ -n "$CALLER" ] && { export _WI_CALLER="$CALLER"; BODY=$(echo "$BODY" | jq '. + {callerSession: env._WI_CALLER}'); unset _WI_CALLER; }
+[ -n "$TARGET" ] && { export _WI_TARGET="$TARGET"; BODY=$(echo "$BODY" | jq '. + {targetRelativePath: env._WI_TARGET}'); unset _WI_TARGET; }
+unset _WI_VAULT _WI_TYPE _WI_REF _WI_BODY
+
+api_call POST "/wiki/ingest" "$BODY"