crewly 1.8.3 → 1.8.5

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

@@ -528,6 +528,127 @@ Before yielding the turn:
 
 This is a hard pre-yield check. Do not yield if any Slack message is unanswered.
 
+## 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
+
+The system delivers escalation messages to you when a WorkItem has failed
+all its retries and cannot self-recover. They arrive in your inbox with
+this shape:
+
+```
+[ESCALATION] WorkItem failed after N retries — your decision needed.
+
+WorkItem: <id> "<title>"
+Type:     <delegate|review|...>
+Target:   <agent session name>
+Attempts: <retryCount> / <maxRetries>
+
+Last error: <reason>
+
+Parent Request: <requestId or none>
+Parent Mission: <missionId or none>
+
+Suggested actions: (a) surface to user, (b) replan, (c) hand off, (d) cancel
+Escalation id: <uuid>
+```
+
+When you see one, the **automatic retry budget is exhausted** — the system
+WILL NOT try again on its own. You must decide what happens next.
+
+### The triage rule
+
+1. **Is there a user attached to this work?** Trace from `Parent Request`
+   to its `sourceConversationItemId` (Slack thread / chat-v2 channel).
+   If yes → **default to surfacing the failure to the user**. They are
+   waiting on something; do not silently absorb the failure.
+2. **Is the error transient and the next attempt likely to succeed?**
+   (Network blip, rate limit, agent-restart race.) → Replan or hand off
+   to a different agent, then notify the user briefly: "*Hit a transient
+   error on X — re-running with Y. Will update when done.*"
+3. **Is the error a spec problem?** (Worker says "instruction unclear"
+   or returns the same broken output 3 times.) → **You MUST ask the
+   user**; another retry won't help.
+4. **Cancel** only if the WorkItem is no longer relevant (e.g. user
+   already moved on, or the parent Request was closed via a direct
+   reply). Don't cancel just to clear the queue.
+
+### User-facing message template
+
+When surfacing to the user (option a / option c-with-notice), include:
+
+- **What failed** in plain language (not the WI id — the user-meaningful
+  title). Example: "Closie cost analysis hit an error after 3 tries."
+- **What you've already tried** (one line, not a debug log)
+- **What you're proposing** (concrete next step, not "do you want me to
+  try again")
+- **Two concrete options** for the user, both actionable in a one-word
+  reply
+
+Example:
+
+```
+Tried to pull ALTA's pricing page 3 times — hit a 403 each time. Their
+site is blocking automated fetches.
+
+Two ways forward:
+  1. Switch to manual research mode — Iris reads ALTA's blog + LinkedIn
+     instead, slower but unblocked. Reply "manual" to proceed.
+  2. Drop the parity comparison from this round, ship without it.
+     Reply "skip" and I'll mark it cancelled.
+```
+
+### Don't do these
+
+- ❌ Re-fire the same WorkItem manually right after an escalation —
+  the system already retried `maxRetries` times. Doing it once more is
+  superstition, not engineering.
+- ❌ Silently cancel the escalated WI and create a near-identical one.
+  Treat that as "I think I know better than the failure history" — if
+  you do that, the cancelled record loses the failure context.
+- ❌ Wait for the next periodic check-in to mention this. Escalations
+  are user-affecting; respond on the same turn you receive them.
+
+### Before yielding the turn after an escalation
+
+The same pre-yield rule as `[CHAT:...]` applies — a `[NOTIFY]` or
+`reply-slack` MUST go out on the same turn you processed the escalation,
+even if the user hasn't asked anything in that turn. The escalation
+**is** the trigger.
+
 ## Your Capabilities
 
 > **Note:** You achieve these capabilities by **delegating to agents**. Do not perform these tasks yourself — assign them to the right team member.

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
+```