@maci0/dsh-cordis-review 0.17.1

package/lib/types/cli.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * `cordis-review-check [options] [root]`: print closed-form CORDIS tags.
+ *
+ * One engine (ast-grep, auto-detected) for every tag; without the binary each
+ * covered file warns on stderr and yields an LLM-fallback hit.
+ *
+ * @module dsh-cordis-review/cli
+ */
+export {};

package/lib/types/frontmatter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Frontmatter reader for the bundled `SKILL.md` files.
+ *
+ * Almost every skill header is flat: `key: value`, a quoted scalar, or a
+ * `|`/`>` block of same-indent lines. A local reader handles that subset and
+ * changes nothing; it returns `undefined` the moment the block contains
+ * anything it cannot prove it understood (a nested map, a list, a quoted
+ * scalar with an escape, a more-indented or empty line inside a block scalar,
+ * a flow collection, a YAML-tag indicator). The caller then loads `yaml`
+ * dynamically and re-parses that one file, so the fallback stays the contract
+ * and a static `import('yaml')` no longer costs every boot ~11ms of CPU for a
+ * mapping it never needed.
+ *
+ * The fast path may only claim a block whose value is *provably* what `yaml`
+ * produces. Anything it cannot prove (a `\r` anywhere in the source, a quoted
+ * key, a duplicate key, a `#` in a value, a scalar that has a typed YAML form
+ * (`0x10`, `0o17`, `.inf`, `.nan`, `1_000`, `+5`, `-0`, leading zeros), a
+ * `+` keep-chomped block scalar) is refused and re-parsed by `yaml`. A false
+ * refusal costs one dynamic import; a false claim silently diverges.
+ *
+ * The delimiter scan stays local: frontmatter with no closing `---` is not
+ * frontmatter, and the body is then the whole source.
+ *
+ * @module dsh-cordis-review/frontmatter
+ */
+/** Parsed frontmatter plus the markdown body that follows it. */
+export interface Frontmatter {
+    /** Frontmatter mapping, values as the YAML parser produced them. */
+    readonly data: Readonly<Record<string, unknown>>;
+    /** Everything after the closing delimiter, or the whole source when absent. */
+    readonly body: string;
+}
+/**
+ * Parse leading frontmatter from a markdown document, for the flat subset only.
+ * @param source - full file contents.
+ * @returns the mapping and body, or `undefined` when this file's block needs
+ *   the real YAML parser ({@link parseFrontmatterWithYaml}).
+ */
+export declare function parseFrontmatter(source: string): Frontmatter | undefined;
+/**
+ * Parse leading frontmatter with the `yaml` parser the harness's own filesystem
+ * skill provider uses. Loaded dynamically, so a flat header never pays for it.
+ * @param source - full file contents.
+ * @returns the parsed mapping and the remaining body.
+ */
+export declare function parseFrontmatterWithYaml(source: string): Promise<Frontmatter>;

package/lib/types/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * dsh-cordis-review: CORDIS review skills as a DeepSeek Harness plugin.
+ *
+ * One capability: every bundled `skills/<name>/SKILL.md` becomes a
+ * `ctx.skills` provider entry, so each appears as `/<name>` in the composer
+ * (DSH's command surface for user-invocable skills). `cordis-review` reviews
+ * a codebase against the CORDIS context paradigm (arXiv:2608.25512) and
+ * applies the fixes; `cordis-doc-review` writes and repairs the docs.
+ *
+ * @module dsh-cordis-review
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Plugin name as it appears in the loader. */
+export declare const name = "cordis-review";
+/**
+ * Mount the plugin.
+ * @param ctx - the host context.
+ */
+export declare function apply(ctx: Context): void;

package/lib/types/skills.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The bundled cordis-review skill as a `ctx.skills` provider.
+ *
+ * Skills are read from this package's `skills/<name>/SKILL.md`, so that file
+ * stays the single source of truth for `/cordis-review`.
+ *
+ * @module dsh-cordis-review/skills
+ */
+import { BUNDLED_SKILL_RANK } from '@deepseek-ai/dsh-skill';
+import type { SkillCandidate, SkillDefinition, SkillInvocationPolicy, SkillLookupOptions, SkillProviderObservation } from '@deepseek-ai/dsh-skill';
+/**
+ * Rank matching a harness bundled skill, re-exported from the registry so a
+ * project-level or user-level skill of the same name still wins the duplicate.
+ */
+export { BUNDLED_SKILL_RANK };
+/** One parsed bundled skill. */
+interface BundledSkill {
+    /** Kebab-case skill name from frontmatter, or the directory name. */
+    readonly name: string;
+    /** Routing description from frontmatter. */
+    readonly description: string;
+    /** Extra routing hint from frontmatter, when present. */
+    readonly whenToUse?: string;
+    /** Resolved invocation controls from the documented frontmatter keys. */
+    readonly invocation: SkillInvocationPolicy;
+    /** Instruction body with frontmatter removed. */
+    readonly content: string;
+    /** Remaining frontmatter keys (provider-specific only). */
+    readonly metadata: Readonly<Record<string, unknown>>;
+    /** Absolute path of the instruction file. */
+    readonly path: string;
+    /** Absolute path of the skill directory, used as the resource base. */
+    readonly directory: string;
+}
+/** Options for {@link createSkillProvider}. */
+interface SkillProviderOptions {
+    /** Directory holding one subdirectory per skill. */
+    readonly skillsDir: string;
+    /** Receives non-fatal discovery problems instead of throwing. */
+    readonly onWarn?: (message: string) => void;
+}
+/**
+ * Read every valid skill directory under `skillsDir`.
+ *
+ * A missing directory, a directory without `SKILL.md`, a file whose frontmatter
+ * the reader refuses, and a file with a missing description or an invalid
+ * invocation key are reported through `onWarn` and skipped: one broken file
+ * must not cost the catalog its other skills.
+ * @param skillsDir - directory holding one subdirectory per skill.
+ * @param onWarn - optional non-fatal problem sink.
+ * @param signal - aborts discovery for a caller that no longer wants the result.
+ * @returns the parsed skills, sorted by name.
+ */
+export declare function discoverSkills(skillsDir: string, onWarn?: (message: string) => void, signal?: AbortSignal): Promise<readonly BundledSkill[]>;
+/**
+ * Build the provider the skill registry mounts.
+ * @param options - skills directory and the non-fatal problem sink.
+ * @returns a provider whose candidates are summaries and whose bodies come from disk.
+ */
+export declare function createSkillProvider(options: SkillProviderOptions): {
+    name: string;
+    list(lookup?: SkillLookupOptions): Promise<readonly SkillCandidate[] | SkillProviderObservation>;
+    get(candidate: SkillCandidate, lookup?: SkillLookupOptions): Promise<SkillDefinition | undefined>;
+};

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "CORDIS review",
+    "description": "Review a codebase against the CORDIS paper and apply the fixes that apply."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "CORDIS 审查",
+    "description": "按 CORDIS 论文审查代码，并应用适用的修改。"
+  }
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@maci0/dsh-cordis-review",
+  "version": "0.17.1",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "description": "CORDIS review slash command (/cordis-review) for DeepSeek Harness: review a codebase against arXiv:2608.25512 and apply the applicable fixes.",
+  "license": "MIT",
+  "bin": {
+    "cordis-review-check": "lib/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "compatibility": {
+      "dsh": ">=0.2.0-rc.2 <0.3.0"
+    }
+  },
+  "files": [
+    "icon.svg",
+    "locale/*.json",
+    "lib/**/*.js",
+    "lib/types/**/*.d.ts",
+    "skills",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bunx --bun tsc -p tsconfig.build.json",
+    "test": "bun test",
+    "typecheck": "bunx --bun tsc -p tsconfig.json",
+    "check": "bun lib/cli.js",
+    "test:node": "node --test tests/*.test.*"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-skill": "0.2.1-alpha.1",
+    "yaml": "2.9.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.5-alpha.1",
+    "@deepseek-ai/dsh-scope": "0.2.1-alpha.1",
+    "@types/node": "^22.20.2",
+    "typescript": "^7.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/maci0/dsh-cordis-review.git"
+  },
+  "icon": "./icon.svg"
+}

package/skills/cordis-doc-review/SKILL.md

@@ -0,0 +1,207 @@
+---
+name: cordis-doc-review
+description: >
+  Create, repair, or restructure documentation for Cordis plugins, DeepSeek
+  Harness subsystems, cookbooks, and package contracts. Use when the user
+  asks for CORDIS documentation, a documentation review, a cookbook, a
+  subsystem document, or an update to existing technical documentation.
+---
+
+# CORDIS documentation review
+
+Create or update documentation that gives a reader one accurate path from a
+Cordis composition to its owned runtime behavior. Deliver documentation edits,
+not a report alone. Treat source code, configuration, and tests as facts;
+never invent API names, lifecycle behavior, commands, or verification results.
+
+For DeepSeek Harness and `dsh-*` plugins, read the nearest `AGENTS.md` first.
+When present, apply `docs/AGENTS.md`, `.agents/skills/dsh-doc/SKILL.md`, and
+`.agents/skills/dsh-prose-standard/SKILL.md`. They define repository-specific
+placement, scope, prose, bilingual, and validation rules. This skill supplies
+the Cordis documentation model; repository rules own filenames and gates.
+
+## Outcome
+
+A complete result has:
+
+1. documentation in its owning location;
+2. an accurate topology and lifecycle explanation;
+3. a runnable reader path for common work;
+4. links to detailed owners instead of duplicated detail; and
+5. focused validation or an explicit, concrete reason validation cannot run.
+
+Do not add documentation for speculative extension points. Update an existing
+owner when it already owns the fact. Create a new document only when its scope
+cannot fit without mixing audiences or subjects.
+
+## Workflow
+
+### 1. Establish scope and readers
+
+Read the request and nearest documentation rules. Identify the requested
+outcome, target reader, current documents, source owners, configuration rows,
+and tests. If scope is absent, use the named document or current subsystem;
+do not expand to a repository-wide rewrite.
+
+Classify each proposed page before writing:
+
+- **Tutorial:** ordered route from starting state to an observable outcome.
+- **Reference:** lookup document defining current contracts and behavior.
+- **Cookbook:** narrow repeatable procedure with numbered actions and
+  verification.
+- **Subsystem document:** architecture, ownership, lifecycle, seams, and links
+  to child documents.
+- **Package README:** package contract, configuration, semantics, limits, and
+  extension points.
+
+One page has one primary reader goal. Split substantial teaching from lookup
+content. Do not turn a subsystem overview into a catalog of child internals.
+
+### 2. Recover runtime truth
+
+Trace every statement through its owner before documenting it:
+
+1. entry: profile, bundle, config patch, CLI, or public API;
+2. composition: plugin `name`, `inject`, `apply`, and provided service;
+3. lifecycle: registrations, effects, cleanup, unload, replacement, and HMR;
+4. data: input shape, output shape, persistence boundary, error behavior; and
+5. proof: closest tests, examples, and commands that exercise the path.
+
+Use code for behavior, tests for exercised guarantees, and generated catalogs
+only for generated facts. State a limitation only when source or tests prove
+it. Link each detail to its lowest owning document.
+
+### 3. Model Cordis accurately
+
+Explain a Cordis subsystem in terms readers can act on:
+
+- **Composition:** which configuration layer mounts it and ordering constraints.
+- **Dependencies:** services declared by `inject`; optional dependencies and
+  degraded behavior only when code supports them.
+- **Contributions:** services, tools, events, commands, skills, or config rows
+  added through context effects.
+- **Lifecycle:** what happens at apply, replacement, disposal, and reload.
+  Registrations are reversible effects, not permanent global mutations.
+- **Ownership:** which component owns each fact, state transition, and cleanup.
+- **Boundaries:** inputs and outputs crossing process, persistence, network, or
+  user trust boundaries; validation and failure behavior at each boundary.
+
+Never claim `ctx` survives outside its context lifetime. Never describe a
+registration as globally permanent when its effect unwinds on unload. Do not
+promise hot reload, teardown, ordering, or compatibility unless verified.
+
+### 4. Write structure before prose
+
+Start with title, audience outcome, and table of contents when page size makes
+navigation useful. Put the shortest successful path before advanced detail.
+
+Use this default shape when it fits:
+
+```md
+# <Subject>
+
+<Audience outcome and scope.>
+
+## Quick path
+
+<Minimal working composition or procedure.>
+
+## How it fits
+
+<Composition, dependency, and ownership model.>
+
+## Lifecycle
+
+<Apply, use, dispose/reload behavior.>
+
+## Reference
+
+<Config, API, events, errors, or limitations.>
+
+## Verify
+
+<Exact focused command and observable result.>
+```
+
+A cookbook uses numbered steps and a verification step. A tutorial introduces
+prerequisites before dependent concepts and verifies each milestone. A reference
+uses stable headings and exhaustive coverage only within its own scope.
+
+### 5. Edit with ownership discipline
+
+Prefer targeted edits to a current canonical document. Keep one owner per
+fact:
+
+- source and types own exact API signatures;
+- tests own executable guarantees;
+- package README owns package contract and limits;
+- subsystem docs own architecture and responsibility boundaries;
+- cookbooks own procedures;
+- configuration examples own minimal composition examples.
+
+Replace stale claims rather than appending contradictory history. Preserve
+existing navigation, translations, and links unless the repository standard
+requires their update. If an English/Chinese pair exists or local policy
+requires one, update both with aligned headings and equivalent meaning.
+
+Write direct prose. Name prerequisites, side effects, limits, error cases, and
+cleanup only where a reader needs them. Remove reasoning transcripts,
+promotional claims, vague adjectives, repeated API restatements, and untested
+commands.
+
+### 6. Validate
+
+Check every changed link, heading hierarchy, code fence, command, config key,
+and symbol against source. Run the smallest documented Markdown, link, prose,
+or package gate that covers changed files. Run an example command only when its
+side effects and environment are understood.
+
+For a documentation claim about runtime behavior, inspect the implementation
+and closest test. For lifecycle prose, inspect the cleanup path. Do not report
+a command as passed unless it ran and passed.
+
+## Review checklist
+
+Apply all relevant checks and patch every confirmed defect.
+
+### Placement and scope
+
+- [ ] Page location matches document type and tree ownership.
+- [ ] Page names one subject, target reader, and bounded outcome.
+- [ ] Parent pages describe child responsibility without copying child detail.
+- [ ] Existing canonical document is updated instead of duplicated.
+- [ ] Tutorial, reference, cookbook, subsystem, and README material are not
+      materially mixed.
+
+### Cordis correctness
+
+- [ ] Mounting layer and configuration path are accurate.
+- [ ] `inject` dependencies and optional behavior match source.
+- [ ] Contributions identify their owner and registration mechanism.
+- [ ] Apply, dispose, replacement, and reload claims match actual effects.
+- [ ] State, events, tools, and persistence boundaries name real owners.
+- [ ] No document promises global mutation, leaked context, or unsupported HMR.
+
+### Reader usefulness
+
+- [ ] Quick path starts from stated prerequisites and reaches an observable end.
+- [ ] Examples are minimal, complete, and use current names.
+- [ ] Reference entries define behavior, failure conditions, and limits needed
+      for safe use.
+- [ ] Details link downward to their owner instead of repeating them.
+- [ ] Verification is concrete and proportionate to the change.
+
+### Editorial quality
+
+- [ ] Headings form a usable hierarchy and links resolve.
+- [ ] Prose states contracts, not author reasoning or marketing.
+- [ ] Facts have evidence in source, tests, configuration, or executed output.
+- [ ] Translation and metadata requirements remain satisfied.
+- [ ] Changed pages meet local word-count and documentation gates.
+
+## Completion report
+
+Report only changed documents, validated commands with results, and material
+omissions with their trigger. Do not list unconfirmed findings. If no edit is
+needed, state why the existing documentation already passes the applicable
+checklist.

package/skills/cordis-review/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: cordis-review
+description: >
+  Review the current codebase against the CORDIS context paradigm
+  (arXiv:2608.25512) and implement every applicable fix. Use when the
+  user says "cordis review", "review against CORDIS", "spatiotemporal
+  composability", or invokes /cordis-review. Targets plugin systems,
+  harnesses, and any code that loads, unloads, or depends on components
+  at runtime.
+---
+
+# CORDIS review
+
+Review this workspace against **A Programming Paradigm for Spatiotemporal
+Composability** (Shi, Zhang, Cui; [arXiv:2608.25512](https://arxiv.org/abs/2608.25512))
+and **implement every applicable fix**. Report-only is failure. Skip a finding
+only when the paper's own system-boundary argument says the effect cannot be
+tracked.
+
+**This file is the checklist: start here.** It is the operational form of
+the paper and is sufficient to review and patch; the agent is not required to
+fetch anything before auditing.
+
+Paper fetch, if you want the abstract and exact metadata: the **abs page only**,
+<https://arxiv.org/abs/2608.25512> (HTTP 200). Do **not** try the PDF
+(`/pdf/2608.25512`: this harness rejects `application/pdf`) or an HTML
+rendering (`/html/2608.25512v1` is 404: no HTML is published for this
+submission). The abstract is not the checklist: rules come from this file, not
+from a fetched page, and never from memory. The `§` numbers below are cited
+from the paper's section structure and were verified against it; do not
+re-derive or second-guess them mid-review.
+
+If the workspace is DeepSeek Harness or a `dsh-*` plugin, also obey that
+repo's Cordis conventions (`AGENTS.md`, `docs/cordis-primer.md`,
+`docs/cordis-tutorial/`). The paper wins on the model; the repo wins on
+names (`ctx.effect`, `inject`, `ctx.get`, `apply`).
+
+## Protocol
+
+1. **Scope.** Default: the current workspace. A `/cordis-review <path>`
+   argument, if present, is the root. Do not wander into unrelated checkouts.
+2. **Get the rules.** Read this file's **Checklist** and **What the paper
+   requires** sections: that is the complete rubric, already loaded. If you
+   need the paper's abstract or exact metadata, `web_fetch` the abs page
+   `https://arxiv.org/abs/2608.25512` (the only URL that works; the PDF is
+   rejected and there is no HTML rendering). In DSH / `dsh-*` plugin
+   workspaces, also read that repo's `AGENTS.md` and `docs/cordis-primer.md`;
+   those are the local naming and convention source of truth.
+3. **Map the runtime.** Find the context object, effect/coeffect primitives,
+   component/plugin entrypoints (`apply` / `inject` / `Service`), and the
+   loader. In DSH/Cordis that is `ctx`, `ctx.effect` / `ctx.on` / `ctx.set`,
+   `inject`, fibers, and the Loader.
+4. **Closed-form pass.** Run this plugin's checker before walking the rest of
+   the checklist. From this package root:
+
+   ```
+   node lib/cli.js [scope]
+   ```
+
+   `bun lib/cli.js [scope]` runs the same file where `node` is not on PATH.
+   The package root is the parent of `skills/cordis-review/` (this skill's
+   directory). It prints `file:line: tag: message` for `mix-export`, `inject`,
+   `toplevel`, and `id` (every tag is one ast-grep query) over JS/TS/TSX,
+   Python, and YAML files; other languages are not scanned. Without
+   `ast-grep` on PATH each covered file warns on stderr and yields an
+   LLM-fallback hit: judge that file against the checklist yourself (that is
+   the fallback, not a second scanner). `--help` prints the usage. `leak` /
+   `inverse` / `hmr` / `boundary` stay judgment.
+   `cordis-check: clean` still means walk the checklist. Exit 2 with
+   `cordis-check: cannot read <dir>` lines means those directories were not
+   scanned: judge their files yourself or fix the permissions and re-run.
+5. **Audit, then fix.** Walk the checklist below. Each hit is a code change
+   unless it is a documented outside-boundary emission. Grep callers of every
+   function you touch; fix the shared primitive, not one call site.
+6. **Verify.** One HMR/dispose test per registration you add or repair: dispose
+   the contributing fiber, assert the contribution is gone. Run the smallest
+   existing test command that covers the files you changed. Re-run the checker.
+
+## What the paper requires
+
+Two orthogonal properties, local to one component, then lifted to a system of
+interleaved components:
+
+- **Temporal composability.** Every context mutation carries an inverse the
+  runtime holds. Unload runs those inverses LIFO. A leftover timer, listener,
+  registry row, or published service after dispose is a bug.
+- **Spatial composability.** A component declares what it requires
+  (coeffects). The runtime classifies every context change against that
+  declaration and activates or deactivates the component. A missing provider
+  leaves it inactive; it does not crash, and it does not reach around the
+  declaration.
+
+The **context paradigm** mediates every effect and coeffect through one
+context. Reaching another component's context through a closure, import, or
+global leaks effects out of the owner's lifecycle and coeffects out of its
+`inject` list.
+
+The runtime does **not** prove that an inverse actually reverts, or that
+operations published at one key commute. Those are author obligations
+(§5.1.1 effect tracking: "Effect tracking" is the only context-transformation
+primitive, and the runtime does not check the inverse witness; §6.1 "System
+Boundary"). This review discharges them in code.
+
+## Checklist
+
+One line per finding in the report, then the patch.
+
+### Temporal: revertible effects
+
+- `leak:` side effect not installed through the context (`setInterval`,
+  `addEventListener`, `on()`, `fetch` abort, file watch, process, mutex,
+  module-level singleton mutation). Wrap in `ctx.effect(() => { …; return dispose })`
+  or the helper that already does (`ctx.on`, `register()` that returns a
+  disposer).
+- `inverse:` dispose does not restore the pre-effect state, is not idempotent,
+  or is not LIFO with sibling effects. Inverse fires at most once.
+- `toplevel:` work at module load (register, listen, I/O, `new Service`)
+  instead of inside `apply(ctx)` / the Service constructor. Move it.
+- `double:` dispose path can run the inverse twice, or never. Guard like
+  Cordis `armed`.
+- `foreign-ctx:` effect installed on a context that is not `fiber.ctx`
+  (captured parent, global, another plugin's `ctx`). Install on the owner.
+
+### Spatial: reactive coeffects
+
+- `inject:` required service used as `ctx.foo` without `inject: ['foo']`.
+  Declare it. Optional services use `ctx.get('foo')`, never the proxy.
+- `bypass:` dependency reached by import, global, or hard-coded singleton
+  instead of the context key. Route through `ctx`.
+- `provide:` published service / registry row not a tracked effect
+  (`ctx.set`, `ctx.plugin`, `register` returning a disposer). Make it one.
+- `mix-export:` default-export Service **and** named `apply`/`inject` on the
+  same module. Loader keeps one form; mixing drops `inject`. Pick one.
+- `react:` component assumes a coeffect is eternal. It must survive provider
+  swap / withdraw (stay inactive until the key returns; do not throw in
+  `apply` for a missing optional).
+
+### Context paradigm
+
+- `mediate:` shared mutable environment written outside `ctx` (process global,
+  imported registry, `window.*`, file side-channel used as a bus). Put it on
+  a service key.
+- `config:` runtime behavior that belongs in the component's `config` /
+  Loader entry is a magic constant or env read inside `apply`. Bind config;
+  invalid values fail at load, not later.
+- `isolate:` cross-plugin state sharing that should be a realm (`isolate`)
+  or a declared service, implemented as a module singleton.
+
+### System boundary (§6.1)
+
+- **Inside:** exclusive and restorable → must be a tracked effect.
+- **Outside:** cannot restore (bytes already on the wire, other processes
+  writing the file) → do not fake an inverse. Either **withhold** until
+  commit or **compensate** with an application-level undo, and say so in a
+  one-line comment (`cordis-boundary: emission, compensate by X`).
+- `boundary:` treats an inside location as outside (leaks) **or** invents a
+  "cleanup" for an emission it cannot revert (lies). Fix the classification.
+
+### Lifecycle / loader
+
+- `fiber:` retains a child plugin / subscription past owner dispose.
+  Keep the fiber and dispose it in the owner's effect.
+- `hmr:` registration has no dispose-the-fiber test. Add one.
+- `id:` duplicate Loader `id` / plugin name, or a bundle patch that `insert`s
+  the same row the profile already has.
+
+## DSH / Cordis names
+
+Map paper → this stack without renaming the stack:
+
+| Paper | Code |
+|---|---|
+| context Γ | `ctx` |
+| revertible effect | `ctx.effect`, `ctx.on`, `register()` → disposer |
+| coeffect declaration | `export const inject = ['…']` |
+| coeffect read | `ctx.foo` (required) / `ctx.get('foo')` (optional) |
+| coeffect provide | `ctx.set` / Service constructor key |
+| component | `export function apply(ctx)` or `class extends Service` |
+| fiber | return value of `ctx.plugin(…)` |
+| inverse accumulator | `fiber.dispose` |
+| loader entry | `cordis.yml` / `cordis.patch.yml` row |
+
+Harness conventions that already encode the paper: registrations are
+effects; `ctx.get` for optional services; function plugins named-export
+`name` / `inject` / `Config` / `apply` with **no** default export; every
+registry has an HMR-safety test.
+
+## Fixes
+
+- Smallest change that restores the invariant. Deletion over a new
+  abstraction. No "lifecycle manager" class for one timer.
+- Do not add a framework, a second context type, or a compatibility shim.
+- Do not rewrite working Cordis usage into a parallel effect system.
+- Leave theory, proofs, and comments that are not lying. Code only.
+- If a hit is outside this workspace (vendored Cordis, another repo), record
+  it as `out-of-scope:` and do not patch it.
+
+## Report (after the patches)
+
+```
+CORDIS review: arXiv:2608.25512
+scope: <root>
+fixed:
+- <file>:<line>: <tag> <what>. <what you did>.
+skipped:
+- <file>:<line>: <tag> <what>. <why: boundary | out-of-scope | already-correct>
+```
+
+No essay. Empty `fixed` with empty `skipped` means you looked and the
+workspace already holds the invariants; say that in one line.