@smartmemory/compose 0.2.2-beta → 0.2.4-beta

package/lib/checkpoint/reconciler.js

@@ -0,0 +1,207 @@
+/**
+ * lib/checkpoint/reconciler.js — COMP-RESUME slice S8: resume reconciliation.
+ *
+ * CORRECTED BOUNDARY (per the Codex boundary review, blueprint.md "Boundary
+ * review" note + design.md Decision 5):
+ *
+ *   `reconcile()` is DETERMINISTIC. It does NOT:
+ *     - write to the CheckpointStore,
+ *     - mutate any persistent DB (vision-state, etc.),
+ *     - call an LLM / agent connector.
+ *
+ *   It computes and RETURNS a `ReconcileResult`. Persistence and the
+ *   reconciliation agent-run happen at the CALLER:
+ *     - the route (S10 `POST /api/session/bind/reconcile`) applies
+ *       `result.lifecycleMutations` via `store.updateLifecycle` and persists,
+ *     - the orchestrator (S9 `compose_resume` consumer) runs the reconciliation
+ *       agent with `result.reconcilePrompt` when `action === 'needs-sync'`, then
+ *       writes the synced checkpoint and re-decides via `decideAfterSync`.
+ *
+ *   `reconcile()` does NOT mutate the passed-in `item` either — it only emits
+ *   plain mutation descriptors in `result.lifecycleMutations`. The route is the
+ *   SINGLE application point (it calls `appendPhaseHistory`, producing the correct
+ *   dual-shape entry, then persists). Mutating here as well double-applied and
+ *   malformed the entry (Codex impl review #1). It must not perform broad state
+ *   surgery — only the well-defined backfill below.
+ *
+ * @see docs/features/COMP-RESUME/blueprint.md (slice S8 + Boundary review note)
+ * @see docs/features/COMP-RESUME/design.md (Decision 5)
+ *
+ * ReconcileResult = {
+ *   action: 'resume' | 'needs-sync' | 'gate',
+ *   drift: 'clean' | 'advanced' | 'diverged',
+ *   lifecycleMutations: Array<LifecycleMutation>,
+ *   checkpoint: object | null,       // the latest recorded checkpoint (or null)
+ *   rendered: string | null,         // renderCheckpoint(checkpoint) — human-readable resume view
+ *   nextStep?: string | null,        // present on the 'resume' path
+ *   reconcilePrompt?: string,        // present on the 'needs-sync' path
+ *   gatePayload?: object,            // reserved for the orchestrator's gate path
+ * }
+ *
+ * LifecycleMutation (plain descriptor the caller applies + persists):
+ *   { type: 'phaseHistory.append', entry: { from, to, outcome, timestamp } }
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { captureFingerprint, classify } from './fingerprint.js';
+import { reconcilePrompt } from './prompts.js';
+import { renderCheckpoint } from './render.js';
+
+/**
+ * Read `<dataDir>/active-build.json` if present. Tolerates an absent or corrupt
+ * file (returns null) — a crash can leave a torn write, and the reconciler must
+ * degrade gracefully rather than throw.
+ *
+ * @param {string|null} dataDir
+ * @returns {object|null}
+ */
+function readActiveBuild(dataDir) {
+  if (!dataDir) return null;
+  const file = join(dataDir, 'active-build.json');
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return null; // corrupt / partially-written — tolerate
+  }
+}
+
+/**
+ * Rebuild derived state in memory and collect plain mutation descriptors the
+ * caller will apply + persist. Deliberately minimal and well-defined:
+ *
+ *   - phaseHistory backfill: if `item.lifecycle.phaseHistory` is missing/empty
+ *     AND `item.lifecycle.currentPhase` is set, surface a single
+ *     `phaseHistory.append` for `{ from:null, to:currentPhase, outcome:'resumed' }`.
+ *     This repairs the known gap where phaseHistory is never reconstructed after
+ *     a crash from a prior session (design Decision 5 step 1; blueprint C5).
+ *
+ * Returns descriptors ONLY; does not mutate `item`. The route applies them via
+ * appendPhaseHistory and persists (single application point).
+ *
+ * @param {object} item — vision item; inspected, not mutated.
+ * @param {object|null} _activeBuild — parsed active-build.json (reserved for
+ *   future derived-pointer rebuild; not used for broad surgery in v1).
+ * @returns {Array<object>} lifecycleMutations
+ */
+function rebuildDerivedState(item, _activeBuild) {
+  const mutations = [];
+  const lifecycle = item && item.lifecycle;
+  if (!lifecycle) return mutations;
+
+  const history = lifecycle.phaseHistory;
+  const historyEmpty = !Array.isArray(history) || history.length === 0;
+  const currentPhase = lifecycle.currentPhase;
+
+  if (historyEmpty && currentPhase) {
+    // Return a descriptor ONLY — do NOT mutate item.lifecycle.phaseHistory here.
+    // The route (S10) is the single application point: it calls
+    // appendPhaseHistory(item, entry), which produces the correct dual-shape
+    // entry (legacy phase/step/enteredAt/exitedAt + new from/to/outcome/timestamp)
+    // and persists it. Mutating here too would double-append AND the direct push
+    // would omit the legacy fields existing readers expect (Codex impl review #1).
+    const entry = {
+      from: null,
+      to: currentPhase,
+      outcome: 'resumed',
+      timestamp: new Date().toISOString(),
+    };
+    mutations.push({ type: 'phaseHistory.append', entry });
+  }
+
+  return mutations;
+}
+
+/**
+ * Reconcile recorded intent against the live environment and return a
+ * ReconcileResult. Deterministic — no store writes, no DB mutation, no LLM.
+ *
+ * @param {object} args
+ * @param {string} args.featureCode
+ * @param {object} args.item — vision item (may be mutated in memory; see above).
+ * @param {string} args.cwd — repo / working dir to fingerprint.
+ * @param {string} args.featureDir — dir holding phase artifacts.
+ * @param {string|null} [args.composeDir] — `.compose` dir for build-stream lookup.
+ * @param {string|null} [args.dataDir] — `.compose/data` dir.
+ * @param {object} args.store — a CheckpointStore (read-only here).
+ * @param {number} [args.confidenceThreshold=0.6] — passed through for the caller.
+ * @returns {object} ReconcileResult
+ */
+export function reconcile({
+  featureCode,
+  item,
+  cwd,
+  featureDir,
+  composeDir = null,
+  dataDir = null,
+  store,
+  confidenceThreshold = 0.6,
+}) {
+  // 1. Rebuild derived state (in-memory, deterministic). Read active-build.json
+  //    tolerantly; collect lifecycle mutation descriptors for the caller.
+  const activeBuild = readActiveBuild(dataDir);
+  const lifecycleMutations = rebuildDerivedState(item, activeBuild);
+
+  // 2. Load latest recorded intent (read-only). Opportunistically use
+  //    semanticRecall if the backend advertises it; the jsonl floor does not, so
+  //    this falls through to readLatest.
+  let latest = null;
+  const caps = typeof store.capabilities === 'function' ? store.capabilities() : new Set();
+  if (caps && caps.has && caps.has('semanticRecall') && typeof store.semanticRecall === 'function') {
+    const hits = store.semanticRecall(featureCode, '', { limit: 1 });
+    latest = Array.isArray(hits) && hits.length ? hits[0] : null;
+  } else {
+    latest = store.readLatest(featureCode);
+  }
+
+  // 3. Capture the live fingerprint and classify drift against the checkpoint's.
+  const live = captureFingerprint(cwd, { featureDir, composeDir, dataDir });
+  const drift = classify(latest?.fingerprint ?? null, live);
+
+  // A human-readable view of the recorded intent, for the resume UX (wires
+  // renderCheckpoint into the production path — Codex impl review #3).
+  const rendered = latest ? renderCheckpoint(latest) : null;
+
+  // 4. clean / advanced → resume at the recorded nextStep (no agent).
+  if (drift === 'clean' || drift === 'advanced') {
+    return {
+      action: 'resume',
+      nextStep: latest?.soft?.nextStep ?? null,
+      drift,
+      lifecycleMutations,
+      checkpoint: latest,
+      rendered,
+    };
+  }
+
+  // 5. diverged → needs-sync. The orchestrator runs the reconciliation agent
+  //    with this prompt, then writes the synced checkpoint and calls
+  //    decideAfterSync. reconcile itself does NOT run the agent or persist.
+  return {
+    action: 'needs-sync',
+    drift,
+    lifecycleMutations,
+    checkpoint: latest,
+    rendered,
+    reconcilePrompt: reconcilePrompt({
+      staleCheckpoint: latest,
+      liveFingerprint: live,
+      envScan: '',
+    }),
+  };
+}
+
+/**
+ * Pure gate decision made by the orchestrator AFTER it has run the
+ * reconciliation agent (on the needs-sync path) and obtained a confidence.
+ * Kept here, separate from any LLM call, so the decision is unit-testable.
+ *
+ * @param {object} args
+ * @param {number} args.confidence — agent-reported confidence in [0,1].
+ * @param {number} [args.confidenceThreshold=0.6]
+ * @returns {'resume'|'gate'} resume when confidence >= threshold (inclusive), else gate.
+ */
+export function decideAfterSync({ confidence, confidenceThreshold = 0.6 }) {
+  return confidence >= confidenceThreshold ? 'resume' : 'gate';
+}

package/lib/checkpoint/render.js

@@ -0,0 +1,107 @@
+/**
+ * COMP-RESUME S11-render — render a Checkpoint to Markdown for human inspection.
+ *
+ * PURE: no fs, no git, no network, no imports from other checkpoint modules.
+ * Markdown is NOT the store of record (the JSONL backend is); this view exists
+ * only so a human can read a checkpoint (e.g. in `compose_resume` output).
+ *
+ * Anchor checkpoints (soft === null) render an explicit "(anchor — no narrative)"
+ * marker in place of the Intent body. Narrative checkpoints render their
+ * agent-authored goal/nextStep/risks. The Environment section reflects the
+ * deterministic fingerprint (records, never interprets).
+ *
+ * @see docs/features/COMP-RESUME/blueprint.md (slice S11)
+ * @see contracts/checkpoint.schema.json
+ */
+
+const SHORT_SHA_LEN = 7;
+
+/**
+ * Shorten a git sha for display; passes through non-sha / null values.
+ * @param {string|null|undefined} sha
+ * @returns {string}
+ */
+function shortSha(sha) {
+  if (!sha || typeof sha !== 'string') return '(none)';
+  return sha.slice(0, SHORT_SHA_LEN);
+}
+
+/**
+ * Render a markdown bullet list, or a placeholder line when empty.
+ * @param {string[]} items
+ * @param {string} emptyText
+ * @returns {string}
+ */
+function bulletList(items, emptyText) {
+  if (!Array.isArray(items) || items.length === 0) return emptyText;
+  return items.map((i) => `- ${i}`).join('\n');
+}
+
+/**
+ * Render a checkpoint to a Markdown string for human inspection.
+ *
+ * @param {object} cp - A Checkpoint (see contracts/checkpoint.schema.json).
+ * @returns {string} markdown
+ */
+export function renderCheckpoint(cp) {
+  const checkpoint = cp || {};
+  const fp = checkpoint.fingerprint || {};
+  const git = fp.git || {};
+  const artifacts = fp.phaseArtifacts || {};
+
+  const lines = [];
+
+  // Heading: featureCode + phase + createdAt
+  const featureCode = checkpoint.featureCode ?? '(unknown feature)';
+  const phase = checkpoint.phase ?? '(unknown phase)';
+  lines.push(`# Checkpoint — ${featureCode} · ${phase}`);
+  lines.push('');
+  const trigger = checkpoint.trigger ? ` · trigger: \`${checkpoint.trigger}\`` : '';
+  lines.push(`_Created: ${checkpoint.createdAt ?? '(unknown)'}${trigger}_`);
+  lines.push('');
+
+  // Intent section
+  lines.push('## Intent');
+  if (checkpoint.soft) {
+    const soft = checkpoint.soft;
+    lines.push(`- **Goal:** ${soft.goal ?? ''}`);
+    lines.push(`- **Next step:** ${soft.nextStep ?? ''}`);
+    lines.push('- **Risks:**');
+    lines.push(bulletList(soft.risks, '  - (none recorded)'));
+  } else {
+    lines.push('(anchor — no narrative)');
+  }
+  lines.push('');
+
+  // Environment section (deterministic fingerprint)
+  lines.push('## Environment');
+  lines.push(`- **Git head:** \`${shortSha(git.head)}\``);
+  lines.push(`- **Branch:** ${git.branch ?? '(none)'}`);
+  lines.push(`- **Tree:** ${git.dirty ? 'dirty' : 'clean'}`);
+
+  // Present phaseArtifacts only (skip null/empty)
+  const present = [];
+  if (artifacts.design) present.push(`design: \`${artifacts.design}\``);
+  if (artifacts.blueprint) present.push(`blueprint: \`${artifacts.blueprint}\``);
+  if (artifacts.plan) present.push(`plan: \`${artifacts.plan}\``);
+  if (Array.isArray(artifacts.implementFiles) && artifacts.implementFiles.length) {
+    present.push(`implement: ${artifacts.implementFiles.map((f) => `\`${f}\``).join(', ')}`);
+  }
+  if (Array.isArray(artifacts.contracts) && artifacts.contracts.length) {
+    present.push(`contracts: ${artifacts.contracts.map((f) => `\`${f}\``).join(', ')}`);
+  }
+  lines.push('- **Artifacts present:**');
+  lines.push(present.length ? present.map((p) => `  - ${p}`).join('\n') : '  - (none)');
+
+  if (fp.testRef) {
+    lines.push(`- **Test output (raw):** \`${fp.testRef}\``);
+  }
+
+  // Confidence line — only when present (resume-sync checkpoints).
+  if (typeof checkpoint.confidence === 'number') {
+    lines.push('');
+    lines.push(`**Confidence:** ${checkpoint.confidence}`);
+  }
+
+  return lines.join('\n');
+}

package/lib/checkpoint/store/index.js

@@ -0,0 +1,67 @@
+/**
+ * lib/checkpoint/store/index.js — CheckpointStore interface + backend registry.
+ *
+ * COMP-RESUME slice S4. The base contract every backend implements:
+ *   - write(cp)                 → persist a Checkpoint, idempotent on cp.id; returns the cp
+ *   - readLatest(featureCode)   → most recent Checkpoint or null
+ *   - list(featureCode, {limit})→ Checkpoints newest-first, sliced to limit
+ *   - capabilities()            → Set<string> of optional capabilities
+ *
+ * Optional (advertised via capabilities(), absent on the jsonl floor):
+ *   - semanticRecall, temporalRange, procedureMatch
+ *
+ * Backend selection defaults to 'jsonl' (read from loadProjectConfig().checkpoint?.backend
+ * by the caller). 'smartmemory' and 'memory-pointer' are registered seams that
+ * throw NOT_IMPLEMENTED in v1.
+ */
+
+import { JsonlCheckpointBackend } from './jsonl.js';
+
+/**
+ * Construct a checkpoint store backend.
+ *
+ * @param {string} [backendId='jsonl'] — one of 'jsonl' | 'smartmemory' | 'memory-pointer'
+ * @param {{ dataDir?: string }} [opts]
+ * @returns {object} a CheckpointStore
+ */
+export function createCheckpointStore(backendId = 'jsonl', { dataDir } = {}) {
+  switch (backendId) {
+    case 'jsonl':
+      return new JsonlCheckpointBackend({ dataDir });
+
+    case 'smartmemory':
+      // ── SmartMemory backend — intended interface mapping (NOT built in v1) ──
+      //
+      // When implemented, map the CheckpointStore contract onto the SmartMemory SDK:
+      //
+      //   write(cp)                  → ReasoningTracesAPI.store({ trace, artifactIds })
+      //                                 (cp.soft + fingerprint serialize into `trace`;
+      //                                  returned trace/artifact ids fill cp.artifactIds)
+      //   readLatest(featureCode)    → TemporalAPI  (most-recent trace for the feature scope)
+      //   list(featureCode, {limit}) → TemporalAPI  (temporal range / latest-N for the scope)
+      //   semanticRecall({query,limit}) → query({ query, limit })   (capability: 'semanticRecall')
+      //   procedureMatch(...)        → ProcedureMatchAPI            (capability: 'procedureMatch')
+      //
+      // Requires adding `smart-memory-sdk-js` as an OPTIONAL peer dep and a LAZY
+      // (dynamic) import here so the dep is only loaded when this backend is
+      // actually selected. Deliberately NOT done in v1 (SmartMemory was scoped
+      // out — see blueprint correction C2).
+      throw Object.assign(
+        new Error('SmartMemory checkpoint backend not implemented'),
+        { code: 'NOT_IMPLEMENTED' }
+      );
+
+    case 'memory-pointer':
+      // Registered seam, deferred. Intended to store only a pointer/ref to an
+      // external memory record rather than the full checkpoint inline.
+      throw Object.assign(
+        new Error('memory-pointer checkpoint backend not implemented'),
+        { code: 'NOT_IMPLEMENTED' }
+      );
+
+    default:
+      throw new Error(
+        `Unknown checkpoint backend '${backendId}'. Valid ids: jsonl, smartmemory, memory-pointer.`
+      );
+  }
+}

package/lib/checkpoint/store/jsonl.js

@@ -0,0 +1,80 @@
+/**
+ * lib/checkpoint/store/jsonl.js — the floor checkpoint backend.
+ *
+ * COMP-RESUME slices S4/S5 (correction C4): checkpoints are stored in
+ * feature-scoped JSONL files `checkpoints-<featureCode>.jsonl` under the data
+ * dir. Feature-scoping keeps `readLatest`/`list` cheap (no global filter) while
+ * each record still carries its own `featureCode`.
+ *
+ * This backend is "floor-only": it implements the base CheckpointStore contract
+ * (write / readLatest / list / capabilities) and advertises no optional
+ * capabilities. Richer backends (e.g. SmartMemory) layer semanticRecall /
+ * temporalRange / procedureMatch on top — see ./index.js.
+ */
+
+import { join } from 'node:path';
+import { appendJsonl, readJsonl } from '../atomic.js';
+
+export class JsonlCheckpointBackend {
+  /**
+   * @param {{ dataDir: string }} opts — dataDir is passed per-construction so the
+   *   backend honors project switches (server re-creates the store on switch).
+   */
+  constructor({ dataDir } = {}) {
+    if (!dataDir) throw new Error('JsonlCheckpointBackend requires { dataDir }');
+    this.dataDir = dataDir;
+  }
+
+  /** Absolute path to the JSONL file for a given feature. */
+  _file(featureCode) {
+    return join(this.dataDir, `checkpoints-${featureCode}.jsonl`);
+  }
+
+  /**
+   * Append a checkpoint. Idempotent on `cp.id`: if a record with the same id
+   * already exists in this feature's file, the existing record is returned and
+   * nothing is appended. Otherwise the cp is appended and returned.
+   *
+   * @param {object} cp — a Checkpoint (must have .id and .featureCode)
+   * @returns {object} the persisted checkpoint
+   */
+  write(cp) {
+    if (!cp || !cp.id) throw new Error('checkpoint requires an id');
+    if (!cp.featureCode) throw new Error('checkpoint requires a featureCode');
+    const file = this._file(cp.featureCode);
+
+    // Idempotency scan. Volume per feature is bounded, so a linear scan is fine.
+    const existing = readJsonl(file);
+    const prior = existing.find((r) => r.id === cp.id);
+    if (prior) return prior;
+
+    appendJsonl(file, cp);
+    return cp;
+  }
+
+  /**
+   * @param {string} featureCode
+   * @returns {object|null} the most-recently-written checkpoint, or null.
+   */
+  readLatest(featureCode) {
+    const all = readJsonl(this._file(featureCode));
+    return all.length ? all[all.length - 1] : null;
+  }
+
+  /**
+   * @param {string} featureCode
+   * @param {{ limit?: number }} [opts]
+   * @returns {object[]} checkpoints for the feature, NEWEST-FIRST, sliced to limit.
+   */
+  list(featureCode, { limit } = {}) {
+    const newestFirst = readJsonl(this._file(featureCode)).reverse();
+    return limit !== undefined ? newestFirst.slice(0, limit) : newestFirst;
+  }
+
+  /**
+   * @returns {Set<string>} optional capabilities — empty for the jsonl floor.
+   */
+  capabilities() {
+    return new Set();
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartmemory/compose",
-  "version": "0.2.2-beta",
+  "version": "0.2.4-beta",
   "description": "Structured AI dev pipeline — goal-to-product orchestration with gates, iteration loops, and feature lifecycle management.",
   "author": "SmartMemory",
   "license": "MIT",

package/server/compose-mcp-tools.js

@@ -238,6 +238,36 @@ export async function toolProposeFollowup(args) {
   return proposeFollowup(getTargetRoot(), args);
 }
 
+// ---------------------------------------------------------------------------
+// Checkpoints / resume — COMP-RESUME
+// ---------------------------------------------------------------------------
+
+// write_checkpoint reads/writes directly from disk so it works even when the
+// Compose server is down (same stance as the rest of this file).
+export async function toolWriteCheckpoint(args) {
+  const { writeCheckpoint } = await import('../lib/checkpoint/checkpoint-writer.js');
+  return writeCheckpoint(getTargetRoot(), args);
+}
+
+// compose_resume HTTP-delegates: reconcile must run server-side where the live
+// vision item / lifecycle state and broadcasts exist (mirrors toolBindSession).
+export async function toolComposeResume({ featureCode }) {
+  let result;
+  try {
+    result = await _httpRequest('POST', '/api/session/bind/reconcile', { featureCode });
+  } catch (err) {
+    throw new Error(`Compose server unreachable: ${err.message}`);
+  }
+  const { status, body } = result;
+  if (status >= 400) {
+    const errMsg = (body && typeof body === 'object' && body.error)
+      ? body.error
+      : `HTTP ${status}: ${typeof body === 'string' ? body : JSON.stringify(body)}`;
+    throw new Error(errMsg);
+  }
+  return body;
+}
+
 // ---------------------------------------------------------------------------
 // Changelog writer — COMP-MCP-CHANGELOG-WRITER
 // ---------------------------------------------------------------------------

package/server/compose-mcp.js

@@ -61,6 +61,8 @@ import {
   toolValidateProject,
   toolSetWorkspace,
   toolGetWorkspace,
+  toolWriteCheckpoint,
+  toolComposeResume,
   _getBinding,
 } from './compose-mcp-tools.js';
 import { switchProject, getTargetRoot } from './project-root.js';
@@ -578,6 +580,42 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'write_checkpoint',
+    description: 'COMP-RESUME: write a durable build checkpoint anchored to a deterministic environment fingerprint. Omit `soft` for a cheap anchor checkpoint — the response then includes a `scribePrompt` you can answer (returning {goal,nextStep,risks} anchored to the fingerprint) and re-submit as `soft` for a narrative checkpoint. Pass `soft` directly to skip that. Returns {checkpoint, scribePrompt}. Direct-to-disk (works when the server is down).',
+    inputSchema: {
+      type: 'object',
+      required: ['featureCode', 'trigger'],
+      properties: {
+        featureCode: { type: 'string' },
+        trigger: { type: 'string', enum: ['phase-transition', 'pre-risky-action', 'iteration-complete', 'gate-resolution', 'manual', 'resume-sync'] },
+        phase: { type: 'string', description: 'Lifecycle phase label; falls back to feature.json then "unknown".' },
+        soft: {
+          type: 'object',
+          description: 'Narrative intent; omit for an anchor checkpoint. Every factual claim should reference a fingerprint anchor.',
+          required: ['goal', 'nextStep'],
+          properties: {
+            goal: { type: 'string' },
+            nextStep: { type: 'string' },
+            risks: { type: 'array', items: { type: 'string' } },
+          },
+        },
+        flowId: { type: 'string', description: 'Stratum flow id, if any.' },
+        confidence: { type: 'number', description: 'Only on resume-sync checkpoints (0..1).' },
+      },
+    },
+  },
+  {
+    name: 'compose_resume',
+    description: 'COMP-RESUME: reconcile a build against ground-truth environment state and return the resume decision. Rebuilds derived state, classifies drift (clean/advanced/diverged), and returns action resume|needs-sync|gate. On needs-sync the caller runs the reconciliation agent with the returned prompt. Requires the Compose server (reconciles live lifecycle state).',
+    inputSchema: {
+      type: 'object',
+      required: ['featureCode'],
+      properties: {
+        featureCode: { type: 'string' },
+      },
+    },
+  },
 ];
 
 // ---------------------------------------------------------------------------
@@ -639,6 +677,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'validate_feature':         result = await toolValidateFeature(args); break;
       case 'validate_project':         result = await toolValidateProject(args); break;
       case 'propose_followup':         result = await toolProposeFollowup(args); break;
+      case 'write_checkpoint':         result = await toolWriteCheckpoint(args); break;
+      case 'compose_resume':           result = await toolComposeResume(args); break;
       // agent_run removed — STRAT-DEDUP-AGENTRUN v1. Use mcp__stratum__stratum_agent_run.
       default:
         return {