@lorekit/cli 1.69.0 → 1.71.0

package/skill/lorekit-setup/templates/multi-step-orchestrator.md

@@ -0,0 +1,76 @@
+# Recipe card — multi-step orchestrator
+
+For a **pipeline that fails in classifiable ways** but does not post durable outputs at
+a shared target and does not (necessarily) edit code: a triage → plan → execute
+workflow, a release orchestrator, a batch processor. The plain two-tier lessons loop
+fits it exactly. This is the card to start from when no other card matches.
+
+Fill in: `<host>` (e.g. `deploy`), `<owner>/<repo>`. `N = 5`.
+
+## Bucket
+
+Tag `loop::<host>-lessons`, key `<host>-lessons::<slug>`. One bucket per host.
+
+## Read step — start of every run
+
+```text
+memory.list { scope: "repo::<owner>/<repo>", tags: ["loop::<host>-lessons"], limit: 5 }
+memory.list { scope: "global",               tags: ["loop::<host>-lessons"], limit: 5 }
+# when the run names a stage/error, one targeted search:
+memory.search { q: "<keywords>", scopes: ["repo::<owner>/*", "global"], limit: 5 }
+```
+
+Match each **Applies when** against the current run; apply matching **Do this instead**
+lines as considerations. `repo::` beats `global` on a collision.
+
+## Write step — at the host's EXISTING failure points
+
+Do not add a new reflection stage — hook the points the host already detects (a stuck
+loop, a repeated failure, a gate that should have caught something, a near-miss, a
+guess that paid off). Not on smooth successes.
+
+```text
+memory.search { q: "<key words of the lesson>", scopes: ["repo::<owner>/<repo>", "global"], limit: 10 }
+
+memory.write {
+  scope:    "<global | repo::<owner>/<repo>>",
+  key:      "<host>-lessons::<slug>",
+  value:    "<markdown lesson body — no hidden blocks>",
+  tags:     ["loop::<host>-lessons", "source::<trigger>"],   # + "status::structural" when it is
+  trigger:  "<stuck-loop | command-failure | gotcha | near-miss | assumption-wrong | paid-off>",
+  ttl_days: 90
+}
+```
+
+Same `scope` + `key` UPDATEs in place — the store increments `seen_count` for you and
+re-passing `ttl_days` refreshes the expiry. Never hand-write a count into the body.
+
+## Lesson body — copy this shape
+
+```markdown
+# <one-line takeaway — what to do, not what it is about>
+
+**Applies when:** <concrete signal — stage name, task type, tool name, error shape>
+
+**What happened:** <the concrete observable>
+**Why:** <root cause, or "unknown">
+**Do this instead:** <prescriptive, testable instruction>
+**Promotion target:** <the host step this would harden if promoted, or "none">
+```
+
+## Promotion
+
+When a lesson hits `seen_count >= 3` (read the column, not the body) or carries
+`status::structural`, surface a one-line promotion suggestion — never act silently.
+See [Promotion](../rules/self-improvement-loops.md#promotion-fast--slow).
+
+## Fire-once check
+
+1. Force the failure this loop targets.
+2. `memory.list { scope: "<expected>", tags: ["loop::<host>-lessons"], limit: 10 }` — confirm the lesson.
+3. Re-run; confirm it surfaces and biases the run.
+
+## Cold start & proof
+
+Optional capped seeding: [cold-start-seeding.md](../rules/cold-start-seeding.md).
+Required proof — the immunity re-challenge: [proving-improvement.md](../rules/proving-improvement.md).

package/skill/lorekit-setup/templates/reviewer-reconcile-host.md

@@ -0,0 +1,86 @@
+# Recipe card — reviewer / reconcile host
+
+For a host that **produces durable outputs at a shared target it revisits**: a PR
+reviewer posting comment threads it re-reviews on every push, a triager filing issues
+it re-scans, a linter opening tickets. A plain read/write loop is not enough — stale
+outputs pile up at the target and the signal about which outputs were *useful* is
+thrown away. This card adds the **reconcile-on-re-run** flow on top of the lessons
+loop, feeding a second **Signal** bucket.
+
+Fill in: `<host>` (e.g. `reviewer`), `<signal>` (e.g. `comment-relevance`),
+`<owner>/<repo>`. `N = 5`.
+
+## Buckets (two)
+
+- Lessons: tag `loop::<host>-lessons`, key `<host>-lessons::<slug>` — how to review better.
+- Signal: tag `loop::<host>-<signal>`, key `<host>-<signal>::<pattern-fingerprint>` —
+  which of the host's OUTPUT PATTERNS get acted on vs declined at this target.
+
+## Read step — start of run
+
+```text
+# Own lessons (capped at N per scope):
+memory.list { scope: "repo::<owner>/<repo>", tags: ["loop::<host>-lessons"], limit: 5 }
+memory.list { scope: "global",               tags: ["loop::<host>-lessons"], limit: 5 }
+
+# Signal bucket — suppress reliably-declined patterns, reinforce reliably-resolved ones:
+memory.list { scope: "repo::<owner>/<repo>", tags: ["loop::<host>-<signal>"], limit: 20 }
+```
+
+## Reconcile step — at the re-run seam, gated on "a prior output exists at this target"
+
+For each prior output the host itself authored, classify against the current target:
+
+| Outcome | Meaning | Evidence |
+| --- | --- | --- |
+| **resolved** | acted on — the flagged thing is handled | the region changed and the finding no longer reproduces, or the owner acknowledged it |
+| **declined** | explicitly rejected | a "won't fix" / "by design" reply, a 👎 |
+| **still-open** | still reproduces this run | the host re-produces the same output |
+
+Then:
+
+1. **Clean up** `resolved` + `declined` at the source (resolve the thread, close the
+   ticket). **Never** touch a `still-open` output. Only ever touch outputs the host
+   authored. Cleanup is idempotent and non-fatal (a cleanup error is logged, never
+   fails the run).
+2. **Record the outcome** to the Signal bucket, keyed by a stable pattern fingerprint
+   (never a line number or a drifting id):
+
+```text
+memory.write {
+  scope:    "repo::<owner>/<repo>",
+  key:      "<host>-<signal>::<pattern-fingerprint>",
+  value:    "<markdown: the pattern, and resolved-vs-declined evidence — no hidden blocks>",
+  tags:     ["loop::<host>-<signal>", "status::<resolved | declined>"],
+  trigger:  "reconcile",
+  ttl_days: 90
+}
+```
+
+`still-open` writes nothing — there is no outcome yet. **Absence of confirmation is not
+resolution**: if a re-run did not re-scan the region a prior output covers, it is
+`still-open`, not `resolved`.
+
+## Write step (lessons) — on friction, as usual
+
+Same as any lessons loop — see [code-changing-agent.md](./code-changing-agent.md#write-step--on-failure--at-end-of-run)
+for the write shape.
+
+## Fire-once check
+
+1. Produce an output at a test target, then resolve it at the source by hand.
+2. Re-run; confirm the host classifies it `resolved`, cleans it up, and writes a
+   positive Signal record for its pattern.
+3. Start a third run; confirm the Signal record surfaces and reinforces that pattern.
+
+## Reference implementation
+
+The `agent-skills` `pr-reviewer` agent: it resolves its own addressed PR threads on
+each commit-triggered re-review and records the fixed/declined outcome to a
+`reviewer-comment-relevance` bucket. Full flow:
+[the reconcile-on-re-run flow](../rules/self-improvement-loops.md#the-reconcile-on-re-run-flow-resolve--record).
+
+## Prove it
+
+[proving-improvement.md](../rules/proving-improvement.md) — for this host the signal is
+the **decline rate** of the host's outputs trending down over runs.

package/src/commands/doctor.mjs

@@ -7,7 +7,6 @@ import { execFileSync } from 'node:child_process';
 import {
   SKILLS,
   resolveProjectRoot,
-  skillInstallDir,
   CLAUDE_HOOK_EVENTS,
   installedHookEvents,
   hookModeFromEvents,
@@ -17,6 +16,7 @@ import {
   tokenKind,
   readLorekitJson,
 } from '../shared/config.mjs';
+import { checkSkillVersions } from '../shared/skill-versions.mjs';
 import { splitEndpoint } from '../shared/mcp.mjs';
 import {
   resolveTelemetryConfig,
@@ -71,18 +71,48 @@ export async function doctor(args) {
   // skill under home, not the repo, so a project-only check reports a healthy
   // global install as "not found" (exactly the false FAIL a --global setup would
   // hit).
+  //
+  // Beyond existence, each installed scope now reports its VERSION against the
+  // one this CLI ships (`checkSkillVersions` — an offline compare of
+  // `metadata.version` in SKILL.md's frontmatter, see `shared/skill-versions.mjs`).
+  // An `outdated` or `unknown` (legacy, unparseable) install is a `warn`, never a
+  // `fail` — the skill still works, it just has no signal to update without this
+  // line — and names the fix scope-aware, mirroring the hooks-upgrade wording
+  // above: `lorekit update` is what a stale install is missing, the same way
+  // `lorekit install --hooks <mode>` is what a stale hook wiring is missing.
+  const skillVersions = checkSkillVersions(root);
   for (const skill of SKILLS) {
-    const skillMd = [
-      skillInstallDir(root, 'project', skill.name),
-      skillInstallDir(root, 'global', skill.name),
-    ]
-      .map((dir) => path.join(dir, 'SKILL.md'))
-      .find((p) => fs.existsSync(p));
-    if (skillMd) {
-      const rel = path.relative(root, skillMd);
-      record('pass', `skill ${skill.name}`, rel && !rel.startsWith('..') ? rel : prettyPath(skillMd));
-    } else {
+    const installedEntries = skillVersions.filter(
+      (r) => r.name === skill.name && r.state !== 'not-installed',
+    );
+    if (installedEntries.length === 0) {
       record('fail', `skill ${skill.name}`, 'not found — run `lorekit install`');
+      continue;
+    }
+    for (const entry of installedEntries) {
+      const rel = path.relative(root, entry.installedPath);
+      const displayPath = rel && !rel.startsWith('..') ? rel : prettyPath(entry.installedPath);
+      // Only distinguish the scope in the label when the skill is installed in
+      // more than one — the common single-scope case keeps the pre-existing
+      // `skill <name>` label so it doesn't churn every doctor transcript.
+      const label = installedEntries.length > 1 ? `skill ${skill.name} (${entry.scope})` : `skill ${skill.name}`;
+      if (entry.state === 'current') {
+        record('pass', label, `${displayPath} — v${entry.installed}`);
+      } else if (entry.state === 'outdated') {
+        record(
+          'warn',
+          label,
+          `${displayPath} — v${entry.installed}, shipped v${entry.shipped} — ` +
+            `run \`lorekit update --${entry.scope}\` to refresh`,
+        );
+      } else {
+        record(
+          'warn',
+          label,
+          `${displayPath} — version unknown (legacy install predates version stamping) — ` +
+            `run \`lorekit update --${entry.scope}\` to refresh`,
+        );
+      }
     }
   }
 

package/src/commands/hook.mjs

@@ -30,6 +30,7 @@ import {
   recordShownLessons,
 } from '../core/state.mjs';
 import { recordFixture } from '../core/record.mjs';
+import { resolveUpdateNudge } from '../core/update-notify.mjs';
 import { claude } from '../adapters/claude.mjs';
 import { cursor } from '../adapters/cursor.mjs';
 import { codex } from '../adapters/codex.mjs';
@@ -62,6 +63,20 @@ function hookMeterAttrs(meter) {
   return attrs;
 }
 
+// Append the offline skill-update nudge to the SessionStart block, when the
+// throttle allows it. Best-effort by design — a broken drift check or a
+// throttle-file write failure must never cost the reader their lessons block,
+// so any error here silently falls back to `text` unmodified.
+function appendUpdateNudge(text, root, control) {
+  try {
+    const nudge = resolveUpdateNudge(root, { notify: control.updatesNotify });
+    if (!nudge) return text;
+    return text ? `${text}\n\n${nudge}` : nudge;
+  } catch {
+    return text;
+  }
+}
+
 function readStdin() {
   return new Promise((resolve) => {
     let data = '';
@@ -164,9 +179,10 @@ async function run(args, meter) {
       // No store: emit a minimal header + instruction when present, then return.
       // A SessionStart that cannot read lore is the highest-value failure to see.
       meter.outcome = HOOK_OUTCOME.STORE_UNAVAILABLE;
-      if (sessionInstruction) {
-        emit(formatLessons(null, { repoScope: null }, { instruction: sessionInstruction }));
-      }
+      const base = sessionInstruction
+        ? formatLessons(null, { repoScope: null }, { instruction: sessionInstruction })
+        : null;
+      emit(appendUpdateNudge(base, root, control));
       return 0;
     }
     const { scope: readScope, lessons, scopeCounts, applicable } = await fetchLessons(store, root, {
@@ -174,7 +190,7 @@ async function run(args, meter) {
       branchHint: control.hooksSessionStartBranchHint !== 'off',
       maxLessons: control.hooksSessionStartMaxLessons,
     });
-    emit(formatLessons(lessons, readScope, {
+    const lessonsBlock = formatLessons(lessons, readScope, {
       instruction: sessionInstruction,
       mode: control.hooksSessionStart,
       maxChars: control.hooksSessionStartMaxChars,
@@ -192,7 +208,8 @@ async function run(args, meter) {
       // `recordShownLessons` never throws, and a failure costs at most one
       // repeated lesson later in the session.
       onShown: (rendered) => recordShownLessons(parsed.sessionId, rendered.map(lessonId)),
-    }));
+    });
+    emit(appendUpdateNudge(lessonsBlock, root, control));
     return 0;
   }
 

package/src/commands/lint.mjs

@@ -1,8 +1,10 @@
 // `lorekit lint` — flag low-quality lessons across the applicable scopes and
 // both stores. Each finding names the rule it violated (empty/whitespace value,
 // suspiciously short value, untrimmed value, empty key, volatile key, malformed
-// scope). The rules are pure predicates in `lessons-view.mjs` (`LINT_RULES` /
-// `lintEntry`), each independently unit-tested.
+// scope, unkinded state record, hidden metadata — an HTML comment / front-matter /
+// `key=value` header in a body that should be pure markdown). The rules are pure
+// predicates in `lessons-view.mjs` (`LINT_RULES` / `lintEntry`), each
+// independently unit-tested.
 //
 // Exit convention: `lint` exits NON-ZERO (1) when any finding exists, so it is
 // usable as a CI gate (`lorekit lint || fail`); a clean run — or a run where the

package/src/commands/update.mjs

@@ -0,0 +1,190 @@
+// `lorekit update` — refresh the bundled skills (and their hook wiring) to the
+// versions shipped with the running CLI.
+//
+// Fully offline: the shipped skill source travels in the SAME npm tarball as
+// this running CLI (`SKILLS[].source` in `shared/config.mjs`), so "installed
+// vs shipped" is a filesystem compare with zero network calls — see
+// `shared/skill-versions.mjs`, the same module `doctor` and the SessionStart
+// drift nudge (`core/update-notify.mjs`) read through, so all three surfaces
+// agree on what counts as outdated.
+//
+// `--check` is a dry run: report drift, write nothing. Without it, `update`
+// first PRUNES any file present in the install that the shipped skill no
+// longer ships (`pruneRemoved` — `copyDir` only ever writes, so without this
+// a rule file a newer version dropped would survive every future refresh
+// forever), then re-copies (force) every skill into whichever scope(s)
+// already have an install — reusing `copyDir`, the exact same skill-copy path
+// `install` uses, so the two can never drift on what "installing a skill"
+// means — and refreshes that scope's hook command string via `upsertClaudeHooks`, the
+// same call `install --force` makes. That refresh is deliberately in scope:
+// a stale `npx -y @lorekit/cli@1.2.3 hook …` pin or an old runner path is the
+// same class of drift this command exists to fix, the call is idempotent
+// (it only rewrites the command string, never the wired event set), and
+// skipping it would leave `update` unable to repair the one other thing an
+// install can go stale on. `--project` / `--global` narrow to one scope;
+// with neither, every scope that currently has an existing skill install is
+// refreshed — `update` never CREATES a fresh install, that stays `install`'s
+// job.
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  SKILLS,
+  resolveProjectRoot,
+  skillInstallDir,
+  copyDir,
+  installedHookEvents,
+  upsertClaudeHooks,
+  resolveHookRunner,
+} from '../shared/config.mjs';
+import { checkSkillVersions, SKILL_SCOPES } from '../shared/skill-versions.mjs';
+import { log, heading, status, c } from '../shared/util.mjs';
+
+// Which scopes `update` should touch. Explicit `--project`/`--global` narrow
+// to exactly one — but only when that scope actually has something installed;
+// naming a scope with nothing in it must still fall through to the "nothing
+// to update" report below, never silently report health on an empty scope.
+// `--global` is checked first, matching `install`/`uninstall`'s own
+// scope-flag precedence, so `--project --global` never picks the opposite
+// scope from its sibling commands.
+// With neither flag, every scope holding at least one installed skill (any
+// state other than `not-installed`) is refreshed.
+function targetScopes(args, results) {
+  const hasInstall = (scope) => results.some((r) => r.scope === scope && r.state !== 'not-installed');
+  if (args.global) return hasInstall('global') ? ['global'] : [];
+  if (args.project) return hasInstall('project') ? ['project'] : [];
+  return SKILL_SCOPES.filter(hasInstall);
+}
+
+// Remove any file under `dest` that no longer exists in `src` before the
+// refresh copy. `copyDir` only ever WRITES — it has no delete path — so a
+// rule/reference file a newer skill version dropped would otherwise survive
+// every future `update` forever, still sitting on disk and still read by the
+// agent alongside the content that superseded it, while `update` reports a
+// clean "already up to date" or a green "refreshed". Safe to prune
+// unconditionally: `update` never touches a scope the caller didn't already
+// have installed, and the refresh that follows overwrites everything that
+// DOES still exist in `src` anyway (`--force`), so nothing reachable from the
+// shipped skill is ever at risk — only content the shipped skill no longer
+// ships is removed.
+// `dryRun: true` counts what WOULD be removed without touching disk — the
+// preview `--check` shows for the one destructive step `update` takes, so a
+// dry run never has to say "outdated" and stay silent about a file the real
+// run is about to delete.
+function pruneRemoved(src, dest, { dryRun = false } = {}) {
+  if (!fs.existsSync(dest)) return 0;
+  let removed = 0;
+  for (const entry of fs.readdirSync(dest, { withFileTypes: true })) {
+    const destPath = path.join(dest, entry.name);
+    const srcPath = path.join(src, entry.name);
+    if (entry.isDirectory()) {
+      if (fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory()) {
+        removed += pruneRemoved(srcPath, destPath, { dryRun });
+      } else {
+        if (!dryRun) fs.rmSync(destPath, { recursive: true, force: true });
+        removed++;
+      }
+    } else if (!fs.existsSync(srcPath)) {
+      if (!dryRun) fs.rmSync(destPath, { force: true });
+      removed++;
+    }
+  }
+  return removed;
+}
+
+const versionLabel = (v) => (v ? `v${v}` : 'unknown');
+
+export async function update(args) {
+  const root = resolveProjectRoot(args.dir);
+  const dryRun = Boolean(args.check);
+
+  heading(dryRun ? 'LoreKit update (--check)' : 'LoreKit update');
+  log(`  project: ${c.dim(root)}`);
+
+  const results = checkSkillVersions(root);
+  const scopes = targetScopes(args, results);
+
+  if (scopes.length === 0) {
+    log('');
+    log(`  ${c.dim('no existing skill install found — nothing to update.')}`);
+    log(`  Run ${c.cyan('lorekit install')} for a fresh install.`);
+    return { exitCode: 0, 'lorekit.cli.update.scopes': 0, 'lorekit.cli.update.outdated': 0, 'lorekit.cli.update.check': dryRun };
+  }
+
+  heading('Skills');
+  let outdatedCount = 0;
+  let filesWritten = 0;
+  let filesRemoved = 0;
+  for (const scope of scopes) {
+    for (const skill of SKILLS) {
+      const entry = results.find((r) => r.scope === scope && r.name === skill.name);
+      if (!entry || entry.state === 'not-installed') continue;
+      const label = scopes.length > 1 ? `skill ${skill.name} (${scope})` : `skill ${skill.name}`;
+
+      if (entry.state === 'current') {
+        status('pass', label, `${versionLabel(entry.installed)} — already up to date`);
+        continue;
+      }
+
+      outdatedCount++;
+      const before = versionLabel(entry.installed);
+      const after = versionLabel(entry.shipped);
+      const dest = skillInstallDir(root, scope, skill.name);
+      if (dryRun) {
+        const wouldRemove = pruneRemoved(skill.source, dest, { dryRun: true });
+        const removedNote = wouldRemove > 0 ? `, ${wouldRemove} to remove` : '';
+        status('warn', label, `${before} → ${after} available${removedNote} — run \`lorekit update\` to refresh`);
+        continue;
+      }
+
+      const removed = pruneRemoved(skill.source, dest);
+      const written = copyDir(skill.source, dest, { force: true });
+      filesWritten += written;
+      filesRemoved += removed;
+      const removedNote = removed > 0 ? `, ${removed} removed` : '';
+      status('pass', label, `${before} → ${after} (${written} file(s) written${removedNote})`);
+    }
+  }
+
+  // Hook command strings — refreshed for real, never on a dry run. Only a
+  // scope that already has hooks wired has anything to refresh; a scope with
+  // none stays untouched (matching `install`'s own "nothing to wire" no-op).
+  // `upsertClaudeHooks` rewrites `.claude/settings.json` unconditionally
+  // (formatting included) even when every entry was already `unchanged` —
+  // tallying its returned counts is what lets the no-skills-outdated report
+  // below say so instead of silently rewriting the file underneath the user.
+  let hooksChanged = 0;
+  if (!dryRun) {
+    for (const scope of scopes) {
+      const wired = installedHookEvents(root, scope);
+      if (wired.length === 0) continue;
+      const stats = upsertClaudeHooks(root, scope, resolveHookRunner(), wired);
+      hooksChanged += stats.added + stats.updated + stats.removed + stats.deduped;
+    }
+  }
+
+  log('');
+  if (outdatedCount === 0) {
+    const hooksNote = hooksChanged > 0 ? ` (hook wiring refreshed: ${hooksChanged} change${hooksChanged === 1 ? '' : 's'})` : '';
+    log(`  ${c.green('✓')} every installed skill is already at the shipped version${hooksNote}.`);
+  } else if (dryRun) {
+    const plural = outdatedCount === 1 ? '' : 's';
+    log(`  ${c.yellow('!')} ${outdatedCount} skill install${plural} outdated — run \`lorekit update\` to apply.`);
+  } else {
+    const plural = outdatedCount === 1 ? '' : 's';
+    const removedNote = filesRemoved > 0 ? `, ${filesRemoved} removed` : '';
+    log(`  ${c.green('✓')} refreshed ${outdatedCount} skill install${plural} (${filesWritten} file(s) written${removedNote}).`);
+  }
+  log('');
+
+  return {
+    // Non-zero only for a `--check` run that found drift — a real run always
+    // finishes at 0 (it just fixed whatever it found), matching `doctor`'s own
+    // deliberate warn-never-fail posture. This is what lets `--check` gate a
+    // CI step or pre-commit hook on "everything is current" instead of only
+    // ever reporting drift for a human to notice.
+    exitCode: dryRun && outdatedCount > 0 ? 1 : 0,
+    'lorekit.cli.update.scopes': scopes.length,
+    'lorekit.cli.update.outdated': outdatedCount,
+    'lorekit.cli.update.check': dryRun,
+  };
+}

package/src/commands.mjs

@@ -36,6 +36,7 @@
 import { install } from './commands/install.mjs';
 import { uninstall } from './commands/uninstall.mjs';
 import { doctor } from './commands/doctor.mjs';
+import { update } from './commands/update.mjs';
 import { list } from './commands/list.mjs';
 import { search } from './commands/search.mjs';
 import { show } from './commands/show.mjs';
@@ -74,6 +75,7 @@ export const COMMANDS = [
   { name: 'install', run: install, traced: true, strictFlags: true, native: 'scaffolds skills, hooks and MCP config on disk' },
   { name: 'uninstall', run: uninstall, traced: true, strictFlags: true, native: 'removes what install wrote' },
   { name: 'doctor', run: doctor, traced: true, strictFlags: true, native: 'connectivity / token / scope health check' },
+  { name: 'update', run: update, traced: true, strictFlags: true, native: 'offline refresh of the bundled skills + hook wiring' },
   { name: 'list', run: list, traced: true, strictFlags: true, tool: 'memory.list', aliases: ['ls'] },
   { name: 'search', run: search, traced: true, strictFlags: true, tool: 'memory.search', aliases: ['grep'] },
   { name: 'show', run: show, traced: true, strictFlags: true, tool: 'memory.read' },