@cairnkeep/cli 1.0.2

package/opencode/plugins/memory-recall.ts

@@ -0,0 +1,132 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import fs from "node:fs"
+import path from "node:path"
+
+// OpenCode-native reimplementation of the Claude PreToolUse `memory-recall`
+// hook (OCP-02, D-10). Before an edit/write proceeds, surface AgentFS facts
+// and wiki pages that specifically mention the file about to be edited —
+// high-signal / low-noise: inject nothing on routine edits, only on a
+// specific stem match.
+//
+// Per 04-RESEARCH.md Pattern 2 / D-11, `tool.execute.before` cannot append
+// freeform non-blocking context the way Claude's `additionalContext` does.
+// The only confirmed mechanism is to `throw new Error(text)`, which the model
+// sees as the tool call's result and must retry — this blocks the first
+// attempt at a matched edit. A once-per-file-per-session guard prevents
+// re-throwing (and re-blocking) the same file forever (T-04-09).
+//
+// Known OpenCode limitation (Pitfall 4, anomalyco/opencode#5894): this hook
+// does not fire for tool calls issued by subagents spawned via the `task`
+// tool — subagent-issued edits silently bypass recall injection. Documented
+// scope limitation, not addressed by this phase.
+//
+// SERVER_ENTRY carries the install-rendered @@INFRA_ROOT@@ token (mirrors
+// memory-wakeup.ts / memory-capture.ts's existing convention — the sync
+// script, not this plugin, resolves it to the real repo root at install
+// time; never accept a runtime-overridable server path here — T-04-03).
+//
+// Fail-open everywhere (D-03): a missing server binary, missing
+// .agentfs/.planning, or any unexpected error must never block an edit.
+
+const SERVER_ENTRY = "@@INFRA_ROOT@@/mcp-memory-server/dist/index.js"
+const MIN_STEM_LENGTH = 4
+const MAX_MEMORY_HITS = 8
+const MAX_CONTEXT_LINES = 40
+
+// Confines a candidate wiki source file to inside `.planning/wiki/sources/`
+// using relative()-based containment (Phase 2 SEC-0001 pattern) — `resolve()
+// === join()` misses `../` traversal, so this checks the relative path
+// instead. The untrusted file path being edited is never concatenated into
+// this read path; it is only used earlier to derive the `stem` grep token.
+function isContained(baseDir: string, candidate: string): boolean {
+  const rel = path.relative(baseDir, candidate)
+  return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel)
+}
+
+export const MemoryRecallPlugin: Plugin = async ({ $, directory }) => {
+  const surfaced = new Set<string>()
+
+  return {
+    "tool.execute.before": async (input, output) => {
+      try {
+        if (input.tool !== "edit" && input.tool !== "write") return
+
+        const filePath: string | undefined = output.args?.filePath ?? output.args?.path
+        if (!filePath) return
+
+        const repo = directory
+        const agentfsDb = path.join(repo, ".agentfs", "project.db")
+        const wikiSourcesDir = path.join(repo, ".planning", "wiki", "sources")
+        const hasAgentfs = fs.existsSync(agentfsDb)
+        const hasWiki = fs.existsSync(wikiSourcesDir)
+        if (!hasAgentfs && !hasWiki) return
+
+        const base = path.basename(filePath)
+        const stem = base.slice(0, base.length - path.extname(base).length)
+        // Low-noise rule (D-10): skip tiny/generic stems that would match
+        // too broadly and turn this into noise on routine edits.
+        if (stem.length < MIN_STEM_LENGTH) return
+
+        // Once-per-file-per-session guard (T-04-09): after surfacing for
+        // this file once in this session, let subsequent edits/retries of
+        // the same file proceed unmodified — never re-block in a loop.
+        const dedupeKey = `${input.sessionID}:${filePath}`
+        if (surfaced.has(dedupeKey)) return
+
+        const sections: string[] = []
+
+        // 1. AgentFS project memory: filter the compact wakeup index by stem.
+        if (hasAgentfs && fs.existsSync(SERVER_ENTRY)) {
+          const res = await $`node ${SERVER_ENTRY} wakeup`.quiet().nothrow()
+          const idx = String(res.stdout ?? "").trim()
+          if (idx) {
+            const hitLines = idx
+              .split("\n")
+              .filter((line) => line.toLowerCase().includes(stem.toLowerCase()))
+              .slice(0, MAX_MEMORY_HITS)
+            if (hitLines.length > 0) {
+              sections.push(`## Relevant project memory for ${base}`, "", hitLines.join("\n"))
+            }
+          }
+        }
+
+        // 2. Wiki source pages (top level only) whose content mentions the
+        // stem. Reads are confined to wikiSourcesDir via isContained() —
+        // filePath (untrusted) only supplied the stem grep token above, it
+        // is never used to build a read path here.
+        if (hasWiki) {
+          const wikiHits: string[] = []
+          const entries = fs.readdirSync(wikiSourcesDir, { withFileTypes: true })
+          for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".md")) continue
+            const pagePath = path.join(wikiSourcesDir, entry.name)
+            if (!isContained(wikiSourcesDir, pagePath)) continue
+            const content = fs.readFileSync(pagePath, "utf8")
+            if (!content.toLowerCase().includes(stem.toLowerCase())) continue
+            const teaserMatch = content.match(/^- \*\*.*$/m)
+            const teaser = teaserMatch ? teaserMatch[0].slice(0, 160) : ""
+            wikiHits.push(`- [${entry.name}] ${teaser}`)
+          }
+          if (wikiHits.length > 0) {
+            sections.push(`## Relevant wiki pages for ${base}`, "", wikiHits.join("\n"))
+          }
+        }
+
+        // Inject only when there is something specific (high-signal /
+        // low-noise) — routine edits with no match proceed silently.
+        if (sections.length === 0) return
+
+        surfaced.add(dedupeKey)
+        const context = sections.join("\n\n").split("\n").slice(0, MAX_CONTEXT_LINES).join("\n")
+        throw new Error(`Memory recall (auto-injected for this file edit):\n\n${context}`)
+      } catch (err) {
+        // Re-throw our own intentional surface-context error (it carries the
+        // "Memory recall" prefix); swallow everything else to fail open —
+        // a lookup failure must never block an edit (D-03).
+        if (err instanceof Error && err.message.startsWith("Memory recall (auto-injected")) {
+          throw err
+        }
+      }
+    },
+  }
+}

package/opencode/plugins/memory-wakeup.ts

@@ -0,0 +1,102 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import fs from "node:fs"
+import path from "node:path"
+
+// OpenCode-native reimplementation of the Claude SessionStart `memory-wakeup`
+// hook (OCP-05, D-04). This plugin no longer shells out to
+// ~/.claude/hooks/memory-wakeup.sh — it surfaces the same four session-start
+// sections natively, calling the shared cairn-memory server directly and
+// reading the same .planning/ files, so OpenCode stands on its own with no
+// Claude-rendered assets on disk.
+//
+// SERVER_ENTRY carries the install-rendered @@INFRA_ROOT@@ token (mirrors the
+// Claude hook's substitution — the sync script, not this plugin, resolves it
+// to the real repo root at install time; never accept a runtime-overridable
+// server path here).
+//
+// Fail-open everywhere (D-03): a missing server binary, missing
+// .agentfs/.planning, or a failed subcommand must never wedge an OpenCode
+// session.
+
+const SERVER_ENTRY = "@@INFRA_ROOT@@/mcp-memory-server/dist/index.js"
+
+export const MemoryWakeupPlugin: Plugin = async ({ $, directory }) => {
+  return {
+    // No per-session dedupe: this hook fires more than once per session
+    // (including OpenCode's internal title-generation call, which happens
+    // before the first real agent turn and shares the same sessionID). A
+    // "surface once per session" Set keyed on sessionID would mark the
+    // session surfaced on that throwaway title-gen call and silently skip
+    // every real turn afterward — the OCP-05 acceptance gate never sees the
+    // injected context. `output.system` is a fresh array per call, so
+    // re-pushing on every invocation is both correct and required.
+    "experimental.chat.system.transform": async (input, output) => {
+      try {
+        const repo = directory
+        const agentfsDb = path.join(repo, ".agentfs", "project.db")
+        const wikiIndex = path.join(repo, ".planning", "wiki", "index.md")
+        const hasAgentfs = fs.existsSync(agentfsDb)
+        const hasWiki = fs.existsSync(wikiIndex)
+        if (!hasAgentfs && !hasWiki) return
+
+        const sections: string[] = []
+
+        if (hasAgentfs) {
+          const res = await $`node ${SERVER_ENTRY} wakeup`.quiet().nothrow()
+          const memory = String(res.stdout ?? "").trim()
+          sections.push("## Project memory (AgentFS)")
+          if (memory) sections.push(memory)
+        }
+
+        if (hasWiki) {
+          const wiki = fs.readFileSync(wikiIndex, "utf8").trim()
+          sections.push("## Wiki index")
+          if (wiki) sections.push(wiki)
+        }
+
+        // Surface open HARD wiki contradictions so the agent (and user) see
+        // them at session start without anyone having to remember to scan the
+        // register. Hard entries cannot both be correct and must be resolved
+        // before dependent work.
+        const contradictionsPath = path.join(repo, ".planning", "wiki", "CONTRADICTIONS.md")
+        if (fs.existsSync(contradictionsPath)) {
+          const raw = fs.readFileSync(contradictionsPath, "utf8")
+          const start = raw.indexOf("<!-- wiki:contradictions:open:start -->")
+          const end = raw.indexOf("<!-- wiki:contradictions:open:end -->")
+          if (start !== -1 && end !== -1 && end > start) {
+            const region = raw.slice(start, end)
+            const hardLines = region
+              .split("\n")
+              .filter((line) => /severity:\s*hard/i.test(line))
+            if (hardLines.length > 0) {
+              sections.push("## Open HARD contradictions — resolve before dependent work")
+              sections.push(hardLines.join("\n"))
+            }
+          }
+        }
+
+        // Surface staged memory candidates captured by the session-end
+        // capture plugin. These are extracted automatically from the last
+        // session but NOT yet written to AgentFS — /memory-review is the
+        // accept gate.
+        const stagingDir = path.join(repo, ".planning", "memory-staging")
+        if (fs.existsSync(stagingDir)) {
+          const staged = fs.readdirSync(stagingDir).filter((f) => f.endsWith(".json"))
+          if (staged.length > 0) {
+            sections.push(`## Staged memory candidates (${staged.length} session(s)) — UNREVIEWED`)
+            sections.push("Run /memory-review to accept (→ AgentFS) or discard these before doing other work.")
+          }
+        }
+
+        if (sections.length === 0) return
+
+        output.system.push(
+          "Session-start context (auto-surfaced by the memory-wakeup plugin — use it; do not ask the user to recall anything it contains):",
+        )
+        output.system.push(sections.join("\n\n"))
+      } catch {
+        // Fail open — never block a session because context surfacing failed.
+      }
+    },
+  }
+}

package/opencode/templates/security-finding-register.yaml.template

@@ -0,0 +1,51 @@
+version: 1
+project: REPLACE_WITH_PROJECT_NAME
+default_branch: REPLACE_WITH_DEFAULT_BRANCH
+last_security_audit:
+  at: null
+  branch: null
+  report: null
+findings: []
+
+# Finding entry shape:
+# - id: SEC-0001
+#   title: Unsafe shell command composition in archive import helper
+#   kind: command_execution
+#   severity: high
+#   status: open
+#   confidence: confirmed
+#   opened_by: security-audit
+#   opened_at: 2026-04-17T18:00:00Z
+#   branch: feature/archive-import
+#   threat_model: authenticated HTTP request
+#   exploit_surface: POST /api/import
+#   selected_file: src/import.rs
+#   investigation_target: shell command construction for imported filenames
+#   evidence:
+#     files:
+#       - src/import.rs
+#     commands:
+#       - cargo test --test import
+#     inputs:
+#       - multipart upload filename payload
+#     reports:
+#       - .planning/security/VALIDATED/SEC-0001-unsafe-shell-command-composition.md
+#   duplication:
+#     duplicate_of: null
+#     related_ids: []
+#   validation:
+#     verdict: accepted
+#     report_path: .planning/security/VALIDATED/SEC-0001-unsafe-shell-command-composition.md
+#     validated_at: 2026-04-17T18:00:00Z
+#     rationale: Reachable from the standard import flow without repo-external assumptions.
+#   remediation:
+#     status: open
+#     fixed_in: null
+#     verified_at: null
+#   tracking:
+#     provider_issue:
+#       project: group/project
+#       iid: "123"
+#       web_url: https://git.example.com/group/project/-/issues/123
+#       confidential: true
+#       created_at: 2026-04-17T18:00:00Z

package/opencode/templates/security-issue.md.template

@@ -0,0 +1,43 @@
+# Confidential Security Issue Draft
+
+- Project: REPLACE_WITH_PROJECT_NAME
+- Provider project: REPLACE_WITH_PROJECT
+- Finding ID: REPLACE_WITH_FINDING_ID
+- Severity: REPLACE_WITH_SEVERITY
+- Kind: REPLACE_WITH_KIND
+- Selected file: REPLACE_WITH_SELECTED_FILE
+- Investigation target: REPLACE_WITH_INVESTIGATION_TARGET
+- Threat model: REPLACE_WITH_THREAT_MODEL
+- Branch: REPLACE_WITH_BRANCH
+- Generated at: REPLACE_WITH_TIMESTAMP
+- Source command: /security-audit
+- Source report: REPLACE_WITH_REPORT_PATH
+
+## Summary
+
+REPLACE_WITH_SUMMARY
+
+## Reachability And Impact
+
+REPLACE_WITH_REACHABILITY_AND_IMPACT
+
+## Evidence
+
+REPLACE_WITH_EVIDENCE
+
+## Minimal Reproduction Or Exploit Sketch
+
+REPLACE_WITH_REPRODUCTION
+
+## Recommended Remediation
+
+REPLACE_WITH_REMEDIATION
+
+## Local Artifact References
+
+- Validated report: REPLACE_WITH_VALIDATED_REPORT
+- Audit report: REPLACE_WITH_AUDIT_REPORT
+
+## Confidentiality Note
+
+This issue was generated from a governed local security assessment and should remain confidential until remediation and disclosure decisions are made.

package/opencode/templates/security-policy.md.template

@@ -0,0 +1,29 @@
+# Security Assessment Policy
+
+This repository uses the governed security-assessment workflow to hunt for realistic security issues without turning normal development into uncontrolled offensive automation.
+
+## Branch Rules
+
+- Default branch: `REPLACE_WITH_DEFAULT_BRANCH`
+- Do not push feature work directly to `REPLACE_WITH_DEFAULT_BRANCH`.
+- Use feature branches for remediation and keep candidate reports under `.planning/security/CANDIDATES/` until a finding is validated.
+
+## Safety Rules
+
+- Run `/security-audit` only against this repository, repo-owned local processes, local files, and localhost services launched from this repo.
+- Do not target external hosts, staging, production, or third-party systems.
+- Keep proofs local, minimal, and non-destructive.
+- Do not attempt persistence, credential harvesting, lateral movement, or data exfiltration.
+
+## Finding Lifecycle
+
+- Open or refresh findings with `/security-audit`.
+- Keep rejected or duplicate candidates in run history only; do not copy them into the canonical ledger.
+- Only accepted findings belong in `.planning/security/FINDINGS.yaml` and `.planning/security/VALIDATED/`.
+- Close or downgrade findings only after remediation or explicit acceptance on the default branch.
+
+## Review Expectations
+
+- Critical and high-severity accepted findings should block merge until triaged by a human.
+- Treat the repo-local findings ledger as the shared state for severity, status, and remediation progress.
+- If a run cannot prove reachability convincingly, prefer rejection over speculative acceptance.

package/opencode/templates/security-report.md.template

@@ -0,0 +1,43 @@
+# Security Audit Report
+
+- Project: REPLACE_WITH_PROJECT_NAME
+- Audit scope: diff | full
+- Base ref: REPLACE_WITH_BASE_REF
+- Head ref: REPLACE_WITH_HEAD_REF
+- Threat model: REPLACE_WITH_THREAT_MODEL
+- Focus path: REPLACE_WITH_FOCUS_PATH
+- Generated at: REPLACE_WITH_TIMESTAMP
+- Generated by: security-audit
+
+## Summary
+
+- Accepted findings: 0
+- Rejected candidates: 0
+- Selected file: REPLACE_WITH_SELECTED_FILE
+- Investigation target: REPLACE_WITH_INVESTIGATION_TARGET
+
+## Accepted Findings
+
+### SEC-0001
+
+- Title: REPLACE_WITH_TITLE
+- Kind: command_execution
+- Severity: high
+- Report: REPLACE_WITH_REPORT_PATH
+
+#### Why this matters
+
+REPLACE_WITH_IMPACT
+
+#### Recommended next step
+
+REPLACE_WITH_NEXT_STEP
+
+## Rejected Candidates
+
+- None
+
+## Safety Notes
+
+- This run was limited to repo-local analysis and locally launched services or local files.
+- Proofs should stay minimal and non-destructive.

package/opencode/templates/wiki-contradictions.md.template

@@ -0,0 +1,31 @@
+# Wiki Contradiction Register
+
+> Persistent register of contradictions flagged across `.planning/wiki/`.
+> Updated in place by `/wiki-lint`. Unlike per-run REPORTS, this file is the
+> durable record — lint opens and resolves entries here rather than emitting
+> write-and-forget reports. Raw repo docs, tests, interfaces, config, and code
+> remain canonical; this register only tracks where the *derived* wiki disagrees.
+
+## Severity Taxonomy
+
+- **soft** — non-blocking, contextual difference. Pages can coexist; flagged for awareness. No action required unless it accumulates.
+- **scope-mismatch** — the two claims apply to different scopes/contexts and do not truly conflict. Recorded so a future reader is not confused; coexists.
+- **hard** — genuinely conflicting claims that cannot both be correct. Must be resolved before downstream work relies on either page. Surface at session start.
+
+## How To Use
+
+- `/wiki-lint` writes/updates entries here on every run. Do not delete open entries by hand — resolve the underlying page disagreement, then let lint (or a `/wiki-ingest --refresh`) flip the status to `resolved`.
+- At session start, scan the **Open** section for `severity: hard`. Surface any hard/open items before doing work that depends on the affected pages.
+- An entry is `resolved` only after the conflicting wiki page(s) have actually been reconciled to the canonical source — not merely acknowledged.
+
+## Open
+
+<!-- wiki:contradictions:open:start -->
+- None.
+<!-- wiki:contradictions:open:end -->
+
+## Resolved
+
+<!-- wiki:contradictions:resolved:start -->
+- None.
+<!-- wiki:contradictions:resolved:end -->

package/opencode/templates/wiki-index.md.template

@@ -0,0 +1,40 @@
+# REPLACE_WITH_PROJECT_NAME Knowledge Wiki
+
+> Derived, sparse, citation-heavy notes for faster repository understanding.
+> Canonical truth remains in raw repository docs, tests, interfaces, config, and code.
+
+## How To Use This Wiki
+
+- Start here to find source summaries, optional topic and entity pages, reusable query answers, and lint reports.
+- Follow the cited canonical sources before treating any derived claim as settled.
+- If the wiki conflicts with raw sources, trust the raw sources and note the contradiction.
+
+## Sources
+
+<!-- wiki:sources:start -->
+- None yet.
+<!-- wiki:sources:end -->
+
+## Topics
+
+<!-- wiki:topics:start -->
+- None yet.
+<!-- wiki:topics:end -->
+
+## Entities
+
+<!-- wiki:entities:start -->
+- None yet.
+<!-- wiki:entities:end -->
+
+## Queries
+
+<!-- wiki:queries:start -->
+- None yet.
+<!-- wiki:queries:end -->
+
+## Reports
+
+<!-- wiki:reports:start -->
+- None yet.
+<!-- wiki:reports:end -->

package/opencode/templates/wiki-lint-report.md.template

@@ -0,0 +1,38 @@
+# Wiki Lint Report
+
+- Project: REPLACE_WITH_PROJECT_NAME
+- Generated at: REPLACE_WITH_TIMESTAMP
+- Scope: REPLACE_WITH_SCOPE
+- Advisory status: Raw repository docs, tests, interfaces, config, and code remain canonical.
+
+## Summary
+
+- Missing citations: 0
+- Orphan pages: 0
+- Stale claims: 0
+- Contradicted claims: 0 (hard: 0 / scope-mismatch: 0 / soft: 0)
+- Missing obvious pages: 0
+- Broken cross-references: 0
+
+> Contradiction entries are also written to `.planning/wiki/CONTRADICTIONS.md`,
+> the persistent register. This report is a snapshot; the register is durable.
+
+## Contradictions (severity-tagged)
+
+- None.
+
+## High Signal Findings
+
+- None.
+
+## Medium Signal Findings
+
+- None.
+
+## Low Signal Findings
+
+- None.
+
+## Suggested Next Steps
+
+- Keep the wiki sparse, citation-heavy, and aligned to canonical raw sources.

package/opencode/templates/wiki-log.md.template

@@ -0,0 +1,11 @@
+# Wiki Log
+
+This log records wiki ingests, reusable query writebacks, and advisory lint runs.
+
+Raw repository docs, tests, interfaces, config, and code remain canonical.
+
+## Entries
+
+<!-- wiki:entries:start -->
+- Scaffold initialized. Append timestamped `wiki-ingest`, `wiki-query --writeback`, and `wiki-lint` entries below.
+<!-- wiki:entries:end -->

package/opencode/templates/wiki-policy.md.template

@@ -0,0 +1,47 @@
+# Project Knowledge Wiki Policy
+
+This repository uses `.planning/wiki/` as a derived, sparse, citation-heavy compiled-knowledge layer.
+
+## Canonical Sources
+
+- Raw repository docs, ADRs, tests, interfaces, config, and code remain the canonical sources of truth.
+- The wiki must never overrule the default-branch implementation or canonical repository documents.
+- Use wiki pages to summarize, cross-link, and preserve reusable answers, not to duplicate every file.
+
+## Branch Rules
+
+- Project: `REPLACE_WITH_PROJECT_NAME`
+- Default branch: `REPLACE_WITH_DEFAULT_BRANCH`
+- Update wiki pages on the same branch as the source changes they depend on.
+- If the wiki and raw sources disagree, record the contradiction explicitly instead of silently normalizing it.
+
+## Provenance Rules
+
+- Every non-trivial claim in `sources/`, `topics/`, `entities/`, and `queries/` should cite canonical source paths.
+- Prefer direct repo-relative paths and specific sections or line ranges when practical.
+- Record `Last reviewed` on every derived page.
+- If freshness is uncertain, say so directly.
+
+## Scope Rules
+
+- Do not auto-generate a wiki page per code file.
+- Prefer source summaries for repository docs, design docs, ADRs, standards, and a small number of stable interfaces or subsystems.
+- Topic and entity pages are optional and rare. Create them only when the same synthesis is needed across three or more sources or recurring queries. An empty `topics/`, `entities/`, or `queries/` directory is a healthy, expected state — a sources-only wiki is the normal stable shape for engineering repos, not a gap to fill.
+
+## Contradiction Severity
+
+When the wiki disagrees with a canonical source or with itself, classify and record it in `.planning/wiki/CONTRADICTIONS.md` (the persistent register) using one of:
+
+- **soft** — non-blocking, contextual difference; coexists, no action required.
+- **scope-mismatch** — the claims apply to different scopes and do not truly conflict; recorded to prevent confusion.
+- **hard** — genuinely conflicting claims that cannot both be correct; must be resolved before downstream work relies on either page. Surfaced at session start.
+
+`/wiki-lint` opens and resolves entries in the register in place. An entry is `resolved` only after the conflicting wiki page has actually been reconciled to the canonical source, not merely acknowledged. Do not silently normalize a contradiction away — if raw sources disagree, record it explicitly.
+
+## Maintenance
+
+- Use `/wiki-ingest <path>` to create a source summary, or `/wiki-ingest <path> --refresh` to re-sync an existing summary to the current canonical source (re-read, update only changed stable facts, bump `Last reviewed`, log a `wiki-refresh` entry). Run a refresh whenever the MR/PR or code state behind a page changes.
+- Use `/wiki-query --writeback <question>` only when the answer is likely reusable.
+- Use `/wiki-lint` for advisory checks on citations, freshness, contradictions, discoverability, and link hygiene. Lint also updates the persistent `CONTRADICTIONS.md` register.
+- At session start, scan `CONTRADICTIONS.md` for any `severity: hard` open entries and surface them before doing dependent work.
+- Lint reports under `REPORTS/` are advisory snapshots; the register is the durable record. Raw docs and code remain the source of truth.

package/opencode/templates/wiki-query-answer.md.template

@@ -0,0 +1,26 @@
+# Query: REPLACE_WITH_QUERY_TITLE
+
+- Asked at: `REPLACE_WITH_TIMESTAMP`
+- Question: REPLACE_WITH_QUESTION
+- Answer status: `derived`
+- Last reviewed: `REPLACE_WITH_TIMESTAMP`
+
+## Answer
+
+REPLACE_WITH_ANSWER
+
+## Wiki Pages Consulted
+
+- REPLACE_WITH_WIKI_PAGE
+
+## Canonical Sources
+
+- REPLACE_WITH_CANONICAL_SOURCE
+
+## Contradictions And Freshness Notes
+
+- None noted.
+
+## Suggested Follow-up
+
+- None.

package/opencode/templates/wiki-source-summary.md.template

@@ -0,0 +1,33 @@
+# Source: REPLACE_WITH_SOURCE_LABEL
+
+- Canonical source: `REPLACE_WITH_SOURCE_PATH`
+- Source kind: `REPLACE_WITH_SOURCE_KIND`
+- Derived status: `active`
+- Last reviewed: `REPLACE_WITH_LAST_REVIEWED`
+
+## Why This Source Matters
+
+REPLACE_WITH_WHY_THIS_MATTERS
+
+## Stable Facts
+
+- REPLACE_WITH_FACT_AND_CITATION
+
+## Contradictions And Freshness Notes
+
+- None noted.
+
+  When a contradiction exists, tag it with a severity so `/wiki-lint` can mirror
+  it into `CONTRADICTIONS.md`. Use one of:
+  - `Contradiction severity: soft` — contextual, coexists.
+  - `Contradiction severity: scope-mismatch` — different scopes, not a true conflict.
+  - `Contradiction severity: hard` — genuinely conflicting, must resolve.
+  Add a `Status: open` (or `resolved`) line so lint can track it deterministically.
+
+## Related Wiki Pages
+
+- None yet.
+
+## Canonical References
+
+- `REPLACE_WITH_SOURCE_PATH`