simt-dev 0.5.0 → 0.6.0

package/src/index/store.mjs

@@ -4,7 +4,7 @@
 // otherwise. Either one is a cache: `git ls-files -s` can rebuild it, so a missing
 // file is not a lost database. A blob that has not changed is not read again.
 
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { stat } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 
@@ -387,9 +387,9 @@ export async function packageOf(root, filePath, cache) {
   }
 }
 
-function git(root, args, input, binary = false) {
+function git(root, args, input) {
   return new Promise((resolve, reject) => {
-    const child = execFile('git', args, { cwd: root, encoding: binary ? 'buffer' : 'utf8', maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+    const child = execFile('git', args, { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
       if (error) reject(Object.assign(error, { stdout, stderr }));
       else resolve(stdout);
     });
@@ -477,28 +477,58 @@ function normalise(filePath, got) {
   return { symbols, imports: Array.isArray(got.imports) ? got.imports : [], edges };
 }
 
+/**
+ * The body of each listed blob, read as one `cat-file --batch` stream.
+ *
+ * Streamed and parsed incrementally rather than buffered: the combined output of a
+ * repository whose tracked content exceeds execFile's maxBuffer (64 MiB) used to
+ * reject the whole index with "stdout maxBuffer length exceeded" — an ~82 MiB
+ * Android checkout died on first run for exactly that reason.
+ */
 export async function blobTexts(root, blobs) {
   const unique = [...new Set(blobs)];
   const texts = new Map();
   if (unique.length === 0) return texts;
-  const stdout = await git(root, ['cat-file', '--batch'], `${unique.join('\n')}\n`, true);
-  let offset = 0;
-  while (offset < stdout.length) {
-    const nl = stdout.indexOf(0x0a, offset);
-    if (nl < 0) break;
-    const header = stdout.toString('utf8', offset, nl);
-    const parts = header.split(' ');
-    const size = Number(parts[2]);
-    if (parts[1] !== 'blob' || !Number.isFinite(size)) {
-      offset = nl + 1;
-      continue;
+  const child = spawn('git', ['cat-file', '--batch'], { cwd: root });
+  child.stdin.end(`${unique.join('\n')}\n`);
+  let pending = null;
+  const onChunk = (chunk) => {
+    pending = pending === null ? chunk : Buffer.concat([pending, chunk]);
+    let consumed = 0;
+    for (;;) {
+      const nl = pending.indexOf(0x0a, consumed);
+      if (nl < 0) break;
+      const parts = pending.toString('utf8', consumed, nl).split(' ');
+      const size = Number(parts[2]);
+      if (parts[1] !== 'blob' || !Number.isFinite(size)) {
+        consumed = nl + 1;
+        continue;
+      }
+      const end = nl + 1 + size + 1;
+      if (pending.length < end) break; // the body is not fully arrived yet
+      const start = nl + 1;
+      const body = pending.subarray(start, start + size);
+      consumed = end;
+      texts.set(parts[0], body.includes(0) ? null : body.toString('utf8'));
     }
-    const start = nl + 1;
-    const body = stdout.subarray(start, start + size);
-    offset = start + size + 1;
-    texts.set(parts[0], body.includes(0) ? null : body.toString('utf8'));
-  }
-  return texts;
+    // Drop the consumed prefix. Copy the tail once it has grown past a MiB, so the
+    // released bytes are actually freed instead of staying alive behind a view into
+    // the buffer they came from.
+    if (consumed > 0) {
+      const tail = pending.subarray(consumed);
+      pending = tail.length === 0 ? null : consumed >= 1 << 20 ? Buffer.from(tail) : tail;
+    }
+  };
+  return new Promise((resolve, reject) => {
+    let stderr = '';
+    child.stderr.on('data', (d) => { stderr += d; });
+    child.stdout.on('data', onChunk);
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code !== 0) reject(new Error(`git cat-file --batch exited ${code}${stderr ? `: ${stderr.trim()}` : ''}`));
+      else resolve(texts);
+    });
+  });
 }
 
 async function blobSizes(root, blobs) {

package/src/ledger/index.mjs

@@ -22,7 +22,7 @@ import {
 
 const exec = promisify(execFile);
 
-const LEDGER_FILE = '.simt-dev/ledger.jsonl';
+const LEDGER_FILE = '.simt/ledger.jsonl';
 
 /** Phrases that claim a run happened. `unverified` and `not verified` are removed
  *  first, because both contain the word and neither is a claim. */
@@ -76,7 +76,7 @@ export async function recordRun(root, { cmd, exit, ms, output }) {
         }
       : {}),
   };
-  await mkdir(join(root, '.simt-dev'), { recursive: true });
+  await mkdir(join(root, '.simt'), { recursive: true });
   await appendFile(join(root, LEDGER_FILE), `${JSON.stringify(line)}\n`);
 
   if (exit === 0 && typeof cmd === 'string') {

package/src/local/client.mjs

@@ -26,6 +26,7 @@ function guardEndpoint(endpoint, { allowRemote = false } = {}) {
   if (!model) {
     return { ok: false, error: 'local model endpoint is missing `model`', refusedRemote: false };
   }
+  const apiKey = typeof endpoint.apiKey === 'string' && endpoint.apiKey.length > 0 ? endpoint.apiKey : null;
   const loopback = isLoopbackUrl(rawUrl);
   if (!loopback && !allowRemote) {
     return {
@@ -39,6 +40,7 @@ function guardEndpoint(endpoint, { allowRemote = false } = {}) {
     url: rawUrl,
     baseUrl: resolveEndpointUrl(rawUrl, ''),
     model,
+    apiKey,
     timeoutMs: Number.isInteger(endpoint.timeoutMs) && endpoint.timeoutMs > 0
       ? endpoint.timeoutMs
       : DEFAULT_LOCAL_TIMEOUT_MS,
@@ -46,13 +48,20 @@ function guardEndpoint(endpoint, { allowRemote = false } = {}) {
   };
 }
 
-async function requestJson(url, { method = 'GET', body = undefined, timeoutMs = DEFAULT_LOCAL_TIMEOUT_MS, fetchImpl = globalThis.fetch } = {}) {
+async function requestJson(url, { method = 'GET', body = undefined, timeoutMs = DEFAULT_LOCAL_TIMEOUT_MS, apiKey = null, fetchImpl = globalThis.fetch } = {}) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
+    const headers = {
+      ...(body !== undefined ? { 'content-type': 'application/json' } : {}),
+      accept: 'application/json',
+    };
+    if (typeof apiKey === 'string' && apiKey.length > 0) {
+      headers.authorization = `Bearer ${apiKey}`;
+    }
     const response = await fetchImpl(url, {
       method,
-      headers: body !== undefined ? { 'content-type': 'application/json', accept: 'application/json' } : { accept: 'application/json' },
+      headers,
       body: body !== undefined ? JSON.stringify(body) : undefined,
       signal: controller.signal,
     });
@@ -121,6 +130,7 @@ export async function localModels(endpoint, { allowRemote = false, fetchImpl = g
   const res = await requestJson(targetUrl, {
     method: 'GET',
     timeoutMs: guard.timeoutMs,
+    apiKey: guard.apiKey,
     fetchImpl,
   });
   if (!res.ok) {
@@ -200,6 +210,7 @@ export async function localChat(
       stream: false,
     },
     timeoutMs: guard.timeoutMs,
+    apiKey: guard.apiKey,
     fetchImpl,
   });
 
@@ -216,12 +227,14 @@ export async function localChat(
   }
 
   const choice = Array.isArray(res.data.choices) ? res.data.choices[0] : null;
-  const content =
-    typeof choice?.message?.content === 'string'
-      ? choice.message.content
-      : typeof choice?.text === 'string'
-        ? choice.text
-        : null;
+  const message = choice?.message ?? {};
+  // Prefer the final answer. A reasoning model (omlx, Qwen3-thinking) emits its
+  // output in `reasoning_content` and leaves `content` empty or absent when the
+  // budget is tiny (e.g. doctor's 1-token ping), so fall back to it, then the
+  // legacy `text` field. Whitespace-only output counts as absent.
+  const content = [message.content, message.reasoning_content, choice?.text]
+    .map((value) => (typeof value === 'string' && value.trim().length > 0 ? value : null))
+    .find((value) => value !== null) ?? null;
 
   if (content === null) {
     return {
@@ -275,6 +288,7 @@ export async function localEmbed(
       input: Array.isArray(input) ? input.map(String) : String(input ?? ''),
     },
     timeoutMs: guard.timeoutMs,
+    apiKey: guard.apiKey,
     fetchImpl,
   });
 

package/src/local/config.mjs

@@ -8,6 +8,10 @@
 //     "embed": { "url": "http://127.0.0.1:11434/v1", "model": "nomic-embed-code" }
 //   }
 //
+// Each role also accepts an optional `apiKey` (a non-empty string). When present it is
+// sent as an `Authorization: Bearer <key>` header, for servers that require a token
+// (omlx, llama.cpp `--api-key`, OpenAI-compatible gateways). Omitted by default.
+//
 // Non-loopback URLs are refused unless `--allow-remote` is explicitly passed (ADR-075).
 
 import { EXIT, fail } from '../output/index.mjs';
@@ -114,6 +118,17 @@ function parseEndpoint(role, entry, { allowRemote = false } = {}) {
     };
   }
 
+  // Optional bearer credential for servers that require authentication (omlx,
+  // llama.cpp `--api-key`, OpenAI-compatible gateways). Absent by default: most
+  // local servers (Ollama, LM Studio) accept unauthenticated loopback requests.
+  let apiKey = '';
+  if (entry.apiKey !== undefined) {
+    if (typeof entry.apiKey !== 'string' || entry.apiKey.trim().length === 0) {
+      return { endpoint: null, finding: `\`local.${role}.apiKey\` must be a non-empty string when set` };
+    }
+    apiKey = entry.apiKey;
+  }
+
   const loopback = isLoopbackHost(parsedUrl.hostname);
   const baseUrl = resolveEndpointUrl(rawUrl, '');
   const blocked = !loopback && !allowRemote;
@@ -126,6 +141,7 @@ function parseEndpoint(role, entry, { allowRemote = false } = {}) {
         baseUrl,
         model,
         timeoutMs,
+        apiKey,
         loopback: false,
         blocked: true,
       },
@@ -141,6 +157,7 @@ function parseEndpoint(role, entry, { allowRemote = false } = {}) {
       baseUrl,
       model,
       timeoutMs,
+      apiKey,
       loopback,
       blocked: false,
     },

package/src/locate.mjs

@@ -12,6 +12,7 @@
 // this is a block and not a script.
 
 import { BIN_ENV, BIN_REL, CLI, PACKAGE_NAME } from './name.mjs';
+import { LOCAL_BIN } from './distribute/release.mjs';
 
 /**
  * @param {string} command arguments to hand the tool, with `$ROOT` spelled as a shell
@@ -24,6 +25,13 @@ import { BIN_ENV, BIN_REL, CLI, PACKAGE_NAME } from './name.mjs';
  * @returns {string} POSIX sh source
  */
 export function renderLocator(command, { subject = CLI, remedy = `REMEDY run: npm i -D ${PACKAGE_NAME}` } = {}) {
+  // The remedy is emitted single-quoted (see the assignment at the bottom of the
+  // block), so a quote in it would end that string and re-open the shell to
+  // whatever follows. Refuse at render time: the failure is a template bug, and
+  // it should be found where the string is written, not in a hook on a machine.
+  if (remedy.includes("'")) {
+    throw new Error(`the remedy is embedded single-quoted and cannot contain a quote: ${remedy}`);
+  }
   const D = '$';
   return `# ${D}${BIN_ENV} must name ONE program: an executable on PATH, or a .mjs entry
 # point to hand to node. It cannot be a command line, because there is no safe way
@@ -59,6 +67,15 @@ if [ -f "${D}ROOT/node_modules/${PACKAGE_NAME}/${BIN_REL}" ]; then
   exec node "${D}ROOT/node_modules/${PACKAGE_NAME}/${BIN_REL}" ${command}
 fi
 
+# The binary this repository downloaded for itself: the pinned bytes, no node.
+# It is checked before PATH so a repository's own copy wins over whatever a
+# machine happens to have installed, the same way node_modules wins - and the
+# dispatcher still compares the version it runs against the pin, so a stale
+# copy is refused rather than trusted.
+if [ -x "${D}ROOT/${LOCAL_BIN}" ]; then
+  exec "${D}ROOT/${LOCAL_BIN}" ${command}
+fi
+
 if command -v ${CLI} >/dev/null 2>&1; then
   exec ${CLI} ${command}
 fi
@@ -68,7 +85,11 @@ echo "${CLI}: cannot locate ${subject}." >&2
 # unbound variable aborts the shell, so an unguarded ${D}${BIN_ENV} here would
 # kill the message that exists to explain the failure - and this block only runs
 # when nothing resolved, which is the one moment the reader needs it.
-echo "  looked for: ${D}{${BIN_ENV}:-<unset>}, ${D}ROOT/node_modules/${PACKAGE_NAME}, ${CLI} on PATH" >&2
+echo "  looked for: ${D}{${BIN_ENV}:-<unset>}, ${D}ROOT/node_modules/${PACKAGE_NAME}, ${D}ROOT/${LOCAL_BIN}, ${CLI} on PATH" >&2
+# The remedy is assigned single-quoted and echoed, so a command in it - the binary
+# download derives its platform with $(uname) - stays text here and runs only when
+# the reader runs it. A remedy in double quotes would be half-executed by this echo.
+remedy='${remedy}'
 echo "${remedy}" >&2
 exit 1
 `;

package/src/mcp/prompts.mjs

@@ -0,0 +1,118 @@
+// Two prompt templates for the two jobs this server exists for.
+//
+// A prompt is a message template, not an answer. The server is read-only, so a prompt
+// cannot implement anything either: what it CAN do is hand a calling agent a working set
+// of instructions that name the tools to call and the order to call them in, which is the
+// part a model otherwise has to discover by trial. The text therefore speaks ABOUT the
+// tools and never runs them.
+
+/**
+ * `simt-brief`: start a task from the pre-assembled packet.
+ *
+ * The brief tool is the entry point every other surface points at, so the one prompt a
+ * client needs before it knows the model is "start there". Required `task` degrades to a
+ * visible placeholder rather than an error: a client that ignored the `required` flag at
+ * least gets a message that says so instead of a broken stream, and the agent reading it
+ * knows to ask before calling anything.
+ */
+const SIMT_BRIEF = {
+  name: 'simt-brief',
+  title: 'Work a task from the simt brief',
+  description: 'Start a task from the pre-assembled brief packet, and work from what it selected and why.',
+  arguments: [
+    { name: 'task', description: "the task, in the user's own words", required: true },
+  ],
+};
+
+/**
+ * `simt-slice`: implement one slice of the working plan.
+ *
+ * `id` is optional and omission is the DEFAULT reading - the next slice whose
+ * dependencies are complete is what "implement the next slice" means, and a plan whose
+ * numbering a reader does not know yet has no id to give.
+ */
+const SIMT_SLICE = {
+  name: 'simt-slice',
+  title: 'Implement a plan slice',
+  description: 'Implement the next ready slice of the working plan, or the named one.',
+  arguments: [
+    { name: 'id', description: 'slice id; omitted means the next ready one', required: false },
+  ],
+};
+
+export const PROMPTS = [SIMT_BRIEF, SIMT_SLICE];
+
+/**
+ * The prompt names as words, exported for the tool-vocabulary derivation in
+ * `src/toolwords.mjs`: a name this tool serves over MCP is this tool's own name, and the
+ * estate guard that reads that derivation would otherwise read `simt-brief` the way it
+ * reads a repository (ADR-080).
+ */
+export const PROMPT_WORDS = PROMPTS.map((prompt) => prompt.name);
+
+/**
+ * The prompt named, or null when there is no such name.
+ *
+ * `null`, not a throw: the caller decides what a missing prompt is worth (the server
+ * answers with the method error a client expects), and `getPrompt` stays a lookup.
+ */
+export function getPrompt(name, args = {}) {
+  const brief = name === SIMT_BRIEF.name;
+  const slice = name === SIMT_SLICE.name;
+  if (!brief && !slice) return null;
+
+  // Prompts degrade on missing arguments instead of failing: a template with an unfilled
+  // variable is still readable, and the agent it reaches is exactly the one that can ask
+  // the user what was meant.
+  const id = typeof args?.id === 'string' && args.id.length > 0 ? args.id : null;
+  const text = brief
+    ? briefText(typeof args?.task === 'string' && args.task.trim() !== '' ? args.task : null)
+    : sliceText(id);
+
+  return {
+    description: brief ? SIMT_BRIEF.description : SIMT_SLICE.description,
+    messages: [{ role: 'user', content: { type: 'text', text } }],
+  };
+}
+
+function briefText(task) {
+  const ask = task ?? '(none given - ask the user what to work before calling anything)';
+  return `Work the task through this repository's simt tools before touching code.
+
+The task: ${ask}
+
+1. Call the \`brief\` tool with this task. It returns the pre-assembled packet: the kind
+   of task, the commands that kind needs, the files the index ranks highest, the tests
+   covering them, the decisions governing them and the skills that apply.
+2. Work from the packet. Where something you need was cut to fit the budget, the packet
+   names the tool that fetches it - call that tool instead of guessing.
+3. Make the change, then prove it by running the packet's focused test before anything
+   broader.
+
+Report what changed and the evidence, not a summary of the effort.
+`;
+}
+
+function sliceText(id) {
+  const ask = id
+    ? `id ${id}`
+    : 'the next one whose dependencies are complete';
+  const lead = id
+    ? `Call the \`plan_next\` tool with id "${id}" for the design and acceptance checks of exactly that slice.`
+    : 'Call the `plan_next` tool with no id: it returns the next queued slice whose dependencies are complete, with that slice\'s design section only.';
+  return `Implement one slice of this repository's plan, reading it through the simt tools.
+
+The slice: ${ask}
+
+1. ${lead}
+2. Read \`simt://kernel\` first: the rules this repository packs for its stack, and the
+   ones it defers to \`simt rules show\`. They govern how you work here.
+3. Implement in the design's language, writing the regression test its acceptance check
+   asks for as you go. A slice is done when its checks hold, not when the code runs.
+4. Run the tests the design names, then the full suite - the last both in place and
+   from a copy at a path with no siblings, because a suite that only passes at home has
+   not passed.
+5. Commit locally with a conventional subject and a body that records why, and report
+   the sha. Push only on explicit user approval.
+`;
+}

package/src/mcp/resources.mjs

@@ -1,13 +1,14 @@
-// Rules and decisions as MCP resources.
+// Rules, decisions, the kernel region and the next plan slice as MCP resources.
 //
-// The tools answer questions and the answers are arguments to the next call. These two
-// answer a different request: "what is the rule you would apply, in full". A client that
-// reads them can hold the text rather than reconstructing it from a tool's summary, and
-// a reader outside this estate gets the same bytes an adopting repository's agent reads -
+// The tools answer questions and the answers are arguments to the next call. These
+// answer a different request: "what is the rule you would apply, in full", "what does an
+// agent actually read here", "what does the plan say to do next". A client that reads
+// them can hold the text rather than reconstructing it from a tool's summary, and a
+// reader outside this estate gets the same bytes an adopting repository's agent reads -
 // redacted, because a decision record cites its own rulings and not this repository's
 // layout (ADR-055, ADR-061).
 //
-// Both revisions agree on the shape here. They disagree about what a missing resource
+// All revisions agree on the shape here. They disagree about what a missing resource
 // returns, and that difference is handled in the server, not here: this module answers
 // with a resource or with nothing at all, and never with an empty `contents` array,
 // which the newest revision forbids because it is indistinguishable from an empty rule.
@@ -16,9 +17,9 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
 import { DECISIONS_DIR, loadDecisions, redactEstate, redactInternalPaths } from '../decisions/index.mjs';
-import { CLI } from '../name.mjs';
+import { planNext } from '../plan/index.mjs';
 import { loadMdcRules } from '../projection/mdc.mjs';
-import { loadRules } from '../projection/rules.mjs';
+import { desiredRegion, loadRules } from '../projection/rules.mjs';
 
 const RULES_SCHEME = 'simt://rules/';
 const DECISIONS_SCHEME = 'simt://decisions/';
@@ -27,7 +28,9 @@ const DECISIONS_SCHEME = 'simt://decisions/';
  * RFC 6570 templates, so a client can discover the shape without a hard-coded string.
  *
  * `id` and `adr` are the handles a reader already has: a gate names a rule id and a
- * finding names an ADR, so the template's variable names match what those print.
+ * finding names an ADR, so the template's variable names match what those print. The two
+ * fixed resources (`simt://kernel`, `simt://plan/next`) have no handle to substitute and
+ * so are listed directly, not templated.
  */
 export const RESOURCE_TEMPLATES = [
   {
@@ -57,12 +60,21 @@ export const RESOURCE_TEMPLATES = [
  */
 function parseResourceUri(uri) {
   if (typeof uri !== 'string') return null;
+  // `simt://kernel` is one resource and not a collection: there is no handle to split,
+  // so it is matched whole, and anything that only looks like it (`simt://kernel/`)
+  // falls through to the refusals below.
+  if (uri === 'simt://kernel') return { collection: 'kernel' };
   const [collection, ...rest] = uri.split('://');
   if (collection !== 'simt') return null;
   const [name, ...handle] = rest.join('://').split('/');
   const id = handle.join('/');
   if (!id || id === '.' || id === '..' || id.includes('..')) return null;
   if (name === 'rules' && id.includes('/')) return null;
+  // `plan` holds one resource per working plan, and the handle says which: `next` is the
+  // plan's own vocabulary for the next ready slice. Any other handle names a resource
+  // that does not exist, so it is refused here rather than resolved against a reader's
+  // guess.
+  if (name === 'plan') return id === 'next' ? { collection: 'plan', id: 'next' } : null;
   if (name !== 'rules' && name !== 'decisions') return null;
   return { collection: name, id };
 }
@@ -79,20 +91,67 @@ function resource(collection, id, title, bytes) {
 }
 
 /**
- * Every rule and every decision record, one entry each.
+ * The kernel region for a root, rendered on demand.
+ *
+ * `simt://kernel` promises the kernel's bytes by its name, whatever the repository
+ * declared: the declared mode governs what `sync` writes to disk, not what a read path
+ * may look at, and a read that re-consulted the manifest would answer a different
+ * question than the URI asked (ADR-002). `mode` is threaded through `desiredRegion` for
+ * exactly this caller.
+ */
+function kernelRegion(root) {
+  return desiredRegion(root, { mode: 'kernel' });
+}
+
+/**
+ * Every rule, every decision record, the kernel and - when one is ready - the next
+ * plan slice, one entry each.
  *
  * The list is built from what is on disk rather than from a hand-kept index, so it cannot
  * describe a rule that was renamed or a record that was never written. Order is sorted:
  * the newest revision forbids a set that varies per connection or as a side effect of
  * another request, and a list built from a directory read is the only shape that satisfies
  * that without a cache to invalidate.
+ *
+ * The slice is listed only when one is ready. A listing that promises a read the server
+ * then answers with "not found" is a listing that lies, and the plan's "no ready slice"
+ * cases are information about the plan, which the `plan_next` tool reports, not about a
+ * resource's text.
  */
-export async function listResources() {
-  const [rules, mdc, { decisions }] = await Promise.all([loadRules(null), loadMdcRules(), loadDecisions({ all: true })]);
+export async function listResources(root = process.cwd()) {
+  const [rules, mdc, { decisions }, region, plan] = await Promise.all([
+    loadRules(null),
+    loadMdcRules(),
+    loadDecisions({ all: true }),
+    kernelRegion(root),
+    planNext(root, null),
+  ]);
   // `size` is the bytes on disk rather than the bytes served: `read` redacts a decision
   // before sending it, so the served length is not knowable without reading the file, and
-  // a size that disagrees with the payload is worse than a size that rounds.
+  // a size that disagrees with the payload is worse than a size that rounds. The kernel
+  // and the slice have no such gap - both serve exactly what they list - so their sizes
+  // are the served ones.
   return [
+    {
+      uri: 'simt://kernel',
+      name: 'kernel',
+      title: 'The kernel region',
+      description: 'The rules this repository packs in kernel mode, with the deferrals named by their fetch command',
+      mimeType: 'text/markdown',
+      size: Buffer.byteLength(region.body),
+    },
+    ...(plan.error || !plan.next
+      ? []
+      : [
+          {
+            uri: 'simt://plan/next',
+            name: 'plan/next',
+            title: 'Next plan slice',
+            description: plan.next.title ?? 'the next slice whose dependencies are complete',
+            mimeType: 'text/markdown',
+            size: plan.next.sectionBytes,
+          },
+        ]),
     ...[...rules, ...mdc]
       .filter((rule) => rule.id !== null)
       .map((rule) => resource('rules', rule.id, rule.title ?? rule.id, rule.bytes)),
@@ -107,10 +166,33 @@ export async function listResources() {
  * a protocol error with a code that CHANGED between revisions, so the server decides the
  * code and this module only declines to invent content.
  */
-export async function readResource(uri) {
+export async function readResource(uri, root = process.cwd()) {
   const parsed = parseResourceUri(uri);
   if (parsed === null) return null;
 
+  if (parsed.collection === 'kernel') {
+    const region = await kernelRegion(root);
+    return {
+      uri,
+      mimeType: 'text/markdown',
+      text: region.body,
+      // Listed size is read size here on purpose: the body is served exactly as it is
+      // rendered, so a client that budgets on the listing gets what it budgeted for.
+      bytes: Buffer.byteLength(region.body),
+    };
+  }
+
+  if (parsed.collection === 'plan') {
+    const plan = await planNext(root, null);
+    if (plan.error || !plan.next) return null;
+    return {
+      uri,
+      mimeType: 'text/markdown',
+      text: plan.next.section,
+      bytes: plan.next.sectionBytes,
+    };
+  }
+
   if (parsed.collection === 'rules') {
     const [rules, mdc] = await Promise.all([loadRules(null), loadMdcRules()]);
     const rule = [...rules, ...mdc].find((candidate) => candidate.id === parsed.id);
@@ -147,11 +229,3 @@ function frontmatterOf(rule) {
 function formatValue(value) {
   return Array.isArray(value) ? `[${value.join(', ')}]` : String(value);
 }
-
-/**
- * The remedy a client gets when it asks for something that is not here.
- *
- * A command, not a path, for the reason every remedy in this package is a command: the
- * reader runs this tool, not this checkout.
- */
-const MISSING_REMEDY = `run: ${CLI} rules list, or ${CLI} graph lint to see what this copy can read`;