@codyswann/lisa 2.24.0 → 2.25.0

package/plugins/lisa-wiki/scripts/validate-config.mjs

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+/**
+ * validate-config.mjs — dependency-free validator for wiki/lisa-wiki.config.json.
+ *
+ * Enforces the constraints described in schema/lisa-wiki-config.schema.json without
+ * requiring a JSON-Schema runtime, so it is portable to any downstream repo that
+ * installs the lisa-wiki plugin (no ajv / node_modules assumptions).
+ *
+ * Usage: node validate-config.mjs [path-to-config]
+ *   default path: wiki/lisa-wiki.config.json (relative to cwd)
+ * Exit code 0 = valid, 1 = invalid or unreadable.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+const MODES = ["embedded", "wrapper", "standalone", "subdir"];
+const SIDE_EFFECTS = ["read-only-ingest", "repo-write", "external-write"];
+const RETENTION = [
+  "raw-ok",
+  "sanitized-note-only",
+  "metadata-only",
+  "external-pointer-only",
+];
+const SENSITIVITY = ["public", "internal", "confidential", "restricted"];
+const SOURCE_LAYOUT = ["by-system", "by-category"];
+const README_MODE = ["rich", "stub", "preserve"];
+
+const configPath = path.resolve(
+  process.argv[2] ?? "wiki/lisa-wiki.config.json"
+);
+const errors = [];
+const err = msg => errors.push(msg);
+
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isStringArray(v) {
+  return Array.isArray(v) && v.every(x => typeof x === "string");
+}
+function checkEnum(value, allowed, label) {
+  if (value !== undefined && !allowed.includes(value)) {
+    err(`${label}: "${String(value)}" is not one of ${allowed.join(" | ")}`);
+  }
+}
+function checkType(value, type, label) {
+  if (value !== undefined && typeof value !== type) {
+    err(
+      `${label}: expected ${type}, got ${Array.isArray(value) ? "array" : typeof value}`
+    );
+  }
+}
+
+if (!fs.existsSync(configPath)) {
+  console.error(`✗ config not found: ${configPath}`);
+  process.exit(1);
+}
+
+let config;
+try {
+  config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+} catch (e) {
+  console.error(`✗ config is not valid JSON: ${e.message}`);
+  process.exit(1);
+}
+
+if (!isObject(config)) {
+  console.error("✗ config must be a JSON object");
+  process.exit(1);
+}
+
+// Required
+for (const key of ["schemaVersion", "org", "mode", "wikiRoot", "categories"]) {
+  if (config[key] === undefined) err(`missing required field: ${key}`);
+}
+checkType(config.schemaVersion, "string", "schemaVersion");
+checkType(config.org, "string", "org");
+checkType(config.displayName, "string", "displayName");
+checkType(config.purpose, "string", "purpose");
+checkEnum(config.mode, MODES, "mode");
+checkType(config.wikiRoot, "string", "wikiRoot");
+if (
+  typeof config.wikiRoot === "string" &&
+  (path.isAbsolute(config.wikiRoot) ||
+    config.wikiRoot.split(/[\\/]/).includes(".."))
+) {
+  err(
+    'wikiRoot: must be a relative path inside the repo (no absolute paths, no ".." traversal)'
+  );
+}
+checkType(config.frontmatter, "boolean", "frontmatter");
+if (
+  config.categories !== undefined &&
+  !(isStringArray(config.categories) && config.categories.length > 0)
+) {
+  err("categories: must be a non-empty array of strings");
+}
+checkEnum(config.sourceRetention, RETENTION, "sourceRetention");
+checkType(config.contaminationTerms, "object", "contaminationTerms");
+if (
+  config.contaminationTerms !== undefined &&
+  !isStringArray(config.contaminationTerms)
+) {
+  err("contaminationTerms: must be an array of strings");
+}
+
+if (config.sources !== undefined) {
+  if (!isObject(config.sources)) err("sources: must be an object");
+  else checkEnum(config.sources.layout, SOURCE_LAYOUT, "sources.layout");
+}
+if (config.git !== undefined) {
+  if (!isObject(config.git)) err("git: must be an object");
+  else {
+    checkType(config.git.prPerIngestion, "boolean", "git.prPerIngestion");
+    checkType(config.git.autoMerge, "boolean", "git.autoMerge");
+    checkType(config.git.targetBranch, "string", "git.targetBranch");
+    checkType(config.git.branchPrefix, "string", "git.branchPrefix");
+  }
+}
+if (config.readme !== undefined) {
+  if (!isObject(config.readme)) err("readme: must be an object");
+  else checkEnum(config.readme.mode, README_MODE, "readme.mode");
+}
+if (config.sensitivity !== undefined) {
+  if (!isObject(config.sensitivity)) err("sensitivity: must be an object");
+  else {
+    checkType(config.sensitivity.enabled, "boolean", "sensitivity.enabled");
+    checkEnum(config.sensitivity.default, SENSITIVITY, "sensitivity.default");
+  }
+}
+if (config.documentation !== undefined) {
+  if (!isObject(config.documentation)) err("documentation: must be an object");
+  else {
+    checkType(config.documentation.absorb, "boolean", "documentation.absorb");
+    if (
+      config.documentation.keepInPlace !== undefined &&
+      !isStringArray(config.documentation.keepInPlace)
+    ) {
+      err("documentation.keepInPlace: must be an array of strings");
+    }
+  }
+}
+if (config.onboarding !== undefined) {
+  if (!isObject(config.onboarding)) err("onboarding: must be an object");
+  else
+    checkType(
+      config.onboarding.allowAudienceNote,
+      "boolean",
+      "onboarding.allowAudienceNote"
+    );
+}
+
+if (config.connectors !== undefined) {
+  if (!isObject(config.connectors))
+    err("connectors: must be an object (name -> connector config)");
+  else {
+    for (const [name, c] of Object.entries(config.connectors)) {
+      if (!isObject(c)) {
+        err(`connectors.${name}: must be an object`);
+        continue;
+      }
+      checkType(c.enabled, "boolean", `connectors.${name}.enabled`);
+      if (c.sideEffects === undefined) {
+        err(
+          `connectors.${name}: missing required field "sideEffects" (every connector must declare its side-effect class so full ingest can skip external-write)`
+        );
+      } else {
+        checkEnum(
+          c.sideEffects,
+          SIDE_EFFECTS,
+          `connectors.${name}.sideEffects`
+        );
+      }
+    }
+  }
+}
+
+if (config.customConnectors !== undefined) {
+  if (!Array.isArray(config.customConnectors))
+    err("customConnectors: must be an array");
+  else {
+    config.customConnectors.forEach((c, i) => {
+      if (!isObject(c)) {
+        err(`customConnectors[${i}]: must be an object`);
+        return;
+      }
+      for (const k of ["name", "skill", "sourceSystem", "sideEffects"]) {
+        if (c[k] === undefined)
+          err(`customConnectors[${i}]: missing required field "${k}"`);
+      }
+      checkEnum(
+        c.sideEffects,
+        SIDE_EFFECTS,
+        `customConnectors[${i}].sideEffects`
+      );
+    });
+  }
+}
+
+if (config.staff !== undefined) {
+  if (!Array.isArray(config.staff)) err("staff: must be an array");
+  else {
+    config.staff.forEach((s, i) => {
+      if (!isObject(s)) {
+        err(`staff[${i}]: must be an object`);
+        return;
+      }
+      for (const k of ["id", "role"]) {
+        if (s[k] === undefined)
+          err(`staff[${i}]: missing required field "${k}"`);
+      }
+      checkEnum(s.sensitivity, SENSITIVITY, `staff[${i}].sensitivity`);
+      if (s.owns !== undefined) {
+        if (!isObject(s.owns)) err(`staff[${i}].owns: must be an object`);
+        else {
+          for (const ok of ["categories", "connectors", "skills"]) {
+            if (s.owns[ok] !== undefined && !isStringArray(s.owns[ok])) {
+              err(`staff[${i}].owns.${ok}: must be an array of strings`);
+            }
+          }
+        }
+      }
+    });
+  }
+}
+
+if (errors.length > 0) {
+  console.error(`✗ ${path.relative(process.cwd(), configPath)} is invalid:`);
+  for (const e of errors) console.error(`  - ${e}`);
+  process.exit(1);
+}
+
+console.log(`✓ ${path.relative(process.cwd(), configPath)} is valid.`);

package/plugins/lisa-wiki/scripts/verify-migration.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * verify-migration.mjs — the deterministic half of /doctor. Dependency-free.
+ *
+ * Composes validate-config + lint-wiki into a grouped report and writes
+ * <wikiRoot>/state/migration/doctor-report.json with an overall verdict. Groups D
+ * (runtime surfaces) and E (functional smoke) are SKIPPED here — the lisa-wiki-doctor
+ * SKILL performs those and merges its results.
+ *
+ * Usage: node verify-migration.mjs [--wiki <root>] [--config <path>] [--migration]
+ * Exit 0 = READY or READY_WITH_WARNINGS, 1 = NOT_READY.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "./_wiki-lib.mjs";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const argv = process.argv.slice(2);
+const opt = n => {
+  const i = argv.indexOf(n);
+  return i !== -1 ? argv[i + 1] : undefined;
+};
+const migration = argv.includes("--migration");
+const configPath = opt("--config");
+const { config } = loadConfig(configPath);
+const wikiRoot = path.resolve(opt("--wiki") ?? config?.wikiRoot ?? "wiki");
+
+const groups = { A: [], B: [], C: [], D: [], E: [], F: [], G: [] };
+const add = (g, id, status, message) => groups[g].push({ id, status, message });
+
+function runNode(script, args) {
+  const res = spawnSync("node", [path.join(scriptDir, script), ...args], {
+    encoding: "utf8",
+  });
+  return {
+    status: res.status ?? 1,
+    stdout: res.stdout ?? "",
+    stderr: (res.stderr ?? "") + (res.error ? `\n${res.error.message}` : ""),
+  };
+}
+
+// --- A. structure & config ------------------------------------------------
+const vc = runNode("validate-config.mjs", [
+  configPath ?? path.join(wikiRoot, "lisa-wiki.config.json"),
+]);
+add(
+  "A",
+  "config-valid",
+  vc.status === 0 ? "PASS" : "FAIL",
+  vc.status === 0
+    ? "config validates"
+    : `config invalid: ${(vc.stderr || vc.stdout).trim().split("\n").slice(0, 6).join("; ")}`
+);
+add(
+  "A",
+  "schema-version",
+  config?.schemaVersion ? "PASS" : "FAIL",
+  config?.schemaVersion
+    ? `schemaVersion ${config.schemaVersion}`
+    : "schemaVersion missing"
+);
+add(
+  "A",
+  "readme-mode",
+  config?.readme?.mode ? "PASS" : "WARN",
+  config?.readme?.mode
+    ? `readme.mode ${config.readme.mode}`
+    : "readme.mode not recorded (asked by /setup)"
+);
+add(
+  "A",
+  "purpose",
+  config?.purpose ? "PASS" : "WARN",
+  config?.purpose
+    ? "purpose set"
+    : "purpose not set (asked by /setup; feeds onboarding + contract)"
+);
+
+// --- A/B. lint (structure -> A, everything else -> B) ---------------------
+const lint = runNode("lint-wiki.mjs", [
+  "--wiki",
+  wikiRoot,
+  ...(configPath ? ["--config", configPath] : []),
+  "--json",
+]);
+let lintReport;
+try {
+  lintReport = JSON.parse(lint.stdout);
+} catch {
+  add(
+    "B",
+    "lint-run",
+    "FAIL",
+    `lint-wiki did not produce JSON: ${(lint.stderr || lint.stdout).trim().slice(0, 200)}`
+  );
+}
+if (lintReport) {
+  const structureItems = lintReport.items.filter(i => i.group === "structure");
+  const otherItems = lintReport.items.filter(i => i.group !== "structure");
+  if (structureItems.length === 0)
+    add("A", "structure", "PASS", "structure conforms to the manifest");
+  for (const i of structureItems)
+    add(
+      "A",
+      `structure:${i.group}`,
+      i.status,
+      `${i.message}${i.file ? ` (${i.file})` : ""}`
+    );
+  if (otherItems.length === 0)
+    add("B", "integrity", "PASS", "no integrity/safety findings");
+  for (const i of otherItems)
+    add(
+      "B",
+      `${i.group}`,
+      i.status,
+      `${i.message}${i.file ? ` (${i.file})` : ""}`
+    );
+}
+
+// --- C/D/E/F/G: deterministic-light + delegated to the doctor skill --------
+add(
+  "C",
+  "no-loss",
+  "SKIP",
+  "no-loss/parity needs the migration manifest from /migrate; dangling-link check is covered in B"
+);
+add(
+  "D",
+  "runtime",
+  "SKIP",
+  "runtime surfaces (commands/skills/subagents/MCP) verified by the lisa-wiki-doctor skill"
+);
+add(
+  "E",
+  "smoke",
+  "SKIP",
+  "functional smoke tests (ingest/query/lint/onboard) performed by the lisa-wiki-doctor skill"
+);
+add(
+  "F",
+  "mode",
+  config?.mode ? "PASS" : "FAIL",
+  config?.mode ? `mode: ${config.mode}; wikiRoot resolves` : "mode not set"
+);
+add(
+  "G",
+  "git-ci-dist",
+  "SKIP",
+  "git/CI/distribution checks performed by the lisa-wiki-doctor skill and CI"
+);
+
+// --- verdict --------------------------------------------------------------
+const all = Object.values(groups).flat();
+const isBlockingWarn = (item, group) =>
+  migration && (group === "A" || group === "B") && item.status === "WARN";
+let verdict = "READY";
+if (all.some(i => i.status === "FAIL")) verdict = "NOT_READY";
+else if (
+  Object.entries(groups).some(([g, items]) =>
+    items.some(i => isBlockingWarn(i, g))
+  )
+)
+  verdict = "NOT_READY";
+else if (all.some(i => i.status === "WARN")) verdict = "READY_WITH_WARNINGS";
+
+const reportObj = {
+  tool: "verify-migration",
+  deterministic: true,
+  wikiRoot: path.relative(process.cwd(), wikiRoot) || ".",
+  mode: config?.mode ?? null,
+  migration,
+  generatedAt: new Date().toISOString(),
+  verdict,
+  subset: "deterministic",
+  note: "Deterministic subset only. Groups C (no-loss/parity), D (runtime surfaces), E (functional smoke), and G (git/CI/distribution) are completed by the lisa-wiki-doctor skill, which merges its results into this report.",
+  groups,
+};
+
+const outPath = path.join(wikiRoot, "state", "migration", "doctor-report.json");
+fs.mkdirSync(path.dirname(outPath), { recursive: true });
+fs.writeFileSync(outPath, `${JSON.stringify(reportObj, null, 2)}\n`);
+
+const counts = all.reduce(
+  (acc, i) => ((acc[i.status] = (acc[i.status] ?? 0) + 1), acc),
+  {}
+);
+console.log(
+  `verdict: ${verdict}  (${["PASS", "WARN", "FAIL", "SKIP"].map(s => `${counts[s] ?? 0} ${s}`).join(", ")})`
+);
+console.log(`report → ${path.relative(process.cwd(), outPath)}`);
+console.log(
+  "  (deterministic subset — C/D/E/G completed by the /doctor skill)"
+);
+for (const i of all.filter(i => i.status === "FAIL" || i.status === "WARN")) {
+  console.log(`  ${i.status === "FAIL" ? "✗" : "⚠"} [${i.id}] ${i.message}`);
+}
+process.exit(verdict === "NOT_READY" ? 1 : 0);

package/plugins/lisa-wiki/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/skills/lisa-wiki-add-role/SKILL.md

@@ -0,0 +1,30 @@
+---
+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.
+
+## 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/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/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/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/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/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/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.