owfadev 0.0.1 → 0.3.1

package/.meta/plugins/core/hot/PLUGIN.md

@@ -0,0 +1,40 @@
+# hot: Hot Cache
+
+## Design Summary
+
+- **Why it exists**: the recent-change digest page — the lowest-cost entry for an agent entering the repository, read hot first then dig deeper as needed; opposite the index retrieval entry, hot is the entry to "now". Merely a cache: if lost, rebuildable from log and the repository
+- **Key rulings**:
+  - Hard-cap trio — 25 entries, 5 days, 200 characters per entry: parameters calibrated against the original repository's measurements — per-entry median 389 characters, maximum 4959, runaway proven; the mechanical authoritative source is pipeline.py
+  - The evict-before-write duty: outside the window means delete; eviction and truncation are performed mechanically by the script, no asking — the cache does not bloat
+  - The only derived page with hand-written links: broken links are checked but it is not an inbound-link source, per the link contract
+
+## Structure
+
+- Single file `wiki/hot.md`, organized in sections — Recent map, Recent save, Recent query, Recent check, etc.
+- Entry: date plus wikilink plus a one-sentence essence, at most 200 characters, a hard cap
+
+## Invariants
+
+- Wholly regenerable: hot is merely a cache; if lost, rebuildable from log and the repository
+- Rolling window: outside the window means delete; eviction and truncation are performed mechanically by the script, no asking
+
+## Config
+
+```yaml config
+hot.max_entries: 25        # mechanical authoritative source in pipeline.py; the script source is the rule list
+hot.max_days: 5
+hot.max_entry_chars: 200   # parameters calibrated against the original repository's measurements: per-entry median 389 chars, max 4959, runaway proven
+```
+
+## Changelog
+
+- 0.10 2026-09-23: added the wiki dependency edge — inner-side plugins attach to wiki, aligning with the domain 0.1 declaration; omitted from the 2026-09-22 domain-ization batch
+- 0.9 2026-09-13: usage's type parameter gained its value-set source — same as log, pointing to the log block of the AGENTS injection region
+- 0.8 2026-09-13: injection source moved to the manifest — removed Checks, Usage, Inject, Attachments sections, md returned to pure documentation
+- 0.7 2026-09-13: established the "Usage" section — the write-side contract is projected by the command's injection region, a single text source
+- 0.6 2026-09-12: manifest dropped layer — layering abolished: injection order changed to dependency topology plus alphabetical order, direction checks removed
+- 0.5 2026-09-12: identifiers anglicized — section headers, attached-audit contract keys, type enums, pipeline call parameters
+- 0.4 2026-09-10: writing mechanized — via pipeline.py hot, eviction and truncation performed by the script; the authoritative source of parameters moved to the script source
+- 0.3 2026-09-10: manifest gained layer: derived — layering established: derived layer, zero dependencies
+- 0.2 2026-09-09: per-entry length cap of 200 characters, plus the evict-before-write duty written down
+- 0.1 2026-09-08: converted from the original wiki hot structure

package/.meta/plugins/core/hot/PLUGIN.yaml

@@ -0,0 +1,15 @@
+id: hot
+schema_version: 1
+version: 0.10
+depends:
+  - wiki
+updated: 2026-10-06
+attachment:
+  - "wiki/hot.md — single-file hot cache"
+fields: {}
+inject: "Hot cache `wiki/hot.md`: recent-change digest (≤25 entries, <5 days, ≤200 chars per entry); agents read this page first on entering the repository; evict out-of-window entries before writing"
+usage:
+  - Writing entries (mechanical, automatic): `python .meta/scripts/pipeline.py hot <type> "<wikilink + one-sentence essence>"` (type value set same as log, see the log block of the AGENTS injection region); window eviction and truncation are performed by the script
+checks:
+  - Window out of bounds (>25 entries / >5 days / >200 chars per entry) → run `pipeline.py hot <type> "<backfill>"` once, or wait for the next write to converge naturally then re-check
+  - Contradiction with log (log has records while hot shows no trace) → warning

package/.meta/plugins/core/index/PLUGIN.md

@@ -0,0 +1,39 @@
+# index: Index
+
+## Design Summary
+
+- **Why it exists**: a cheap retrieval entry, the second layer of query, a pointer structure for drilling down level by level. A derived-layer aggregation page — born of the parent's offloading need, not a directory's "supposed duty"
+- **Key rulings**:
+  - Overflow-offloading scheme, final shape in 0.10: a small repository lists all content directly in the root index, one page serves all — the engineering repository went 4-to-1, test-repo measured 8-to-1; wherever content grows, the disclosure boundary appears there. The cure is always subdirectories, never index changes
+  - Pure-function rebuild, never hand-edited: the offloading split is a function of the structural status quo; same structure, same result, no historical state
+  - Indexes do not invent structure: an index only reflects structure, never hints how directories should be organized — silent on content quality
+  - The root index is the version self-statement spot: format_version is the page-format contract version, bumped on incompatible changes
+
+## Structure
+
+- The root `wiki/index.md` is always present: a format_version frontmatter, i.e. the page-format contract version, bumped on incompatible changes — the root index is the version self-statement spot; it directly lists reachable pages, taking in this directory and un-split subtrees, full-path wikilinks
+- Other directories' `index.md` are born of overflow offloading: when some index list — page entries plus directory entries — overflows the window, subtrees are split out in descending page-count order, ties by name order, into their own index, until it fits; applies recursively
+- Entry = wikilink plus description — frontmatter `description` first, falling back to the body's first non-empty non-structural line truncated at 80 characters; concept pages grouped by type; a split-out subdirectory's entry line carries the subtree count; an empty subtree keeps a 0-page visibility line, with no link, outside the broken-link graph
+- `wiki/tags.md`: the tag-to-page reverse index, aggregating the tag plugin's field
+
+## Invariants
+
+- Index pages are wholly regenerable, never hand-edited: aggregate only, originate nothing; pure-function rebuild — the offloading split is a function of the structural status quo, same structure same result, no historical state
+- Window parameters defer to the `pipeline.py` source code; the script source is the rule list; obsolete old indexes after merge-back into the parent are mechanically deleted on rebuild
+- Indexes do not invent structure: the existence and content of an index only reflect structure, never hint how directories should be organized; when a level's flat files overflow the window, they are listed over the window as-is; splitting directories belongs to humans and territory plugins
+- Consistent with the actual page set; reserved-name files, i.e. index and log, the wiki root's derived pages, i.e. hot and tags, the archive/ subtree, and the tmp/ temporary zone are invisible to the derived layer: not concept pages, not indexed
+
+## Changelog
+
+- 0.13 (2026-10-06) inject line compressed to pointer density (issue #12 layer discipline) — procedural detail lives in usage / PLUGIN.md / skills- 0.12 2026-09-23: added the wiki dependency edge — inner-side plugins attach to wiki, aligning with the domain 0.1 declaration; omitted from the 2026-09-22 domain-ization batch
+- 0.11 2026-09-19: concept-page detection excluded wiki/tmp/ — the temporary zone stays out of indexes and tags, in step with the tmp plugin's establishment
+- 0.10 2026-09-19: the per-directory scheme changed to the overflow-offloading scheme — list window of at most M, subtree-descending splits, the root always present, empty-subtree visibility lines; small repositories collapse to a single index, the engineering repository 4-to-1, test-repo measured 8-to-1; invariants gained "pure-function rebuild" and "indexes do not invent structure"
+- 0.9 2026-09-13: the format_version semantics entered the in-repository disclosure — expert review: no provenance inside the instance; index-description truncation gained an ellipsis, pipeline `_cut`
+- 0.8 2026-09-13: injection source moved to the manifest — removed Checks, Usage, Inject, Attachments sections, md returned to pure documentation
+- 0.7 2026-09-13: established the "Usage" section — the write-side contract is projected by the command's injection region, a single text source
+- 0.6 2026-09-13: the root index's version self-statement field renamed format_version — the format contract internalized, the plugin's external contract references zeroed
+- 0.5 2026-09-12: manifest dropped layer — layering abolished: injection order changed to dependency topology plus alphabetical order, direction checks removed
+- 0.4 2026-09-12: identifiers anglicized — section headers, attached-audit contract keys, type enums, pipeline call parameters
+- 0.3 2026-09-10: per-directory indexing, progressive disclosure — root page carrying the version self-statement field, subdirectories carrying counts; rebuilds scripted as pipeline.py index and tags, LLMs never hand-write
+- 0.2 2026-09-10: manifest gained layer: derived — layering established: derived layer, depending only on tag
+- 0.1 2026-09-08: converted from the original wiki index, i.e. the master-catalog rules; changed to whole rebuilds only, no incremental writes

package/.meta/plugins/core/index/PLUGIN.yaml

@@ -0,0 +1,18 @@
+id: index
+schema_version: 1
+version: 0.13
+depends:
+  - tag
+  - wiki
+updated: 2026-10-06
+attachment:
+  - "wiki/index.md — root index (always present; carries format_version; directly lists reachable pages)"
+  - "Per-directory index.md — born of the overflow-offloading scheme (split out when a list overflows the window, disappearing on rebuild once merged back into the parent)"
+  - "wiki/tags.md — tag reverse index"
+fields: {}
+inject: "Index overflow-offloading: root wiki/index.md always present (carries format_version), listing all reachable pages full-path; a list over the window (params in pipeline source) splits subtrees into their own index.md by descending page count; wiki/tags.md unchanged; aggregate only, never hand-edited, pure-function rebuild (pipeline.py index); indexes invent no structure — overflow lists in full as-is, the cure is subdirectories"
+usage:
+  - Post-write rebuild (mechanical, automatic): `python .meta/scripts/pipeline.py index` (index — overflow-offloading scheme, including deletion of obsolete old indexes after merge-back) and the same script's `tags` (tag reverse index); LLMs never hand-write indexes
+checks:
+  - Deviation between indexes and the actual page set (including merged-back indexes pending deletion) → fixed by running `pipeline.py index` to rebuild (idempotent; no diff means consistent); same for tags (`pipeline.py tags`)
+  - Traces of hand editing → warning

package/.meta/plugins/core/instance-git/PLUGIN.md

@@ -0,0 +1,39 @@
+# instance-git: the snapshot ledger of real use
+
+The instance library's git is a **snapshot surface** — a time machine and an undo button, not a collaboration tool. This plugin declares the contract and mechanically audits the red lines; it never executes git writes itself, and neither does the kernel (the journal is the kernel's own ledger).
+
+## Three authors, one ledger
+
+| Snapshot | Author | When | Scope |
+|---|---|---|---|
+| kernel snapshot | — none. The kernel never touches git; its mechanical facts live in the kernel journal | — | — |
+| session snapshot | the agent, on the user's behalf | every transaction close (package transactions after validate goes green; session close commits the dirty tree) | the whole tree |
+| manual snapshot | the human | any time, freely | anything |
+
+Beyond these, usage (remotes, branches, bundles, whether to rebase) is the user's own; the framework does not regulate it.
+
+## The minimal contract
+
+1. **Message format**: `type: summary` — the same shape as a wiki/log entry (type from the log enumeration: map / save / query / check / plugin / todo / profile / other; optional `[domain]` tag). Git history becomes the mechanical twin of the log
+2. **Red lines, exactly three**:
+   - credentials and session files never enter git
+   - adding an ignore must sweep already-tracked matches out of tracking
+   - project-domain entities keep their own git — the instance discloses, never hosts
+3. **The recovery entrance**: a check-flagged page → `git log -- <page>` (who changed it) → `git checkout -- <page>` (yesterday's truth back)
+
+## Attached audit (read-only)
+
+`scripts/check.py` runs on `check` and reports:
+
+| Check | Catches |
+|---|---|
+| ignore-rule vs tracked-file residue | files matching an ignore rule that are still tracked (the dsh-router lesson, mechanized) |
+| credential-pattern filenames | `*.ses`, `.env*`, `*cookie*`, `*secret*`, `credentials*` tracked |
+| sensitive faces + remote | a remote is configured while `vault/` / `cuhksz/` faces are tracked — confirm it is private |
+| entity self-git tracked | `projects/*/` carrying their own `.git` yet tracked by the parent |
+
+Not a git repository at the root (no `.git`)? The contract is dormant — one info line, no warnings.
+
+## One upgrade path, FYI
+
+Pure local (the default) → a `git bundle` file copied elsewhere → a private remote. Before any remote, sweep the sensitive faces (vault/ assets, cuhksz course records — anything you would not hand to a stranger); public remotes are out of the question for an instance.

package/.meta/plugins/core/instance-git/PLUGIN.yaml

@@ -0,0 +1,15 @@
+id: instance-git
+schema_version: 1
+version: 0.1
+depends: []
+updated: 2026-10-13
+attachment: []
+fields: {}
+inject: "Instance git = the snapshot ledger of real use (rollback + time machine), never a collaboration face: three authors — the kernel never touches git (the journal is its ledger), the agent commits at transaction close (type: summary, log-shaped), humans snapshot freely; red lines — credentials/session files never tracked, adding an ignore sweeps tracked matches out, project entities keep their own git (the instance discloses, never hosts); recovery entrance: git log -- <page> → git checkout -- <page>; beyond this contract, usage is the human's own"
+usage:
+  - Package transactions: after validate goes green, one commit at close — mechanical + semantic in one snapshot (message `plugin: <verb> <pkg> [v<version>]`); see the plugin command's Transaction close section
+  - Session close: commit the dirty tree the session leaves (`type: summary`, optional `[domain]` tag — the same shape as a log entry); no other rhythm is mandated
+  - Recovery entrance: a check-flagged page → `git log -- <page>` (who changed it, when) → `git checkout -- <page>` (yesterday's truth back)
+  - Upgrade path FYI: pure local (default) → a `git bundle` copied elsewhere → a private remote (sweep sensitive faces first); public remotes are out of the question for an instance
+checks:
+  - Mechanical (attached audit, read-only): ignore-rule vs tracked-file residue; credential-pattern filenames tracked; sensitive faces tracked while a remote is configured; projects/*/ self-git repos tracked by the parent — all warnings, the script never writes

package/.meta/plugins/core/instance-git/scripts/check.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""instance-git attached audit: read-only checks of the snapshot-contract red lines.
+
+Never writes, never prompts. Four checks:
+1. ignore-rule vs tracked-file residue (files matching an ignore rule yet still tracked)
+2. credential-pattern filenames among tracked files
+3. sensitive faces (vault/, cuhksz/) tracked while a remote is configured
+4. projects/*/ self-git repos tracked by the parent
+Not a git repository at the root -> contract dormant, one info line.
+"""
+import fnmatch
+import os
+import subprocess
+
+IGNORE_BASE = ["*.ses", ".env", ".env.*", "*cookie*", "*secret*", "credentials*", "*.pem"]
+SENSITIVE_TOP = {"vault", "cuhksz"}
+
+
+def _git(root, *args):
+    return subprocess.run(["git", "-C", root, *args], capture_output=True, text=True, timeout=30)
+
+
+def _ignore_rules(root):
+    """Parse the root .gitignore: non-negated patterns only, trailing slashes stripped."""
+    path = os.path.join(root, ".gitignore")
+    rules = []
+    if not os.path.exists(path):
+        return rules
+    for line in open(path, encoding="utf-8").read().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or line.startswith("!"):
+            continue
+        rules.append(line.rstrip("/"))
+    return rules
+
+
+def _matches_rule(rel, rule):
+    """Directory-prefix or fnmatch, mirroring gitignore spirit closely enough for an audit."""
+    if fnmatch.fnmatch(rel, rule) or fnmatch.fnmatch(rel, rule + "/*"):
+        return True
+    parts = rel.split("/")
+    for i in range(1, len(parts)):
+        if fnmatch.fnmatch("/".join(parts[:i]), rule):
+            return True
+    return False
+
+
+def check(ctx):
+    issues = []
+    root = ctx.root
+    if not os.path.exists(os.path.join(root, ".git")):
+        issues.append({"level": "info", "message": "instance-git: no .git at the root — snapshot contract dormant"})
+        return issues
+    tracked = [l for l in _git(root, "ls-files").stdout.splitlines() if l.strip()]
+    if not tracked:
+        issues.append({"level": "info", "message": "instance-git: nothing tracked — snapshot contract dormant"})
+        return issues
+    # 1. ignore vs tracked residue
+    rules = _ignore_rules(root)
+    residue = sorted({rel for rel in tracked for rule in rules if _matches_rule(rel, rule)})
+    if residue:
+        issues.append({"level": "warning", "message": "instance-git: ignored-but-tracked residue (sweep out: git rm --cached) — " + ", ".join(residue[:6]) + (" …" if len(residue) > 6 else "")})
+    # 2. credential patterns
+    hits = sorted({rel for rel in tracked for pat in IGNORE_BASE if fnmatch.fnmatch(os.path.basename(rel), pat)})
+    if hits:
+        issues.append({"level": "warning", "message": "instance-git: credential-pattern files tracked (red line 1) — " + ", ".join(hits[:6])})
+    # 3. sensitive faces + remote
+    remotes = _git(root, "remote").stdout.split()
+    tops = {rel.split("/")[0] for rel in tracked if "/" in rel}
+    if remotes and tops & SENSITIVE_TOP:
+        issues.append({"level": "warning", "message": f"instance-git: remote(s) configured ({', '.join(remotes)}) while sensitive faces ({', '.join(sorted(tops & SENSITIVE_TOP))}/) are tracked — confirm private; public remotes are out of the question"})
+    # 4. entity self-git tracked by the parent (a gitlink shows as bare "projects/<name>", a stray add as "projects/<name>/...")
+    pdir = os.path.join(root, "projects")
+    if os.path.isdir(pdir):
+        for name in sorted(os.listdir(pdir)):
+            if os.path.isdir(os.path.join(pdir, name, ".git")):
+                leaked = [rel for rel in tracked if rel == f"projects/{name}" or rel.startswith(f"projects/{name}/")]
+                if leaked:
+                    issues.append({"level": "warning", "message": f"instance-git: projects/{name}/ keeps its own git yet {len(leaked)} entr{'y' if len(leaked) == 1 else 'ies'} tracked by the parent (red line 3 — disclose, never host)"})
+    return issues
+
+
+if __name__ == "__main__":
+    import types as _t
+    _r = check(_t.SimpleNamespace(root=os.getcwd(), pages=[]))
+    if not _r:
+        print("instance-git attached audit: all clean")
+    for _i in _r:
+        print(_i["level"] + ": " + _i["message"])

package/.meta/plugins/core/language/PLUGIN.md

@@ -0,0 +1,38 @@
+# language: output language and writing
+
+## Design Overview
+
+- **Why it exists**: output-language choice and term translations were previously scattered across a one-line charter clause (AGENTS principle 7) and stray conventions in each domain — nowhere to look up across sessions, translations drifting with the session (today '检索增强生成', tomorrow '检索增强式生成'). This plugin establishes one declaration page: language and writing baselines in writing, the term table mechanically consultable, a rule to follow before the pen touches the page
+- **Position in the family**: a global cross-cutting plugin, declaration-page pattern (structure precedent) — the plugin governs the mechanism, concrete norms are instance configuration landing on the page; division of labor with user-profile — the profile governs dynamic cognition of the individual user (evidence-driven, convergence-style), this page governs the instance-level constant writing regime (declarative, true for all sessions); division of labor with tag — tag governs `tags` field word forms, this page governs body prose
+- **Key rulings**:
+  - Absence tolerance: page or key absent = follow the session language (conversation language is the output language); a language norm is an optional enhancement, not a requirement — isomorphic with structure; proper nouns, code, paths, commands, and file names always keeping their original form is the language-neutrality discipline, invariant under configuration
+  - Language neutrality (2026-10-04 batch): the framework hard-codes no specific language — output language is entirely instance data (declaration page values or session language); layered ruling: source alignment (materials are in whatever language they are in, e.g. exam language follows course materials) belongs to domain-plugin discipline, reader alignment (what language lectures and solutions use) belongs to this page's canonical keys (the teaching/annotation precedent); 'Chinese-first' demoted to a development-period instance fact (AGENTS principle 7) — when English unification finally comes, project docs change, not the architecture
+  - A default baseline, not a mandate: the domain plugins' source-alignment discipline takes precedence over this page; this page never overrides in-domain self-managed language discipline
+  - Emergence-based term registry: annotate the original on first occurrence, register only after recurring hits — the email source-archive emergence philosophy, preventing a page-per-term explosion
+  - Two-form partitioning: the two frontmatter mappings are the mechanical zone (regenerably maintained), the body distillation section is append-only (translation rationale, usage examples, abandoned renderings)
+- **Rejected alternatives**:
+  - Merging into user-profile: observation-convergence and instance configuration are heterogeneous in nature, and the term table is a shared asset, not personal cognition — rejected
+  - Writing into AGENTS principle 7: the charter is law, not data, and the term table keeps growing — rejected
+  - A page per term (`wiki/terms/`): terms are lookup pieces, not written artifacts; a single-page mapping suffices, with an upgrade path to discuss if it overflows the window — rejected
+- **Mechanism back-references**: declaration-page absence-tolerance precedent structure; emergence precedent the email source archive; block mappings draw on the wiki frontmatter minimal YAML subset; usage lands on the save command via usage_routes — the first application of the source-side routing mechanism, 2026-10-04
+
+## Structure
+
+- `wiki/language.md` — the writing declaration page, type: language. Frontmatter `language` block mapping = canonical key → one-sentence rule (open vocabulary, self-extended by instances); `terms` block mapping = term original → unified translation (single-line value); the body `## Distillations` section holds long notes, append-only
+- Zero commands: reading is consuming (hung on save via usage_routes), writing goes through conversational editing; v0.1 sets no registration command
+
+## Invariants
+
+- This page is a default baseline, not a mandate: the domain plugins' source-alignment discipline takes precedence; this page never touches in-domain self-managed discipline
+- Three boundary non-involvements: forms of address and personal dynamic preferences belong to user-profile, tag word forms belong to tag, in-domain term tables (the bb courseware glossary) are self-managed in-domain and never lifted up
+- Canonical keys are an open vocabulary, not enumerated by the architecture (principle 3)
+- Emergence-based term registration; direct human edits are legitimate, the agent never overwrites human-defined entries (objections reported)
+- Page absence = a legal state (follow the session language); no error, no proxy-creation
+- The framework presets no specific language: output language is entirely instance data (declaration page values or session language); Chinese is merely a development-period fact of this project
+
+## Changelog
+
+- 0.5 (2026-10-23): restore the register discipline in manifest usage routed to save and align the field description; generated command projections now retain it across rebuilds (issue #26).
+- 0.4 (2026-10-07): register key — the `register` canonical key governs the audience reading level (program default first/second-year undergraduates, AGENTS principle 12), consumed by bb-teach (teaching) / bb-quiz (annotation) / save (PR #23, renumbered past master's 0.3 compression)
+- 0.3 (2026-10-06) inject line compressed to pointer density (issue #12 layer discipline) — procedural detail lives in usage / PLUGIN.md / skills- 0.2 2026-10-04: language neutralization — the absence fallback changed from 'Chinese-first' to 'follow the session language', Chinese demoted to a development-period instance fact; layered ruling: source alignment belongs to domain plugins, reader alignment to this page's canonical keys (the teaching/annotation precedent); same batch as bb-teach/bb-quiz v0.4
+- 0.1 2026-10-04: established — the writing declaration page with two-form partitioning (language/terms block mappings + distillation section), absence tolerance, default-baseline-not-mandate, emergence-based term registry; usage_routes landing on save, first application; depends wiki

package/.meta/plugins/core/language/PLUGIN.yaml

@@ -0,0 +1,23 @@
+id: language
+schema_version: 1
+version: 0.5
+depends:
+  - wiki
+updated: 2026-10-23
+attachment:
+  - "wiki/language.md — the writing declaration page (output-language and writing-baseline ontology: frontmatter language/terms block mappings + body distillation section)"
+  - "scripts/check.py — attached audit (territory placement / terms empty values / declaration page presence)"
+fields:
+  language: block mapping (declaration page) — canonical key → one-sentence rule (open vocabulary, e.g. default/teaching/annotation/register); output language and writing baseline — register = the writing register (audience reading level, default first/second-year undergraduates), consumed by bb-teach, bb-quiz and save
+  terms: block mapping (declaration page) — term original → unified translation (single-line value); the cross-session translation-consistency lookup piece
+usage_routes:
+  - save
+inject: "Writing declaration page wiki/language.md (type: language): language block mapping = key → one-sentence rule (consumer precedents: teaching bb-teach, annotation bb-quiz, register = audience reading level, program default first/second-year undergraduates per AGENTS principle 12) + terms = original → unified translation; body distillation notes append-only; the agent reads it before producing written artifacts; page or key absent → session language (proper nouns/code/paths keep original); default baseline not a mandate — domain source-alignment disciplines take precedence; terms emergence-based (register after recurring hits); direct human edits legitimate"
+usage:
+  - Register discipline: follow the language.register audience reading level when writing saved artifacts; absent register uses the program baseline (first/second-year undergraduates), while explicit user audience requirements and domain source-alignment rules take precedence
+  - When to read: read the declaration page before writing any artifact (wiki pages, documents, lecture distillates); page or key absent = follow the session language (conversation language is the output language); proper nouns, code, paths, commands, and file names always keep their original form (language neutrality, invariant under configuration) — the framework presets no specific language; Chinese is merely an instance fact of this project's development period (AGENTS principle 7)
+  - Term discipline: when writing hits a term, consult the `terms` mapping first — if tabled, follow the table; otherwise annotate the original in parentheses on first occurrence (e.g. '检索增强生成 (RAG)'), registering only after recurring hits (emergence-based); a registered entry = a single line original→translation, long notes (translation rationale, usage examples) go to the body distillation section
+  - Layering: a default baseline, not a mandate — the domain plugins' source-alignment discipline (exam language follows samples/course materials) takes precedence over this page; tag word forms belong to tag, forms of address and personal dynamic preferences belong to user-profile, in-domain term tables (the bb courseware glossary) are self-managed within the domain — none of these are restated on this page
+  - Maintenance: the `language` mapping is human-defined first, the agent may propose; the `terms` mapping may be registered by the agent but never overwrites human-defined entries (objections reported); the body distillation section is append-only
+checks:
+  - Mechanical (attached-audit script `scripts/check.py`, executed discovery-style by audit): type: language landing outside `wiki/language.md` → error; terms empty values → warning; declaration page absent → info (session-language fallback tolerated)

package/.meta/plugins/core/language/scripts/check.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""language plugin attached audit: declaration page existence, territory misplacement, empty terms values.
+
+A missing declaration page = tolerated default posture (legal, info); an empty terms value is a registry defect.
+"""
+
+
+def check(ctx):
+    issues = []
+    decl = False
+    for rel, fm, _body in ctx.pages:
+        if fm.get("type") == "language" and rel != "language.md":
+            issues.append({"level": "error", "message": f"{rel}: type: language outside the declaration page (territory misplacement)"})
+        if rel == "language.md":
+            decl = True
+            terms = fm.get("terms") or {}
+            for k, v in terms.items():
+                if not str(v).strip():
+                    issues.append({"level": "warning", "message": f"terms empty value: {k} (translated name missing; fill in or remove)"})
+    if not decl:
+        issues.append({"level": "info", "message": "no language declaration page (default posture tolerated)"})
+    return issues

package/.meta/plugins/core/link/PLUGIN.md

@@ -0,0 +1,39 @@
+# link: Link Layer
+
+## Design Summary
+
+- **Why it exists**: wiki's ontological structure — reference relations between pages; links are where the value of knowledge lies, thinking happens where things collide. A field plugin: owns the link syntax and the related and aliases fields, and hosts the graph-property health checks — broken links and orphans
+- **Key rulings**:
+  - Full names, not titles: `[[page full name]]` = the relative path within wiki/ minus one .md — an extension of "the path is the origin" into the link layer; truncated references forbidden; same-name ambiguity resolved by path, disambiguation never by guessing
+  - Broken links are not defects: a broken link may be knowledge not yet written down, TODO placeholders are a normal state; warning not error; when unsure, better to leave a TODO than to guess
+  - Inbound sources for orphan detection count only concept pages: derived pages and tmp don't count — otherwise the index links everything and orphans never trigger; mechanical-registration territory pages drop to info, registration being the norm; notes knowledge pages stay warning
+  - The syntax conventions must enter the injection line: when the conventions lived only in the attached-audit source, a zero-prior agent was bound to guess wrong, proven in 0.8 — a lesson specimen of disclosure completeness
+
+## Structure
+
+- `related` field: YAML list; full names of pages related to this page's topic, i.e. wikilinks
+- `aliases` field: YAML list; this page's aliases and short names, for link resolution and retrieval
+- wikilink syntax conventions: `[[page full name]]`. **Full name = the page file's relative path within wiki/ minus the trailing .md**, e.g. `notes/X`; an md asset's proxy file is `<name>.md.md`, its full name `vault/<name>.md`, only one removed. Truncated partial references are forbidden; long compound names must be written in full; on same-name ambiguity, include the path
+
+## Invariants
+
+- Link targets must resolve: the full name hits a page, or hits some page's aliases
+- Broken links are not silent but not treated as defects: a broken link may be knowledge not yet written down, TODO placeholders are a normal shape; when unsure of the target, better to leave a TODO than to guess
+- Orphan detection is a graph property: only a page with no inbound links and no related references is an orphan; **inbound sources count only concept pages** — index, hot, log, tags and other derived pages, the archive/ subtree, and the tmp/ temporary zone with its draft broken-link exemption — none count as link sources, otherwise the index links everything and orphans never trigger. Territory-value pages — registry territory values except session, i.e. source, lark, calendar, structure, todo, profile, project, tmp, the mechanical-registration kinds — having no inbound links yet is the registration norm, downgraded to info; notes knowledge pages stay warning. hot is the only derived page with hand-written links: its broken links are checked but it is not an inbound-link source
+
+## Changelog
+
+- 0.14 2026-09-23: added the wiki dependency edge — inner-side plugins attach to wiki, aligning with the domain 0.1 declaration; omitted from the 2026-09-22 domain-ization batch
+- 0.13 2026-09-19: _concept excluded wiki/tmp/ — the temporary zone is not a link source and is exempt from graph checks; a draft's broken link = not yet written down, closed upon promotion
+- 0.12 2026-09-19: the orphan info set changed to dynamically reading registry type.values except session — new territory types covered automatically, the hardcoded set retired, prerequisite for project's establishment
+- 0.11 2026-09-19: the orphan info set extended to all territory values except session — calendar smoke testing confirmed false-positive warnings on calendar.md and month pages; the judgment aligned with registry territory values, no more squeezing toothpaste type by type
+- 0.10 2026-09-19: the orphan-downgrade criterion changed from path-based to type-based, source and lark treated alike — the lark-family landing smoke test confirmed: new pointer pages falsely warned en masse
+- 0.9 2026-09-13: attached audit gained the hot hand-written broken-link scan; orphan grading — proxy pages dropped to info; expert review: warning inflation; the injection line gained the md-asset full-name example
+- 0.8 2026-09-13: the full-name definition entered the injection line and Structure — test-repo walkthrough finding: the conventions lived only in the attached-audit source, a zero-prior agent was bound to guess wrong
+- 0.7 2026-09-13: injection source moved to the manifest — removed Checks, Inject, Attachments sections, md returned to pure documentation
+- 0.6 2026-09-12: manifest dropped layer — layering abolished: injection order changed to dependency topology plus alphabetical order, direction checks removed
+- 0.5 2026-09-12: identifiers anglicized — section headers, attached-audit contract keys, type enums, pipeline call parameters
+- 0.4 2026-09-11: mechanical items absorbed into the attached-audit script — broken links, garbled text, orphans; new alias-ambiguity as error, and one-way related as info; the hub list kept as a semantic item
+- 0.3 2026-09-10: broken links downgraded to warning — knowledge not yet written down, not a defect; the orphan-detection scope written down, derived pages don't count as inbound sources
+- 0.2 2026-09-10: manifest gained layer: field — layering established: field layer, zero dependencies
+- 0.1 2026-09-09: newly established — link syntax and the related and aliases fields; the broken-link check converted from the original lint; the orphan check moved over from notes

package/.meta/plugins/core/link/PLUGIN.yaml

@@ -0,0 +1,16 @@
+id: link
+schema_version: 1
+version: 0.14
+depends:
+  - wiki
+updated: 2026-10-06
+attachment:
+  - "Cross-cutting plugin, no files of its own: owns the link-syntax conventions and the related / aliases fields"
+  - "scripts/check.py — attached audit (broken links / garbled text / alias ambiguity / orphans / one-way related)"
+fields:
+  related: "YAML list, full-name wikilinks of related pages"
+  aliases: "YAML list, aliases/short names, for link resolution"
+inject: "Link syntax `[[page full name]]` — full name = the relative path within wiki/ minus the trailing .md (e.g. `notes/X`, pdf asset proxy `vault/a.pdf`, md asset proxy `vault/<name>.md`, only one removed); truncated references forbidden, same-name ambiguity resolved by path; fields `related` / `aliases`; broken link = warning (not yet written down), orphan (no inbound links and no references, derived pages don't count as sources) = warning for notes knowledge pages, info for territory-value registration pages (dynamically reads registry type.values, except session)"
+checks:
+  - Mechanical items (attached-audit script `scripts/check.py`, executed on audit discovery): broken link (target is neither a page full name nor any page's aliases) → warning; hand-written broken link in hot → warning (not counted as an inbound-link source); garbled link (target contains the U+FFFD replacement character, including related items) → error; alias ambiguity (two pages declaring the same aliases, resolution indeterminate) → error; orphan page (no inbound links and no related references, inbound sources counting concept pages only) → warning for notes knowledge pages, info for territory-value registration pages (registry territory values except session, having no inbound links yet being the registration norm); one-way related (A lists B while B does not list back) → info
+  - Semantic items (check command): inbound-link density top list → info item (evidence for hub emergence, no alert)

package/.meta/plugins/core/link/scripts/check.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""link plugin attached audit: mechanical items (broken links / garbled text / alias ambiguity / orphans / one-way related).
+
+The in-link density top list (evidence for hub emergence) is an analytical item, under the check command's semantic items.
+Concept-page determination is isomorphic to the pipeline: reserved names (index/log), wiki-root derived pages (hot/tags),
+the archive/ subtree and the tmp/ temporary zone are not link sources and are exempt from graph checks (derived pages link
+to everything, otherwise orphans would never trigger; a broken link in a draft = not yet written down, closed upon promotion).
+hot is the only derived page with handwritten links: its broken links are checked, but it is not an in-link source and stays
+out of the orphan graph.
+Territory-value pages (registry type.values except session — the mechanical-registry kind) having no in-links yet is the
+registry norm: orphans are downgraded to info level there, while native pages (notes knowledge pages) stay warning. The
+territory value set is read dynamically from registry, so new territory types are covered automatically — no per-type upkeep.
+"""
+import os
+import re
+
+WIKILINK_RE = re.compile(r"\[\[([^\]|]+)(?:\|[^\]]*)?\]\]")
+RESERVED_NAMES = {"index.md", "log.md"}
+ROOT_DERIVED = {"hot.md", "tags.md"}
+
+
+def _as_list(v):
+    if v is None:
+        return []
+    return v if isinstance(v, list) else [v]
+
+
+def _name_of(rel):
+    return rel[:-3] if rel.endswith(".md") else rel
+
+
+def _concept(rel):
+    d, _, fn = rel.rpartition("/")
+    if fn in RESERVED_NAMES:
+        return False
+    if d == "" and fn in ROOT_DERIVED:
+        return False
+    if rel.startswith("tmp/") or d.startswith("tmp/") or d == "tmp":
+        return False  # temporary zone: not a link source, exempt from graph checks (draft broken-link exemption)
+    return not (rel.startswith("archive/") or d.startswith("archive/") or d == "archive")
+
+
+def _target(text):
+    """related item or wikilink text → target full name (tolerates both [[x|display]] and bare-name forms)."""
+    return str(text).strip().lstrip("[").split("|")[0].strip().rstrip("]")
+
+
+TERRITORY_LABELS = {"source": "proxy page", "lark": "pointer page", "calendar": "time page",
+                    "structure": "declaration page", "todo": "delegation page", "profile": "profile page", "project": "project page"}
+
+
+def _territory_types(root):
+    """Read registry type.values (closed set of territory values) dynamically; session excluded (knowledge backbone, orphan hint is meaningful there)."""
+    try:
+        text = open(os.path.join(root, ".meta", "protocol", "registry.yaml"), encoding="utf-8").read()
+        m = re.search(r"values: \[([^\]]+)\]", text)
+        return {v.strip() for v in m.group(1).split(",") if v.strip()} - {"session"}
+    except OSError:
+        return set(TERRITORY_LABELS)
+
+
+def check(ctx):
+    issues = []
+    pages = list(ctx.pages)
+    names = {_name_of(rel) for rel, _fm, _b in pages}
+    # alias table and ambiguity (error: makes [[alias]] resolution indeterminate)
+    alias_map = {}
+    for rel, fm, _b in pages:
+        for a in _as_list(fm.get("aliases")):
+            alias_map.setdefault(str(a).strip(), set()).add(_name_of(rel))
+    for a, owners in sorted(alias_map.items()):
+        if len(owners) > 1:
+            issues.append({"level": "error", "message": f"alias {a!r} ambiguous: {', '.join(sorted(owners))} — resolution indeterminate, needs adjudication"})
+    referenced, related_map = set(), {}
+    for rel, fm, body in pages:
+        if not _concept(rel):
+            continue
+        src = _name_of(rel)
+        for m in WIKILINK_RE.finditer(body):
+            t = m.group(1).strip()
+            if "\ufffd" in t:
+                issues.append({"level": "error", "message": f"{rel}: garbled link [[{m.group(1)}]]"})
+            elif t not in names and t not in alias_map:
+                issues.append({"level": "warning", "message": f"{rel}: broken link [[{t}]] (neither a page full name nor any aliases)"})
+            referenced.add(t)
+        rels = [_target(r) for r in _as_list(fm.get("related"))]
+        related_map[src] = {t for t in rels if t}
+        for t in rels:
+            if "\ufffd" in t:
+                issues.append({"level": "error", "message": f"{rel}: related garbled item {t!r}"})
+            elif t not in names and t not in alias_map:
+                issues.append({"level": "warning", "message": f"{rel}: related broken link [[{t}]]"})
+            referenced.add(t)
+    # hot: handwritten-link surface (broken links checked; not an in-link source, out of the orphan graph)
+    for rel, _fm, body in pages:
+        if _name_of(rel) != "hot":
+            continue
+        for m in WIKILINK_RE.finditer(body):
+            t = m.group(1).strip()
+            if "\ufffd" in t:
+                issues.append({"level": "error", "message": f"{rel}: garbled link [[{m.group(1)}]]"})
+            elif t not in names and t not in alias_map:
+                issues.append({"level": "warning", "message": f"{rel}: hot broken link [[{t}]] (handwritten summary link no longer valid)"})
+    # orphans (no in-links and no related references; sources count concept pages only; territory-value registry pages downgraded to info)
+    territory = _territory_types(ctx.root)
+    for rel, fm, _b in pages:
+        if not _concept(rel):
+            continue
+        if _name_of(rel) not in referenced:
+            ptype = fm.get("type")
+            if ptype in territory:
+                label = TERRITORY_LABELS.get(ptype, "territory page")
+                issues.append({"level": "info", "message": f"{rel}: {label} has no in-links yet (registry norm, not an alert)"})
+            else:
+                issues.append({"level": "warning", "message": f"{rel}: orphan page (no in-links and no related references)"})
+    # related one-way (informational: asymmetry hint, not an error)
+    for src, rels in sorted(related_map.items()):
+        for t in sorted(rels):
+            if t in related_map and src not in related_map[t]:
+                issues.append({"level": "info", "message": f"{src}: related one-way (lists [[{t}]], other side does not list back)"})
+    return issues

package/.meta/plugins/core/log/PLUGIN.md

@@ -0,0 +1,58 @@
+# log: Run Log
+
+## Design Summary
+
+- **Why it exists**: the repository's operation journal — what was done to the repository and when. Opposite of hot: hot is the present that gets evicted, log is append-only never-deleted history. The mandatory bridge guarantees that anything any domain produces always leaves a trace — an instance of the topological-completeness invariant, see Section 5 of mechanics
+- **Key rulings**:
+  - Entries are append-only and never rewritten, prepended at the top: modifying a historical entry = error; archival moves don't change a single character of an entry
+  - Rolling window rather than an infinite ledger: the main file holds at most 100 entries; overflow is mechanically archived, grouped by entry month, to `wiki/archive/<month>/log.md` — freshness and full history both served
+  - Writing is mechanized: via `pipeline.py log`; capacity checks and archiving are performed by the script; the authoritative source of parameters is the script source
+  - Domain tags, since 0.15: in-domain transaction entries carry `[domain]`; domainless transactions omit it — the journal becomes searchable by domain
+
+## Structure
+
+- Single file `wiki/log.md`; entries prepended at the top, newest on top
+- Entry format: `- YYYY-MM-DD <type> [<domain>]: one-sentence summary`, may contain wikilinks; the domain tag is omissible, i.e. domainless transactions
+- Type enum: map, save, query, check, plugin, todo, other; instances may extend
+
+## Bridge: mandatory
+
+Recording bridge: the operation-journal home shared by all domain plugins across domains, constitution principle 11. Attachment cardinality **mandatory** — all domain bases must depend on this plugin; kernel validate verifies completeness; the topology guarantees: anything a domain produces leaves a trace. Format authority lives in this plugin's usage, projected to the consumption sites, per the division-of-labor ruling. This section details: in-domain transaction entries carry the domain tag `[domain]`, e.g. `[bb]`; domainless transactions omit it; written via `pipeline.py log --domain`.
+
+## Invariants
+
+- Entries are append-only and never rewritten — the object of "append-only, never delete" is entry content, not the file's physical location; modifying a historical entry = error
+- Every entry must carry a date, accurate to the day
+- Archival moves don't change a single character of entry content
+
+## Rolling
+
+The main file is a rolling window, not an infinite ledger:
+
+- Window of at most 100 entries, about 14k characters; the mechanical authoritative source is `pipeline.py`, this section is the semantic description
+- On overflow the oldest segment is automatically moved, grouped by entry month, into `wiki/archive/YYYY-MM/log.md`; entry content unchanged by a single character, only moved. The archive file is the reserved name log.md of its directory — reserved-name files are not concept pages, naturally exempt from frontmatter
+- The archive directory falls into the immutable zone; compression and consolidation still require human confirmation, see constitution principle 5
+
+## Config
+
+```yaml config
+log.max_entries: 100     # main-file rolling window, entries
+log.max_chars: 14000     # window character cap, approximate
+```
+
+## Changelog
+
+- 0.15 2026-10-02: global-domain batch one — established the mandatory bridge, i.e. the recording bridge; domain bases must depend on it, kernel verifies completeness; entries gained the omissible `[domain]` tag; pipeline log gained the `--domain` parameter
+- 0.13 2026-09-23: added the wiki dependency edge — inner-side plugins attach to wiki, aligning with the domain 0.1 declaration; omitted from the 2026-09-22 domain-ization batch
+- 0.12 2026-09-14: type value set extended with todo — the home of the todo plugin's task-settlement events; history goes to log, the todo page keeps only the active working set
+- 0.11 2026-09-13: usage's type parameter gained its value-set source — the log block of the AGENTS injection region, removing cross-block guess points
+- 0.10 2026-09-13: injection source moved to the manifest — removed Checks, Usage, Inject, Attachments sections, md returned to pure documentation
+- 0.9 2026-09-13: established the "Usage" section — the write-side contract is projected by the command's injection region, a single text source
+- 0.8 2026-09-12: manifest dropped layer — layering abolished: injection order changed to dependency topology plus alphabetical order, direction checks removed
+- 0.7 2026-09-12: identifiers anglicized — section headers, attached-audit contract keys, type enums, pipeline call parameters
+- 0.6 2026-09-11: the undated-entry check moved into the attached-audit script, main file and archive checked alike; the historical-modification audit kept as a semantic item, verifiable via git
+- 0.5 2026-09-10: writing mechanized — via pipeline.py log; capacity checks and archiving performed by the script; the authoritative source of parameters moved to the script source
+- 0.4 2026-09-10: archive path rerouted to `wiki/archive/YYYY-MM/log.md` — grouped by entry month; reserved names exempt from frontmatter
+- 0.3 2026-09-10: manifest gained layer: derived — layering established: derived layer, zero dependencies
+- 0.2 2026-09-09: the rolling-archive mechanism written down, window of 100 entries; the type enum gained "query"; parameters calibrated against the original repository's measurements, averaging 139 characters per entry
+- 0.1 2026-09-08: converted from the original wiki log rules