@codyswann/lisa 4.74.9 → 4.75.0

package/plugins/lisa-wiki-devin/skills/lisa-wiki-add-ingest/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: lisa-wiki-add-ingest
+description: Scaffold a project-specific "front-door" ingest skill that does something unique (classify a source, fetch from a special system, stamp domain frontmatter) and then chains into /ingest. Use when a project needs a bespoke ingestion path that the core connectors do not cover — instead of forking the kernel. The generated skill enriches and delegates; the kernel still owns synthesis, index, log, verify, state, and PR.
+---
+
+# lisa-wiki-add-ingest
+
+Generate a thin, project-local front-door ingest skill so a project can extend ingestion **without
+forking** the kernel. The front-door does only the unique part, then hands enriched parameters to
+`/ingest`.
+
+## Workflow
+1. **Interview** the project: a short name; what the source is; which `wiki/sources/<sourceSystem>/`
+   bucket and page type/frontmatter it should produce; whether it merely *enriches/classifies* an
+   input or also *fetches* from an external system; and its **side-effect class**
+   (`read-only-ingest` | `repo-write` | `external-write`).
+2. **Generate** the front-door skill on both runtimes —
+   `.claude/skills/lisa-wiki-local-<name>/SKILL.md` and `.agents/skills/lisa-wiki-local-<name>/SKILL.md`.
+   Its body does the unique step, then **delegates to the `lisa-wiki-ingest` skill** (Claude facade
+   `/ingest`) passing the bucket/type/metadata. If it fetches, it writes only a sanitized source note
+   (+ run metadata) and lets the kernel do synthesis/index/log/verify/state/PR.
+3. **Register** it in `wiki/lisa-wiki.config.json` under `customConnectors`
+   (`{ name, skill, sourceSystem, stateFile, sideEffects }`). `/ingest` dispatches **only** to
+   registered names — no auto-discovery.
+
+## Rules (the front-door contract)
+- A generated front-door writes **only** its source note + run metadata. It must not write synthesis
+  pages, `index.md`, `log.md`, or final state — the kernel does those, in order, after it returns.
+- `external-write` front-doors require config opt-in **and** explicit per-run intent, and their PRs
+  never auto-merge.
+- Side effects outside the declared class are a hard failure (enforced by the touched-file guard).
+
+## Related
+`lisa-wiki-ingest` (what it chains into), `lisa-wiki-add-role`, `lisa-wiki-doctor`.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-add-role/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: lisa-wiki-add-role
+description: Scaffold a domain-expert "digital staff" role over the wiki — a dual-runtime subagent (Claude + Codex) plus a staff doc page — from a config.staff[] entry. Use when a project wants a role-scoped expert (e.g. Legal, Finance, Sales) whose knowledge is a slice of the wiki. The plugin only SETS UP the subagent; whether it is ever invoked, scheduled, or routed is out of scope.
+---
+
+# lisa-wiki-add-role
+
+Turn a role definition into two generated artifacts: a documentation page in the wiki and a runnable,
+brain-pointed subagent on both runtimes. **Running the subagent (invocation, scheduling, Telegram /
+agent-team routing, private notebooks) is out of scope** — this skill only creates it.
+
+## Workflow
+1. **Resolve the role** from a `config.staff[]` entry (or interview to add one): `id`, `role`,
+   `expertise`, `owns` (categories / connectors / skills), `sensitivity`.
+2. **Doc page:** generate `wiki/staff/<id>.md` describing the role, its owned domain, and who it
+   reports to. This page is wiki content and is itself ingestible (the `roles` connector).
+3. **Subagents (dual-runtime), rendered from the role-agent templates:**
+   - Claude: `.claude/agents/<id>.md`.
+   - Codex: `.codex/agents/<id>.toml` (keys `name`, `description`, `developer_instructions`; optional
+     `model`, `model_reasoning_effort`, `sandbox_mode`).
+4. **Brain-pointed, not baked:** the subagent's instructions say *"your domain is `wiki/<owned>/`;
+   `/query` it first, contribute via `/ingest`; stay in your lane."* It points at the live wiki so it
+   never goes stale. Only its one-line `description` is synthesized from the wiki at generation time.
+5. **Serialize the description before rendering:** derive `roleDescriptionSerialized` with
+   `JSON.stringify(roleDescription)` or an exact equivalent that emits one JSON string literal on one
+   physical line. Substitute that serialized literal, including its surrounding quotes, directly for
+   `{{roleDescriptionSerialized}}` in both templates. Do not add another layer of quotes. This keeps
+   colon-space sequences, quotes, backslashes, and runtime newlines exact in both YAML and TOML.
+
+## Rules
+- v1 instructs lane-keeping but does not *enforce* per-role write isolation (deferred).
+- Setup seeds the starter roster by delegating here per `config.staff[]` entry.
+
+## Related
+`lisa-wiki-setup` (seeds the roster), `lisa-wiki-add-ingest`, `lisa-wiki-onboard-me`.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-connector-confluence/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: lisa-wiki-connector-confluence
+description: Produce sanitized Confluence source notes for lisa-wiki ingest via the Atlassian MCP. Use only when lisa-wiki-ingest routes to the confluence connector. Read-only; tenant-guarded.
+---
+
+# lisa-wiki-connector-confluence
+
+Skill-driven connector (Atlassian MCP). Writes ONLY source notes under `wiki/sources/confluence/` and
+emits a proposed cursor; the kernel does the rest.
+
+## Flow
+1. Confirm `connectors.confluence.enabled` and `sideEffects: read-only-ingest`.
+2. **Tenant guard:** verify the Atlassian connection matches `connectors.confluence.tenantGuard`
+   (same site/cloudId discipline as jira). Abort on mismatch.
+3. **Window:** read `wiki/state/confluence/*.json`. First run → configured window; incremental →
+   pages updated since the cursor. Scope to the configured spaces.
+4. **Fetch (read-only)** page content + metadata via the Atlassian MCP. Never edit Confluence.
+5. **Write source notes** under `wiki/sources/confluence/<YYYY-MM-DD>-confluence-ingest.md` with
+   frontmatter and citations (`Source: <space>/<page>`). Redact secrets; honor retention/sensitivity.
+6. **Emit run metadata** (proposed cursor, counts) to the handoff file; return to `lisa-wiki-ingest`.
+
+## Rules
+- Abort on tenant mismatch; do not invent pages/decisions; weak evidence → open-questions.
+- Disabled if the Atlassian MCP is absent (`scripts/mcp-doctor.mjs`).
+- Writes only source notes + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-connector-docs/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: lisa-wiki-connector-docs
+description: Ingest a local document (PDF, DOCX, Markdown, text) into a sanitized source note for lisa-wiki ingest. Use only when lisa-wiki-ingest routes to the docs connector (a file-path input). Uses available local converters; no heavy bundled dependency.
+---
+
+# lisa-wiki-connector-docs
+
+Skill-driven connector. Converts a local document to markdown using whatever converter is available,
+writes a source note, and hands off; the kernel does the rest.
+
+## Converters (no bundled heavy dependency)
+- **Markdown / text**: ingest directly.
+- **PDF**: `pdftotext` (Poppler) if available, else `pandoc`.
+- **DOCX**: `pandoc` if available, else `textutil` (macOS).
+If no suitable converter is installed, **skip that source and record a `docs` doctor finding** (the
+file could not be converted) so the user can install a converter — a targeted `/ingest <file>` reports
+the skip rather than pretending success. Missing converters are connector-specific, never a
+plugin-install blocker.
+
+## Flow
+1. Confirm `connectors.docs.enabled` and `sideEffects: read-only-ingest`.
+2. Resolve the input file; pick the converter by extension; convert to markdown (read-only).
+3. Write a source note under `wiki/sources/docs/<YYYY-MM-DD>-<slug>.md` with frontmatter
+   (`type: source`, dates, `source_system: docs`, original filename) and the converted, reader-safe
+   text. Redact secrets; honor `sourceRetention`/`sensitivity`.
+4. Emit run metadata (source-note path) to the handoff file; return to `lisa-wiki-ingest`.
+
+## Rules
+- Read-only on the source document; never modify the original.
+- Writes only the source note + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-connector-git/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: lisa-wiki-connector-git
+description: Produce sanitized git/PR-history source notes for lisa-wiki ingest. Use only when lisa-wiki-ingest routes to the git connector (self repo or a registered project). Read-only — never checks out, fetches, or mutates the target repo.
+---
+
+# lisa-wiki-connector-git
+
+A universal, deterministic connector backed by `scripts/ingest-git.mjs`. It writes ONLY a source note
+under `wiki/sources/git/` (or a per-project path) and emits a proposed cursor; the kernel performs
+synthesis/index/log/verify/state/PR.
+
+## Flow
+1. Confirm `connectors.git` is enabled and `read-only-ingest`.
+2. For the self repo (and each registered project under `projects/`), run:
+   ```
+   node "${PLUGIN_ROOT}/scripts/ingest-git.mjs" --repo <path> --slug <name> \
+     --config wiki/lisa-wiki.config.json --source-dir wiki/sources/git \
+     --state wiki/state/git/<slug>.json --emit-meta wiki/state/handoff/git-<slug>-<runId>.json
+   ```
+3. Hand the emitted source-note paths + proposed cursor back to `lisa-wiki-ingest`.
+
+## Rules
+- Read-only: only `git log`/`rev-parse`/`gh pr list` against the repo; never checkout/fetch/reset/pull.
+- In wrapper/standalone mode, the registered child repos are read-only inputs and are never staged.
+- Writes only its source note + handoff meta; the kernel advances `wiki/state/git/<slug>.json`.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-connector-jira/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: lisa-wiki-connector-jira
+description: Produce sanitized JIRA source notes for lisa-wiki ingest via the Atlassian MCP. Use only when lisa-wiki-ingest routes to the jira connector. Read-only; tenant-guarded.
+---
+
+# lisa-wiki-connector-jira
+
+Skill-driven connector (Atlassian MCP). Writes ONLY source notes under `wiki/sources/jira/` and emits
+a proposed cursor; the kernel does synthesis/index/log/verify/state/PR.
+
+## Flow
+1. Confirm `connectors.jira.enabled` and `sideEffects: read-only-ingest`.
+2. **Tenant guard:** verify the active Atlassian connection resolves to
+   `connectors.jira.tenantGuard.site` / `cloudId`. If it resolves to a different account/tenant,
+   **abort** (do not ingest) — this is the cross-tenant contamination guard.
+3. **Window:** read `wiki/state/jira/*.json`. First run → last 4 months (or configured window);
+   incremental → issues `updated >=` the cursor watermark. Scope to `connectors.jira.projects[]`.
+4. **Fetch (read-only)** via the Atlassian MCP (JQL search + issue read). Never write to JIRA.
+5. **Write source notes** under `wiki/sources/jira/<YYYY-MM-DD>-jira-ingest.md` — reader-safe, with
+   frontmatter (`type: source`, dates, `source_system: jira`) and citations (`Source: <issue key>`).
+   Redact secrets; honor `sourceRetention`/`sensitivity`.
+6. **Emit run metadata** (proposed cursor: latest `updated` watermark, counts) to the handoff file,
+   then return to `lisa-wiki-ingest`.
+
+## Rules
+- Abort on tenant mismatch; never invent issues/PRs/people; weak evidence → open-questions.
+- If the Atlassian MCP is absent, the connector is disabled (see `scripts/mcp-doctor.mjs`).
+- Writes only source notes + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-connector-memory/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: lisa-wiki-connector-memory
+description: Ingest the agent's PROJECT-SCOPED memory into a sanitized source note. Use only when lisa-wiki-ingest routes to the memory connector. NEVER ingests global or unrelated memory — global Codex memory and the Chronicle store are refused.
+---
+
+# lisa-wiki-connector-memory
+
+A universal connector backed by `scripts/ingest-memory.mjs`. **Project-scoped only.**
+
+## Resolve the memory directory (then pass it explicitly)
+- **Claude**: per-project memory at `~/.claude/projects/<encoded-project-path>/memory/` — inherently
+  project-scoped; always eligible.
+- **Codex**: eligible ONLY if a project-scoped memory store exists (e.g. a per-project `CODEX_HOME`).
+  The global `~/.codex/memories/` and the Chronicle store are **never** ingested (the script
+  hard-refuses them).
+
+## Flow
+```
+node "${PLUGIN_ROOT}/scripts/ingest-memory.mjs" --memory-dir <project-scoped-dir> \
+  --config wiki/lisa-wiki.config.json --source-dir wiki/sources/memory \
+  --state wiki/state/memory/memory.json --emit-meta wiki/state/handoff/memory-<runId>.json
+```
+Hand the source note + proposed cursor back to `lisa-wiki-ingest`.
+
+## Rules
+- Secrets are redacted; sensitivity is at least `internal`.
+- If no project-scoped memory exists, ingest nothing rather than reaching for global memory.
+- Writes only its source note + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-connector-notion/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: lisa-wiki-connector-notion
+description: Produce sanitized Notion source notes for lisa-wiki ingest via the Notion MCP. Use only when lisa-wiki-ingest routes to the notion connector. Read-only; teamspace-guarded.
+---
+
+# lisa-wiki-connector-notion
+
+Skill-driven connector (Notion MCP). Writes ONLY source notes under `wiki/sources/notion/` and emits a
+proposed cursor; the kernel does the rest.
+
+## Flow
+1. Confirm `connectors.notion.enabled` and `sideEffects: read-only-ingest`.
+2. **Tenant guard:** verify the Notion connection resolves to
+   `connectors.notion.tenantGuard.teamspace` / `teamspaceId`. Abort on a different workspace/teamspace.
+3. **Window:** read `wiki/state/notion/*.json`. First run → configured window; incremental → pages
+   edited since the cursor.
+4. **Fetch (read-only)** via the Notion MCP. Never edit Notion.
+5. **Write source notes** under `wiki/sources/notion/<YYYY-MM-DD>-notion-ingest.md` with frontmatter
+   and citations (`Source: <notion page>`). Redact secrets; honor retention/sensitivity.
+6. **Emit run metadata** (proposed cursor, counts) to the handoff file; return to `lisa-wiki-ingest`.
+
+## Rules
+- Abort on teamspace mismatch; do not invent pages; weak evidence → open-questions.
+- Disabled if the Notion MCP is absent (`scripts/mcp-doctor.mjs`).
+- Writes only source notes + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-connector-roles/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: lisa-wiki-connector-roles
+description: Ingest the wiki's own digital-staff roster (config.staff[] + wiki/staff/*) into a sanitized source note. Use only when lisa-wiki-ingest routes to the roles connector. Does not run any subagent.
+---
+
+# lisa-wiki-connector-roles
+
+A universal, deterministic connector backed by `scripts/ingest-roles.mjs`. It captures the roster so
+the wiki documents its own digital staff.
+
+## Flow
+```
+node "${PLUGIN_ROOT}/scripts/ingest-roles.mjs" --config wiki/lisa-wiki.config.json \
+  --wiki wiki --source-dir wiki/sources/roles \
+  --state wiki/state/roles/roles.json --emit-meta wiki/state/handoff/roles-<runId>.json
+```
+Hand the source note + proposed cursor back to `lisa-wiki-ingest`.
+
+## Rules
+- Reads `config.staff[]` and `wiki/staff/*.md` only; never invokes/schedules the role subagents
+  (that is out of scope — see lisa-wiki-add-role).
+- Writes only its source note + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-connector-slack/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: lisa-wiki-connector-slack
+description: Ingest a Slack channel into sanitized source notes via a user token. Use only when lisa-wiki-ingest routes to the slack connector AND the run carries explicit external-write intent (Slack OAuth opens a browser and stores a token file). Centralized stdlib-Python scripts; secrets are redacted.
+---
+
+# lisa-wiki-connector-slack
+
+The centralized Slack connector backed by `scripts/slack_oauth_user.py` (one-time OAuth) and
+`scripts/ingest_slack_channel.py` (ingest). These are the stdlib-Python scripts previously duplicated
+verbatim across projects, now shipped once by the plugin.
+
+## Side effects — `external-write`
+Slack OAuth opens a browser and writes a user-token file to a local secrets path. The slack connector
+is therefore `external-write`: it runs ONLY with config opt-in **and** explicit per-run intent, is
+skipped during an unattended full ingest, and its PR never auto-merges.
+
+## Flow
+1. One-time auth (explicit): `python3 "${PLUGIN_ROOT}/scripts/slack_oauth_user.py"` — stores a
+   `xoxp-` user token under an ignored secrets path. The token file is never committed.
+2. Ingest: `python3 "${PLUGIN_ROOT}/scripts/ingest_slack_channel.py" --channel <id-or-name> \
+   --config wiki/lisa-wiki.config.json --emit-meta wiki/state/handoff/slack-<runId>.json` — verifies
+   the Slack tenant against config, then writes sanitized source notes under `wiki/sources/slack/`
+   (tokens/keys redacted) and emits a **proposed** cursor to the handoff file.
+3. Hand the source notes + handoff meta back to `lisa-wiki-ingest` (the kernel advances final state
+   after verification).
+
+## Rules
+- Verify the Slack team/tenant matches config before ingesting.
+- Token/OAuth artifacts stay in `.gitignore` and are never committed.
+- Writes only Slack source notes; the kernel performs synthesis/index/log/verify/PR.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-connector-web/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: lisa-wiki-connector-web
+description: Ingest a public URL into a sanitized source note for lisa-wiki ingest (via WebFetch). Use only when lisa-wiki-ingest routes to the web connector (a URL input). Read-only.
+---
+
+# lisa-wiki-connector-web
+
+Skill-driven connector. Fetches a public URL (WebFetch / equivalent), reduces it to a reader-safe
+source note, and hands off; the kernel does synthesis/index/log/verify/state/PR.
+
+## Flow
+1. Confirm `connectors.web.enabled` and `sideEffects: read-only-ingest`.
+2. Fetch the URL read-only (WebFetch). Do not follow suspicious cross-host redirects without care.
+3. Write a source note under `wiki/sources/web/<YYYY-MM-DD>-<slug>.md` with frontmatter
+   (`type: source`, dates, `source_system: web`, the URL) and a faithful, reader-safe summary +
+   key excerpts. Redact secrets; honor `sourceRetention` (e.g. `external-pointer-only` keeps just the
+   URL + minimal note).
+4. Emit run metadata (the source-note path) to the handoff file; return to `lisa-wiki-ingest`.
+
+## Rules
+- Read-only; never submit forms or trigger actions on the page.
+- Do not invent content not present on the page; weak/uncertain material → open-questions.
+- Writes only the source note + handoff meta; the kernel advances state.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-doctor/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: lisa-wiki-doctor
+description: Verify that a wiki is correctly set up and (after migration) fully functional. Runs the deterministic checks plus functional smoke tests, writes a doctor report, and returns an overall verdict. Use as the final gate of /migrate, after /setup, or anytime to confirm wiki health. A repo is not "migrated" until its doctor verdict is READY.
+---
+
+# lisa-wiki-doctor
+
+The post-migration / post-setup verification checklist. Orchestrates the deterministic scripts and
+functional smoke tests, then writes `wiki/state/migration/doctor-report.json` and prints the blocking
+items.
+
+## Verdict
+Each item is `PASS | WARN | FAIL | SKIP`; overall is `READY | READY_WITH_WARNINGS | NOT_READY`. In
+hard-enforcement mode (`--migration` after phase 5) `WARN` on structure/integrity items is not
+allowed; earlier phases allow documented legacy warnings. Build checks (group G) are Lisa/release-only
+and `SKIP` in downstream repos.
+
+## Checklist
+- **A. Structure & config** (deterministic): `validate-config.mjs` + structure-manifest conformance;
+  required files present; `schemaVersion` set and rendered `kernelVersion` matches the installed
+  plugin; README mode recorded (never implicit `stub`).
+- **B. Integrity & safety** (deterministic): `lint-wiki.mjs` + `diff-guard.mjs`; index/log coverage;
+  state-order invariant; no broken/orphan links; secret/tenant/contamination/sensitivity scans;
+  memory sources project-scoped only (no global Codex memory / Chronicle).
+- **C. No-loss / parity**: pre/post manifest maps every legacy page/doc/command/ingest-path/role;
+  nothing dropped; docs absorption idempotent with zero dangling links; old README ingested before
+  rewrite; no leftover project-local machinery except generated overlays + role agents.
+- **D. Runtime surfaces** (both runtimes): canonical commands resolve on Claude; `$lisa-wiki-*` on
+  Codex; each `config.staff[]` role has its doc page + both subagents; MCP doctor passes or connector
+  cleanly disabled; external-write connectors skipped unless explicit intent.
+- **E. Functional smoke** (skill-orchestrated): targeted ingest of a small fixture exercises the full
+  ordered pipeline (in the migration branch or dry/scratch mode — **no extra PR**); `/query` returns
+  a cited answer; `/lint` clean (or expected phase warnings); `/onboard-me` completes read-mostly with
+  no PII; bare `/ingest --dry-run` lists non-external-write sources; `/doctor` rerun is idempotent.
+- **F. Mode-specific**: embedded self-ingest at HEAD; wrapper child-docs ingested-not-moved and not
+  staged; standalone/subdir path resolution; no-PR mode does not require PR creation.
+- **G. Git / CI / distribution** (deterministic): clean working tree (only intended changes); no
+  secrets/OAuth committed; PR/auto-merge policy honored; CI validator green if `--with-ci`; (Lisa
+  only) `bun run build:plugins` builds both artifacts and `check:plugins` passes.
+
+## Notes
+- Deterministic items are run by `scripts/verify-migration.mjs` (which emits the JSON report); this
+  skill adds the functional smoke tests and interprets phase-allowed warnings.
+- Read-mostly: the smoke tests must not open an extra PR or perform external writes.
+
+## Related
+`lisa-wiki-migrate`, `lisa-wiki-lint`, `lisa-wiki-setup`.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-ingest/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: lisa-wiki-ingest
+description: Ingest source material into the LLM Wiki. With an argument (URL, file path, or prompt) it ingests that one source; with no argument it runs a full ingest across every enabled non-external-write source. Routes to the right connector, then runs the ordered pipeline (source note → synthesis → index → log → verify → state → commit/PR). Use whenever new knowledge should enter the wiki.
+---
+
+# lisa-wiki-ingest
+
+The single entry point for getting knowledge into the wiki. It is a **router**: it never reimplements
+synthesis per source — it selects a connector to produce a sanitized source note, then the kernel
+performs the shared, ordered pipeline.
+
+## Modes
+- **Targeted:** `/ingest <url|file|prompt>` — ingest one source. Classify the input and pick the
+  matching connector.
+- **Full:** `/ingest` (no argument, or "do a full ingest") — iterate **every enabled connector whose
+  side-effect policy permits unattended ingest**: self + other registered projects' git/PR history,
+  project-scoped memory, roles, plus read-only registered sources (notion, jira, confluence,
+  quickbooks, …). `external-write` connectors (Slack OAuth, CRM writeback) are **skipped unless the
+  run includes explicit external-write intent**.
+- **Dry run:** `/ingest --dry-run` — list the sources a full ingest would run; perform no writes.
+
+## Step 0 — resolve the wiki root (once per run)
+
+Before anything else, run the bundled resolver from the installed Lisa wiki plugin, not from the
+consumer repository's `scripts/` directory:
+
+```bash
+node "${PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT:-${CURSOR_PLUGIN_ROOT:-$(npm root)/@codyswann/lisa/plugins/lisa-wiki}}}/scripts/ensure-wiki.mjs" --json
+```
+
+Use the returned `wikiRoot` as the base for the whole pipeline — never hardcode `wiki/`. This is
+mode-agnostic by design:
+
+- **Local wiki** (no `wiki.source` in `.lisa.config.json`) — resolves the in-repo wiki root instantly;
+  the branch sync below proceeds against **this** repo's remote, exactly as before.
+- **Remote wiki** (`wiki.source.url` set) — `ensure-wiki` mirrors/refreshes the gitignored working copy
+  of the canonical wiki repo and returns its path. In this mode the "sync the branch" step below, and
+  the Commit/PR step (7), operate against the **wiki repo's own remote** (the mirror), not the host
+  project's `origin`. The host project repo is never written to.
+
+## Before ingesting — sync the branch (once per run)
+
+Run this **once per ingest invocation, before any source is processed** (skip for `--dry-run`, which
+writes nothing). The point is to ingest on top of fresh state, never stale state. Operate in the wiki
+root resolved in Step 0 — the host repo for a local wiki, the mirror for a remote one.
+
+1. **Resolve the default remote branch** — `gh repo view --json defaultBranchRef -q .defaultBranchRef.name`,
+   or `git remote show origin | sed -n 's/.*HEAD branch: //p'`, or the `origin/HEAD` symbolic ref. If
+   the repo has no remote, note "no remote — skipping branch sync" and proceed.
+2. **Fetch** — `git fetch <remote>` to update remote-tracking refs.
+3. **Bring the working branch up to date with the default remote branch** so the ingest lands on
+   current state:
+   - On the default branch → fast-forward to `<remote>/<default>` (`git pull --ff-only`).
+   - On a non-default branch → merge or rebase `<remote>/<default>` in (per the project's convention)
+     so the branch is not behind the default.
+4. If the sync cannot complete cleanly (merge conflict, diverged history, or a dirty tree that would
+   conflict), **stop and surface it** rather than ingesting on top of stale or conflicted state — the
+   human resolves and re-runs. **Never discard unrelated working-tree changes** to force a sync.
+
+## The ordered pipeline (per source) — never reorder
+1. **Connector** validates (tenant guard + auth), reads its state cursor (first-run vs incremental),
+   fetches read-only, and writes a sanitized **source note** under `wiki/sources/<system>/` plus run
+   metadata. A connector writes *only* its source note + metadata — never synthesis/index/log/state.
+2. **Synthesis** (kernel): distill durable knowledge into the appropriate category pages, with
+   citations back to the source note. Weak/uncertain material → `wiki/open-questions/`, never asserted.
+3. **Index**: update `wiki/index.md`.
+4. **Log**: append a `wiki/log.md` entry (fixed operation vocabulary).
+5. **Verify**: `git diff --check`, secret/tenant/contamination scans, touched-file guard.
+6. **State**: advance the connector's `wiki/state/<system>/*.json` cursor — only now, after 1–5 pass.
+7. **Commit/PR**: commit only the ingestion changes per `config.git` policy. If the ingest started on
+   the default branch, create a dedicated ingestion branch first — never commit ingestion straight to
+   the default. Push the branch and **open a PR targeting the default remote branch** (via the host's
+   PR mechanism — e.g. `gh pr create --base <default>`). Before enabling auto-merge, feed the safety
+   scan output into `createWikiIngestPublicationPolicy` from `scripts/wiki-safety.mjs`. Enable
+   auto-merge only when `autoMergeAllowed` is true. `external-write` runs, redacted runs, and any run
+   with sensitive findings are the exception — open the PR **without** auto-merge so a human reviews
+   them before it lands. The PR summary must include the policy's safe review summary: counts and
+   entity types only, never raw values, ranges, tokens, source snippets, or scanner output. If
+   auto-merge cannot be enabled (the host doesn't support it, branch protection forbids it, or the
+   policy requires review), leave the PR open and note that a human must merge.
+
+## Rules
+- **Bookend every ingest with git hygiene:** sync the branch with the default remote branch *before*
+  writing (see "Before ingesting"), and *after* a successful ingest open a PR to the default remote
+  branch with auto-merge enabled when possible — never auto-merging `external-write`/sensitive runs.
+  `--dry-run` does neither (it writes nothing).
+- Source-note-before-synthesis; state advanced **only** after verification.
+- Project-scoped only; memory ingestion never touches global/Codex-global stores.
+- Respect `sourceRetention` and `sensitivity`; do not invent facts.
+- Before advancing state or committing, run the generated-output safety gate
+  (`scripts/verify-wiki-safety.mjs`) against the wiki files/source notes produced by
+  the ingest. The default built-in scan blocks unredacted private keys, tokens, and
+  common financial/person identifiers without printing raw values. Projects may
+  select `--scanner gitleaks` for local parity with Gitleaks, and may use
+  `--scanner trufflehog` as a stricter optional verification pass when installed;
+  if a selected scanner is unavailable, keep the ingest blocked for review.
+- Redaction and review policy is centralized in `scripts/wiki-safety.mjs`. Treat
+  `reviewRequired` or any summarized finding as a hard auto-merge stop. Use the
+  generated PR summary text as-is or preserve its shape so reviewers see entity
+  types and counts without raw sensitive values.
+- Connector execution and the connector contract are detailed in the connector skills (M2+); this
+  router defines and enforces the ordering and side-effect rules above.
+
+## Related
+`lisa-wiki-add-ingest` (scaffold a custom front-door that chains here), `lisa-wiki-query`,
+`lisa-wiki-lint`, `lisa-wiki-doctor`.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-lint/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: lisa-wiki-lint
+description: Health-check the LLM Wiki. Reports orphan pages, contradictions, stale claims, broken internal links, missing index/log coverage, structure-manifest violations, and secret/tenant leaks. Use periodically or before hardening a wiki. Read-only — it reports findings, it does not fix them.
+---
+
+# lisa-wiki-lint
+
+Run the wiki's integrity checks and report findings by severity. Lint is **read-only**: it diagnoses,
+it does not repair (use `/ingest`, `/setup`, or `/migrate` to fix).
+
+## What it checks (deterministic core via `scripts/lint-wiki.mjs`)
+- **Frontmatter** present/valid where required (per `schema/page-frontmatter.schema.json`).
+- **Index coverage**: every page appears in `wiki/index.md`; no index rows point at missing pages.
+- **Log coverage**: material changes have `wiki/log.md` entries.
+- **Links**: no broken internal links; no orphan pages (unreferenced and unlinked).
+- **State ordering**: no state cursor advanced without its source notes + synthesis + index + log.
+- **Structure**: files conform to `schema/wiki-structure.schema.json` (canonical locations).
+- **Safety**: secret patterns, tenant/contamination terms, stray binaries, child-repo contents
+  staged in wrapper mode.
+
+## What it checks (LLM-assisted)
+- **Contradictions** between claims; **stale** claims (older than the configured staleness window);
+  **coverage gaps** vs the wiki's stated `purpose`.
+
+## Output
+A report grouped by severity, with each item marked `PASS | WARN | FAIL`. During phased migration,
+legacy issues are reported as `WARN`; in hard-enforcement mode structural/integrity issues are `FAIL`.
+Read-only: lint prints the report and does not modify the wiki (it does not write a `LINT` log entry).
+
+## Related
+`lisa-wiki-doctor` (broader post-migration verification that runs lint among other checks),
+`lisa-wiki-ingest`, `lisa-wiki-setup`.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-migrate/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: lisa-wiki-migrate
+description: Migrate an existing, hand-rolled wiki implementation onto the lisa-wiki kernel — phased and compatibility-first, with a strict no-loss guarantee. Use when adopting lisa-wiki in a repo that already has its own wiki/, ingest skills, docs, or roles. Renaming things into the canonical shape is fine; losing functionality or data is not. Ends by running /doctor.
+---
+
+# lisa-wiki-migrate
+
+Move a repo's bespoke wiki onto the kernel without breaking it or producing one giant diff. Each
+phase is a reviewable change; nothing legacy is deleted until its replacement is parity-checked.
+
+## Migration invariant — rename, never lose
+Any unique command, ingest path, or role is migrated **as though created via** `/add-ingest`
+(front-door skill) or `/add-role` (subagent); wiki-ingest aliases (`*-wiki-ingest`, custom `/ingest`
+routers, …) are renamed to the canonical `/ingest`. **Loss of functionality or data is not
+acceptable** — for each migrated artifact, run the old path and the new path and diff the output
+before deleting the old one.
+
+## Phases (per repo; one reviewable change each)
+- **0 — Inventory.** Profile the repo: mode, root, categories, frontmatter coverage, log/index
+  format, source dirs, state files, connectors, runtime surfaces, MCP config, scripts, PR policy.
+  Write a pre/post manifest mapping every legacy page, source note, doc, command, ingest path, role.
+- **1 — Adopt kernel (no content rewrite).** Add `wiki/lisa-wiki.config.json`, render the contract
+  snapshot, add `wiki/state/README.md`, run validators in **warning** mode.
+- **1b — Documentation absorption & structure.** `scripts/absorb-docs.mjs` moves the host repo's own
+  docs (`docs/`, `specs/`, top-level docs) into `wiki/documentation/`, ingests them, and conforms to
+  the structure manifest; `scripts/rewrite-refs.mjs` rewrites every internal link/citation/index
+  entry (zero dangling links). Keep-in-place files stay at conventional paths. **Ask** the README
+  mode (default `rich`; `stub` only on explicit choice). Wrapper mode moves only host docs, never
+  child-project docs. Idempotent (source fingerprints); parity-checked.
+- **2 — Runtime consolidation.** Replace duplicated local wiki skills with the plugin's; bespoke ones
+  become `/add-ingest` front-doors or `/add-role` subagents. Claude commands become facades.
+- **3 — Connector consolidation.** Centralize shared connectors (e.g. Slack); keep org-specific ones
+  as contrib/overlay.
+- **4 — Normalize by touch.** New/touched pages get frontmatter; new logs use the canonical table;
+  legacy stays parseable until deliberately migrated.
+- **5 — Hard enforcement.** Flip validators to hard-fail (and enable CI) once the baseline is clean.
+
+## Finish
+Run `lisa-wiki-doctor --migration`. The repo is not considered migrated until the verdict is `READY`
+(or a human-approved `READY_WITH_WARNINGS`). Roll back by reverting the migration change.
+
+## Related
+`lisa-wiki-doctor`, `lisa-wiki-setup`, `lisa-wiki-add-ingest`, `lisa-wiki-add-role`.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-onboard-me/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: lisa-wiki-onboard-me
+description: Onboard a user to the project via its LLM Wiki. Interviews the user about themselves in relation to the project, captures that to project-scoped memory only, then gives a guided tour of what the project is and sample questions they can ask. Use when someone is new to the project or asks to be onboarded. Read-mostly — it does not open PRs or write PII into the wiki.
+---
+
+# lisa-wiki-onboard-me
+
+Bidirectional onboarding: learn who the user is *in relation to this project*, then teach them what
+the project is and how to use the wiki. The minimal project README points here.
+
+## Workflow
+1. **Interview** (brief): the user's role, goals, and what they intend to do in this project.
+2. **Capture** to **project-scoped memory only** — Claude's per-project memory; on Codex only if a
+   project-scoped memory store exists. If none exists, keep it session-local. **Never** write the
+   capture into global memory and **never** commit PII into the wiki.
+3. **Tour:** summarize the project from `wiki/start-here.md` + the wiki's `purpose`, show the folder
+   map (categories), and point at the key entry pages.
+4. **Sample questions:** offer a handful of `/query` prompts tuned to the user's role to get them
+   productive immediately.
+
+## Modes
+- Default: **read-mostly, no PR.**
+- `--save-memory`: persist the capture to project-scoped memory.
+- `--write-audience-note`: write a sanitized, **non-PII** audience/role note into the wiki via the
+  normal PR flow — only when `onboarding.allowAudienceNote: true` in config.
+
+## Rules
+- Project-scoped only; global Codex memory and the Chronicle store are never used.
+- Do not auto-create a staff role; offer `/add-role` only if the user is taking on a durable project
+  function (not merely onboarding).
+
+## Related
+`lisa-wiki-query`, `lisa-wiki-usage`, `lisa-wiki-add-role`.

package/plugins/lisa-wiki-devin/skills/lisa-wiki-query/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: lisa-wiki-query
+description: Answer a question from the LLM Wiki with citations. Reads the index, drills into relevant pages, and synthesizes a cited answer. Read-only by default; only files new synthesis back into the wiki when the user explicitly asks. Use when someone asks a question the wiki should be able to answer, or wants to explore what the wiki knows.
+---
+
+# lisa-wiki-query
+
+Answer from the wiki, with citations, without changing it (by default).
+
+## Workflow
+0. **Resolve the wiki root.** Run the bundled resolver from the installed Lisa wiki plugin, not from
+   the consumer repository's `scripts/` directory:
+   ```bash
+   node "${PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT:-${CURSOR_PLUGIN_ROOT:-$(npm root)/@codyswann/lisa/plugins/lisa-wiki}}}/scripts/ensure-wiki.mjs" --json
+   ```
+   Use the returned `wikiRoot` as the base for every read below — never assume `wiki/`. A local wiki
+   resolves instantly (no-op); a wiki whose `.lisa.config.json` declares `wiki.source.url` is
+   mirrored and refreshed transparently first. The script is offline-tolerant (it proceeds with the
+   existing mirror and warns rather than blocking), so freshness is guaranteed here and the caller
+   never has to think about it.
+1. Read `<wikiRoot>/index.md` to locate candidate pages; consult `<wikiRoot>/start-here.md` for orientation.
+2. Drill into the relevant synthesis pages and their cited source notes.
+3. Synthesize an answer. **Every claim cites its wiki page and/or source note.** If the wiki does not
+   support an answer, say so plainly rather than inventing one; suggest an `/ingest` that would fill
+   the gap. Only record the gap in `wiki/open-questions/` if the user explicitly asks (that is a
+   writeback — see step 4); never write it silently.
+4. **Writeback (opt-in only):** if — and only if — the user explicitly asks to persist new synthesis
+   discovered during the query, route it through the ingest pipeline so provenance/index/log/state
+   stay consistent, and log it as a `QUERY` operation. Never write back silently.
+
+## Rules
+- **Read-only by default.** No page edits, index/log changes, state advancement, or PRs unless the
+  user explicitly requests writeback.
+- Prefer the wiki's own content over outside knowledge; distinguish wiki-sourced facts from your own
+  reasoning.
+- Surface contradictions or stale claims you encounter as `/lint`-style findings rather than
+  silently picking one.
+
+## Related
+`lisa-wiki-ingest`, `lisa-wiki-lint`, `lisa-wiki-usage`.