dsh-engramory 0.2.0 → 0.2.1

package/README.md

@@ -18,14 +18,17 @@ because the index loads every session and everything past the cap silently stops
 recalled. On most hosts that limit is rules plus a checker the agent has to remember to
 run. dsh exposes `ctx.tools.guard()` — a synchronous, **monotonic** refusal: once a guard
 returns a reason, no later listener can turn it back into an allow. So here the limit is
-enforced, not requested — **once the plugin is actually installed and running**; a
-profile install currently fails upstream (see "Known limits"), and until then the cap on
-dsh is still rules plus the checker. Outside Claude Code, this is the only host where a
-deterministic cap is even possible.
-
-**The protocol arrives with the plugin.** `ctx.skills.register()` contributes the skill at
-runtime, so it does not depend on landing files in one of the five skill roots dsh scans —
-a path that is easy to get subtly wrong and fails silently when you do.
+enforced, not requested. Use **0.2.1 or later**: 0.2.0 shipped before profile installs
+worked upstream and carried an `inject` declaration this Cordis does not accept — it
+installed but never activated (issue #8). Outside Claude Code, dsh is the first host with
+the shim actually written (a few others expose equivalent pre-write seams — see
+PORTING.md — but have no shim yet).
+
+**The protocol arrives with the plugin.** The skill is registered at runtime through
+dsh's skill registry — via a reactive `ctx.inject(['skills'], …)` child, so a profile
+without a registry still gets the cap and one whose registry activates late still gets
+the skill — which means it does not depend on landing files in one of the five skill
+roots dsh scans, a path that is easy to get subtly wrong and fails silently when you do.
 
 ## Install
 
@@ -91,18 +94,23 @@ newline, so an index sitting exactly at the cap stays writable.
   index cannot be grown further, and a shrinking write always passes.
 - **The tool roster follows dsh's documented tool-fs contract** (`write`/`edit` with
   `file_path`, `str_replace_editor` with `path`) and is deliberately conservative:
-  unknown tools pass. Until the plugin runs inside a real profile this mapping is
-  documentation-verified only.
-- **Not yet verified end to end inside dsh.** The guard's decision table is covered by
-  `node --test` (20 cases, run in Engramory's CI), and the wiring for the AGENTS.md block
-  and skill discovery was dogfooded against a live `deepseek-v4-flash` session. But
-  installing a *third-party plugin* into a profile currently fails on dsh 0.1.0-rc.6:
-  `dsh plugin` shells out to `pnpm` (not bundled), and a direct `pnpm add` then dies on
-  `ERR_PNPM_FETCH_404` for `@deepseek-ai/dsh-type-meta`, a package the published tree
-  depends on but which is not on the registry. That is a preview-packaging problem
-  upstream, not a plugin defect; this note goes away once a profile install resolves.
+  unknown tools pass.
+- **0.2.0 never activated; 0.2.1 is the first version that runs.** While the rc.6
+  preview bug blocked all third-party profile installs upstream, the only coverage a
+  plugin could have was mocks — and 0.2.0's mock hid two activation bugs: an
+  older-Cordis `{ required, optional }` inject shape (read as waiting for services
+  literally named `required`/`optional`, pending forever) and a bare `ctx.skills` read
+  of an undeclared service (throws under Cordis' reflective context). The first field
+  install caught both the moment installs became possible (issue #8). 0.2.1 fixes them,
+  verified end to end on a live dsh 0.1.0-rc.7 web profile (0.2.0 reproduces the boot
+  failure byte for byte; 0.2.1 boots and serves) and against the vendored
+  `@deepseek-ai/cordis` resolver (activation with, without, and with a late-mounted
+  skill registry). The test mock now mirrors the reflective-context access rules, and
+  the guard's decision table stays covered by `node --test` (22 cases, run in
+  Engramory's CI).
 - dsh is a developer preview and its plugin API can change. This plugin deliberately
-  touches only `ctx.tools.guard()` and `ctx.skills.register()` so it stays cheap to fix.
+  touches only `ctx.tools.guard()` and a reactive `ctx.inject(['skills'], …)` child
+  that registers the skill, so it stays cheap to fix.
 
 ## License
 

package/index.js

@@ -7,8 +7,9 @@
  *      monotonic refusal — once a guard returns a reason, no later waterfall
  *      listener can turn it back into an allow. That makes it a stronger seam than
  *      most hosts expose, and it is why the 200-line / 25 KB limit can be enforced
- *      here rather than merely asked for. Everywhere except Claude Code, Engramory's
- *      cap degrades to "rules plus a checker the agent has to remember to run".
+ *      here rather than merely asked for. Without a shim like this one, everywhere
+ *      except Claude Code the cap degrades to "rules plus a checker the agent has to
+ *      remember to run".
  *   2. Skill delivery that does not depend on install paths. Registering at runtime
  *      sidesteps the five-root scan entirely, so the protocol is present because the
  *      plugin is loaded, not because a directory happened to be right.
@@ -27,9 +28,14 @@ import { basename } from 'node:path'
 
 export const name = 'engramory'
 
-// `tools` carries the cap and is required. `skills` is optional so the plugin still
-// loads (and still caps) on a profile that mounts no skill registry.
-export const inject = { required: ['tools'], optional: ['skills'] }
+// `tools` carries the cap and is the plugin's only declared dependency. Cordis reads
+// `inject` as an array of service names (or an object KEYED by them) and treats every
+// entry as a hard wait — the `{ required, optional }` shape is older-Cordis syntax that
+// the build dsh vendors resolves as services literally named "required"/"optional",
+// which never appear, so the plugin sat pending forever (issue #8). `skills` is
+// deliberately NOT declared: the cap must mount even on a profile with no skill
+// registry, so apply() probes it at runtime instead.
+export const inject = ['tools']
 
 /** Mirrors hooks/engramory_index_guard.py — the caps are the protocol's, not this port's. */
 const DEFAULT_INDEX_NAME = 'MEMORY.md'
@@ -57,19 +63,30 @@ export function apply(ctx, config = {}) {
 
   ctx.tools.guard((exec) => refuseOversizedIndex(exec, settings))
 
-  if (ctx.skills && config.registerSkill !== false) {
-    const skill = config.skill ?? builtinSkillBody()
-    ctx.skills.register({
-      name: 'engramory',
-      description:
-        'Curated file-based long-term memory: recall through MEMORY.md at the start of ' +
-        'a task, save durable user/feedback/project/reference facts, and sync before ' +
-        'compacting or opening a fresh thread.',
-      whenToUse:
-        'Starting or resuming work, learning something durable worth a future session, ' +
-        'or approaching a compact/clear/new-thread boundary.',
-      source: 'runtime',
-      content: skill,
+  // The skill registry is optional AND may activate after this plugin — fiber order
+  // between unrelated providers is not guaranteed, so a one-shot probe here would
+  // silently skip registration on such boots. ctx.inject() is Cordis' reactive form:
+  // the callback runs once `skills` is available (however late), re-runs if the
+  // registry reloads, and never makes the cap wait. A bare `ctx.skills` read at THIS
+  // level would throw (undeclared service — issue #8's second crash); inside the
+  // callback the service is declared, so the read is legal.
+  if (config.registerSkill !== false) {
+    ctx.inject(['skills'], (inner) => {
+      const skill = config.skill ?? builtinSkillBody()
+      // effect() ties the registration to the child fiber: it is disposed when the
+      // registry unloads, so a reload cannot accumulate duplicate registrations.
+      inner.effect(() => inner.skills.register({
+        name: 'engramory',
+        description:
+          'Curated file-based long-term memory: recall through MEMORY.md at the start of ' +
+          'a task, save durable user/feedback/project/reference facts, and sync before ' +
+          'compacting or opening a fresh thread.',
+        whenToUse:
+          'Starting or resuming work, learning something durable worth a future session, ' +
+          'or approaching a compact/clear/new-thread boundary.',
+        source: 'runtime',
+        content: skill,
+      }))
     })
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-engramory",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Curated file-based long-term memory for DeepSeek Harness — human-readable markdown notes, one plain-file store shared across hosts (git-ignored when it lives inside a project repo), and a deterministic index cap enforced by ctx.tools.guard()",
   "keywords": [
     "dsh-plugin",