dsh-retrace 0.3.0 → 0.4.2

package/lib/dynamic-host.js

@@ -29,10 +29,112 @@ return {
     
     const EDITOR_PLUGIN = 'retrace'
     
-    /** Message-id prefix every event this plugin appends carries (client discriminator). */
+    /**
+     * Message-id prefix every event this plugin appends carries (client discriminator).
+     * RENAME RULE: when the plugin changes identity, KEEP this prefix unchanged for
+     * new markers — or, if it must change, add the old value to the legacy prefix
+     * lists in lib/client.js (MARKER_PREFIXES / LEGACY_MARKER_PREFIXES) and
+     * lib/version-index.js (MARKER_ID_PREFIXES) so old markers keep rendering and
+     * classifying. Recognition must never be broken by a rename.
+     */
     const MARKER_ID_PREFIX = 'retrace'
     
-    function createEditorApi(ctx, sessions, agents, log = () => {}) {
+    /** A fresh marker event id: `<prefix>-<op>-<time36>-<rand>`. */
+    function editorId(op) {
+      return `${MARKER_ID_PREFIX}-${op}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
+    }
+    
+    /** An error carrying a stable wire `code` (mirrors the editor result shape). */
+    function editorError(code, message) {
+      const error = new Error(message)
+      error.code = code
+      return error
+    }
+    
+    /** Latest known provider/model: from the last request header, else last assistant message. */
+    function lastModelSource(session) {
+      const events = session.events
+      for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i]
+        if (event.type === 'request/header') {
+          const config = event.data?.header?.config
+          if (
+            config &&
+            typeof config.provider === 'string' && config.provider.length > 0 &&
+            typeof config.model === 'string' && config.model.length > 0
+          ) {
+            return { provider: config.provider, model: config.model }
+          }
+        }
+        if (event.type === 'assistant/message') {
+          const source = event.data?.message?.source
+          if (
+            source && source.kind === 'model' &&
+            typeof source.provider === 'string' && source.provider.length > 0 &&
+            typeof source.model === 'string' && source.model.length > 0
+          ) {
+            return { provider: source.provider, model: source.model }
+          }
+        }
+      }
+      return null
+    }
+    
+    /**
+     * Append the invisible replacement marker that shadows [span.start..span.end].
+     * Shared by recall/edit/regenerate (L1) and context rollback (P1): an empty
+     * assistant message is a valid surface node yet derives to *no* model message,
+     * so the LLM context simply rewinds. `turn: null` declares a session-level
+     * event (the client location index maps it to SESSION_LOCATION, keeping it out
+     * of every turn's node list). `editor` carries the reference facts the UI uses
+     * for the optional "original input" comparison row.
+     */
+    /**
+     * Append the invisible replacement marker that shadows [span.start..span.end].
+     * Shared by recall/edit/regenerate (L1) and context rollback (P1): an empty
+     * assistant message is a valid surface node yet derives to *no* model message,
+     * so the LLM context simply rewinds. `turn: null` declares a session-level
+     * event (the client location index maps it to SESSION_LOCATION, keeping it out
+     * of every turn's node list). `editor` carries the reference facts the UI uses
+     * for the optional "original input" comparison row.
+     *
+     * The optional `validate` hook receives the would-be event envelope BEFORE it
+     * is committed (validate first, commit later — the 8-25 incident's fix): a
+     * throwing validator aborts the append, so a contract-violating marker can
+     * never reach the durable log. The hook may be async.
+     */
+    async function appendEditorMarker(session, span, op, targetSeq, originalText, validate) {
+      const model = lastModelSource(session)
+      if (!model) {
+        throw editorError(
+          'no-model-header',
+          'This session has no model header yet; send at least one message before recalling or editing.',
+        )
+      }
+      const marker = {
+        id: editorId(op),
+        role: 'assistant',
+        content: [],
+        source: { kind: 'model', provider: model.provider, model: model.model },
+      }
+      const data = {
+        turn: null,
+        step: null,
+        message: marker,
+        editor: {
+          targetSeq,
+          text: typeof originalText === 'string' ? originalText.slice(0, 2000) : '',
+        },
+      }
+      const surfaceOp = { op: 'replace', start: span.start, end: span.end }
+      const sourceEventSeqs = span.shadowedSeqs.slice()
+      if (typeof validate === 'function') {
+        await validate(session, { type: 'assistant/message', data, surfaceOp, sourceEventSeqs })
+      }
+      return session.append('assistant/message', data, { surfaceOp, sourceEventSeqs })
+    }
+    
+    function createEditorApi(ctx, sessions, agents, log = () => {}, hooks = {}) {
       /** One in-flight op per session; later ops wait for the earlier one. */
       const locks = new Map()
     
@@ -46,16 +148,6 @@ return {
         return next
       }
     
-      function editorId(op) {
-        return `${MARKER_ID_PREFIX}-${op}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
-      }
-    
-      function editorError(code, message) {
-        const error = new Error(message)
-        error.code = code
-        return error
-      }
-    
       function requireSession(sessionId) {
         if (typeof sessionId !== 'string' || sessionId.length === 0) {
           throw editorError('bad-request', 'sessionId must be a non-empty string')
@@ -74,35 +166,6 @@ return {
         }
       }
     
-      /** Latest known provider/model: from the last request header, else last assistant message. */
-      function lastModelSource(session) {
-        const events = session.events
-        for (let i = events.length - 1; i >= 0; i--) {
-          const event = events[i]
-          if (event.type === 'request/header') {
-            const config = event.data?.header?.config
-            if (
-              config &&
-              typeof config.provider === 'string' && config.provider.length > 0 &&
-              typeof config.model === 'string' && config.model.length > 0
-            ) {
-              return { provider: config.provider, model: config.model }
-            }
-          }
-          if (event.type === 'assistant/message') {
-            const source = event.data?.message?.source
-            if (
-              source && source.kind === 'model' &&
-              typeof source.provider === 'string' && source.provider.length > 0 &&
-              typeof source.model === 'string' && source.model.length > 0
-            ) {
-              return { provider: source.provider, model: source.model }
-            }
-          }
-        }
-        return null
-      }
-    
       /** Locate the durable seq of a user/assistant message by its stable message id. */
       function findMessageSeq(session, messageId) {
         if (typeof messageId !== 'string' || messageId.length === 0) {
@@ -178,42 +241,6 @@ return {
         }
       }
     
-      /**
-       * Append the invisible replacement marker that shadows [span.start..span.end].
-       * An empty assistant message is a valid surface node yet derives to *no*
-       * model message, so the LLM context simply rewinds. `turn: null` declares a
-       * session-level event (the client location index maps it to SESSION_LOCATION,
-       * keeping it out of every turn's node list). `editor` carries the reference
-       * facts the UI uses for the optional "original input" comparison row.
-       */
-      function appendEditorMarker(session, span, op, targetSeq, originalText) {
-        const model = lastModelSource(session)
-        if (!model) {
-          throw editorError(
-            'no-model-header',
-            'This session has no model header yet; send at least one message before recalling or editing.',
-          )
-        }
-        const marker = {
-          id: editorId(op),
-          role: 'assistant',
-          content: [],
-          source: { kind: 'model', provider: model.provider, model: model.model },
-        }
-        return session.append('assistant/message', {
-          turn: null,
-          step: null,
-          message: marker,
-          editor: {
-            targetSeq,
-            text: typeof originalText === 'string' ? originalText.slice(0, 2000) : '',
-          },
-        }, {
-          surfaceOp: { op: 'replace', start: span.start, end: span.end },
-          sourceEventSeqs: span.shadowedSeqs.slice(),
-        })
-      }
-    
       function extractUserText(content) {
         if (!Array.isArray(content)) return ''
         return content
@@ -276,7 +303,7 @@ return {
         if (seq === -1) throw editorError('message-not-found', 'Message not found in this session.')
         const span = roundSpanFrom(session, seq)
         if (!span) throw editorError('target-shadowed', 'This message is no longer part of the active conversation.')
-        const markerEvent = appendEditorMarker(session, span, 'recall', seq, messageTextOf(session, seq))
+        const markerEvent = await appendEditorMarker(session, span, 'recall', seq, messageTextOf(session, seq), hooks.validateMarker)
         await flushSafely(session)
         return {
           op: 'recall',
@@ -318,7 +345,7 @@ return {
         if (startSeq === undefined) throw editorError('empty-surface', 'This session has no conversation to edit.')
         const span = shadowSpanFrom(session, startSeq)
         if (!span) throw editorError('target-shadowed', 'This message is no longer part of the active conversation.')
-        appendEditorMarker(session, span, 'edit', seq, originalText)
+        await appendEditorMarker(session, span, 'edit', seq, originalText, hooks.validateMarker)
         await flushSafely(session)
         const message = resendMessage(text.trim(), 'resend')
         agent.followup(message)
@@ -367,7 +394,7 @@ return {
         }
         const span = shadowSpanFrom(session, userSeq)
         if (!span) throw editorError('target-shadowed', 'This message is no longer part of the active conversation.')
-        appendEditorMarker(session, span, 'regenerate', userSeq, text)
+        await appendEditorMarker(session, span, 'regenerate', userSeq, text, hooks.validateMarker)
         await flushSafely(session)
         const message = resendMessage(text.trim(), 'resend')
         agent.followup(message)

package/lib/git-adapter.js

@@ -0,0 +1,177 @@
+/**
+ * dsh-retrace — GitAdapter (PLAN.md §4.4).
+ *
+ * All git activity rides the host subprocess seam (`ctx.subprocess`):
+ * read-only commands (`rev-parse`, `status`, `ls-tree`) run freely; write
+ * commands (`init`, `update-ref`, `checkout`, the one-time initial commit)
+ * are only ever issued from user-confirmed flows (one-click init, artifact
+ * rollback). Nothing here touches the working tree directly — every file
+ * change goes through `ctx.fs` (workspace sandbox) or `git checkout` with a
+ * strict path allow-list.
+ *
+ * The adapter is transport-shaped for tests: the caller injects `run` (one
+ * spawn spec in → one outcome out) and `writeText` (workspace sandbox write),
+ * so the test suite exercises the full decision logic with a fake runner
+ * instead of a real git binary.
+ */
+
+import { isAbsolute, join, relative, resolve } from 'node:path'
+
+/** Minimal `.gitignore` written by the one-click init (never touches user files). */
+export const MINIMAL_GITIGNORE = [
+  '# created by dsh-retrace (one-click git init) — remove freely',
+  'node_modules/',
+  'dist/',
+  '*.log',
+  '',
+].join('\n')
+
+const SPILL_LIMIT = 256 * 1024
+
+/** Run-spec → outcome shim over the real host subprocess seam. */
+export function createSubprocessRunner(ctx, log = () => {}) {
+  const command = async (argv, cwd, signal) => {
+    const git = await ctx.subprocess.resolveExecutable('git')
+    const handle = ctx.subprocess.spawn({
+      argv: [git, ...argv],
+      cwd,
+      stdio: {
+        stdin: 'ignore',
+        stdout: { maxBytes: 256 * 1024, spill: { maxBytes: SPILL_LIMIT } },
+        stderr: { maxBytes: 256 * 1024, spill: { maxBytes: SPILL_LIMIT } },
+      },
+      graceMs: 30_000,
+      signal,
+      env: {},
+    })
+    const outcome = await handle.done
+    const collected = handle.collected
+    const read = (reader) => {
+      const value = reader.readFrom(0)
+      return value.text ?? ''
+    }
+    return {
+      ok: outcome.exitCode === 0,
+      exitCode: outcome.exitCode,
+      stdout: read(collected.stdout),
+      stderr: read(collected.stderr),
+    }
+  }
+  const writeText = async (target, content, sandboxPolicy) => {
+    await ctx.fs.writeText(target, content, undefined, undefined, sandboxPolicy)
+  }
+  return { command, writeText }
+}
+
+/**
+ * Create the git adapter.
+ * @param {object} deps
+ * @param {(argv: string[], cwd: string, signal?: AbortSignal) => Promise<{ok:boolean, exitCode?:number, stdout:string, stderr:string}>} deps.command
+ * @param {(target: string, content: string, sandboxPolicy: any) => Promise<void>} deps.writeText — workspace sandbox write (one-click init's .gitignore).
+ * @param {(line: string) => void} [deps.log]
+ */
+export function createGitAdapter({ command, writeText, log = () => {} }) {
+  /** Detect the enclosing repository root from `cwd` (outer repos included). */
+  async function detect(cwd) {
+    if (typeof cwd !== 'string' || cwd.length === 0) return null
+    const run = await command(['rev-parse', '--show-toplevel'], cwd)
+    if (!run.ok) return null
+    const root = run.stdout.trim()
+    return root.length > 0 ? root : null
+  }
+
+  /**
+   * Read-only repo status at `cwd`: HEAD hash + dirty flag + porcelain paths.
+   * Returns null when `cwd` is not inside a repository.
+   */
+  async function status(cwd, signal) {
+    if (typeof cwd !== 'string' || cwd.length === 0) return null
+    const run = await command(['rev-parse', '--show-toplevel'], cwd, signal)
+    if (!run.ok) return null
+    const root = run.stdout.trim()
+    if (root.length === 0) return null
+    const head = await command(['rev-parse', 'HEAD'], cwd, signal)
+    if (!head.ok) return { root, headHash: null, dirty: false, paths: [] }
+    const headHash = head.stdout.trim()
+    const dirtyRun = await command(['status', '--porcelain'], cwd, signal)
+    const paths = dirtyRun.ok
+      ? dirtyRun.stdout.split('\n').map((line) => line.replace(/^.../, '')).filter((p) => p.length > 0)
+      : []
+    return { root, headHash, dirty: paths.length > 0, paths }
+  }
+
+  /** Files present at `headHash` among `paths` (rollback allow-list pre-filter). */
+  async function presentAt(cwd, headHash, paths, signal) {
+    if (paths.length === 0) return []
+    const run = await command(['ls-tree', '-r', '--name-only', headHash, '--', ...paths], cwd, signal)
+    if (!run.ok) return []
+    const present = new Set(run.stdout.split('\n').filter((p) => p.length > 0))
+    return paths.filter((p) => present.has(p))
+  }
+
+  /** Guard every path: relative, inside cwd, no `..` escape, not absolute. */
+  function guardPaths(cwd, paths) {
+    const base = resolve(cwd)
+    const safe = []
+    for (const path of paths) {
+      if (typeof path !== 'string' || path.length === 0) continue
+      if (isAbsolute(path)) continue
+      const resolved = resolve(base, path)
+      const rel = relative(base, resolved)
+      if (rel.startsWith('..') || isAbsolute(rel)) continue
+      safe.push(rel)
+    }
+    return safe
+  }
+
+  /**
+   * Roll `paths` back to their content at `headHash` (`git checkout <hash> -- <paths>`).
+   * Only paths present at the commit are touched; absent ones are no-ops.
+   * @returns {{ok: boolean, checked: string[], skipped: string[], stderr?: string}}
+   */
+  async function checkout(cwd, headHash, paths, signal) {
+    const safe = guardPaths(cwd, paths)
+    if (safe.length === 0) return { ok: true, checked: [], skipped: [] }
+    const present = await presentAt(cwd, headHash, safe, signal)
+    const skipped = safe.filter((p) => !present.includes(p))
+    if (present.length === 0) return { ok: true, checked: [], skipped }
+    const run = await command(['checkout', headHash, '--', ...present], cwd, signal)
+    if (!run.ok) {
+      log(`retrace: git checkout failed: ${run.stderr.trim()}`)
+      return { ok: false, checked: [], skipped: safe, stderr: run.stderr }
+    }
+    return { ok: true, checked: present, skipped }
+  }
+
+  /**
+   * One-click init for a non-repository workspace: `git init` + minimal
+   * `.gitignore` + a baseline commit + the `refs/dsh/versions` ref (the
+   * plugin's own ref; the default branch is only touched by the baseline
+   * commit). Deleting `refs/dsh/versions` afterwards restores the pre-plugin
+   * git state (the baseline commit and .gitignore remain).
+   * @returns {{ok: boolean, root: string, headHash?: string, stderr?: string}}
+   */
+  async function init(cwd, signal) {
+    const base = resolve(cwd)
+    const initRun = await command(['init', '-q'], base, signal)
+    if (!initRun.ok) return { ok: false, root: base, stderr: initRun.stderr }
+    const gitignoreTarget = join(base, '.gitignore')
+    try {
+      await writeText(gitignoreTarget, MINIMAL_GITIGNORE, undefined)
+    } catch (error) {
+      return { ok: false, root: base, stderr: String(error) }
+    }
+    const add = await command(['add', '.gitignore'], base, signal)
+    if (!add.ok) return { ok: false, root: base, stderr: add.stderr }
+    const commit = await command(['commit', '-q', '-m', 'chore(dsh-retrace): initialize version tracking'], base, signal)
+    if (!commit.ok) return { ok: false, root: base, stderr: commit.stderr }
+    const head = await command(['rev-parse', 'HEAD'], base, signal)
+    const headHash = head.ok ? head.stdout.trim() : undefined
+    if (headHash) {
+      await command(['update-ref', 'refs/dsh/versions', headHash], base, signal)
+    }
+    return { ok: true, root: base, headHash }
+  }
+
+  return { detect, status, checkout, init }
+}

package/lib/host-core.js

@@ -20,10 +20,112 @@
 
 export const EDITOR_PLUGIN = 'retrace'
 
-/** Message-id prefix every event this plugin appends carries (client discriminator). */
+/**
+ * Message-id prefix every event this plugin appends carries (client discriminator).
+ * RENAME RULE: when the plugin changes identity, KEEP this prefix unchanged for
+ * new markers — or, if it must change, add the old value to the legacy prefix
+ * lists in lib/client.js (MARKER_PREFIXES / LEGACY_MARKER_PREFIXES) and
+ * lib/version-index.js (MARKER_ID_PREFIXES) so old markers keep rendering and
+ * classifying. Recognition must never be broken by a rename.
+ */
 export const MARKER_ID_PREFIX = 'retrace'
 
-export function createEditorApi(ctx, sessions, agents, log = () => {}) {
+/** A fresh marker event id: `<prefix>-<op>-<time36>-<rand>`. */
+export function editorId(op) {
+  return `${MARKER_ID_PREFIX}-${op}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
+}
+
+/** An error carrying a stable wire `code` (mirrors the editor result shape). */
+export function editorError(code, message) {
+  const error = new Error(message)
+  error.code = code
+  return error
+}
+
+/** Latest known provider/model: from the last request header, else last assistant message. */
+export function lastModelSource(session) {
+  const events = session.events
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i]
+    if (event.type === 'request/header') {
+      const config = event.data?.header?.config
+      if (
+        config &&
+        typeof config.provider === 'string' && config.provider.length > 0 &&
+        typeof config.model === 'string' && config.model.length > 0
+      ) {
+        return { provider: config.provider, model: config.model }
+      }
+    }
+    if (event.type === 'assistant/message') {
+      const source = event.data?.message?.source
+      if (
+        source && source.kind === 'model' &&
+        typeof source.provider === 'string' && source.provider.length > 0 &&
+        typeof source.model === 'string' && source.model.length > 0
+      ) {
+        return { provider: source.provider, model: source.model }
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Append the invisible replacement marker that shadows [span.start..span.end].
+ * Shared by recall/edit/regenerate (L1) and context rollback (P1): an empty
+ * assistant message is a valid surface node yet derives to *no* model message,
+ * so the LLM context simply rewinds. `turn: null` declares a session-level
+ * event (the client location index maps it to SESSION_LOCATION, keeping it out
+ * of every turn's node list). `editor` carries the reference facts the UI uses
+ * for the optional "original input" comparison row.
+ */
+/**
+ * Append the invisible replacement marker that shadows [span.start..span.end].
+ * Shared by recall/edit/regenerate (L1) and context rollback (P1): an empty
+ * assistant message is a valid surface node yet derives to *no* model message,
+ * so the LLM context simply rewinds. `turn: null` declares a session-level
+ * event (the client location index maps it to SESSION_LOCATION, keeping it out
+ * of every turn's node list). `editor` carries the reference facts the UI uses
+ * for the optional "original input" comparison row.
+ *
+ * The optional `validate` hook receives the would-be event envelope BEFORE it
+ * is committed (validate first, commit later — the 8-25 incident's fix): a
+ * throwing validator aborts the append, so a contract-violating marker can
+ * never reach the durable log. The hook may be async.
+ */
+export async function appendEditorMarker(session, span, op, targetSeq, originalText, validate) {
+  const model = lastModelSource(session)
+  if (!model) {
+    throw editorError(
+      'no-model-header',
+      'This session has no model header yet; send at least one message before recalling or editing.',
+    )
+  }
+  const marker = {
+    id: editorId(op),
+    role: 'assistant',
+    content: [],
+    source: { kind: 'model', provider: model.provider, model: model.model },
+  }
+  const data = {
+    turn: null,
+    step: null,
+    message: marker,
+    editor: {
+      targetSeq,
+      text: typeof originalText === 'string' ? originalText.slice(0, 2000) : '',
+    },
+  }
+  const surfaceOp = { op: 'replace', start: span.start, end: span.end }
+  const sourceEventSeqs = span.shadowedSeqs.slice()
+  if (typeof validate === 'function') {
+    await validate(session, { type: 'assistant/message', data, surfaceOp, sourceEventSeqs })
+  }
+  return session.append('assistant/message', data, { surfaceOp, sourceEventSeqs })
+}
+
+export function createEditorApi(ctx, sessions, agents, log = () => {}, hooks = {}) {
   /** One in-flight op per session; later ops wait for the earlier one. */
   const locks = new Map()
 
@@ -37,16 +139,6 @@ export function createEditorApi(ctx, sessions, agents, log = () => {}) {
     return next
   }
 
-  function editorId(op) {
-    return `${MARKER_ID_PREFIX}-${op}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
-  }
-
-  function editorError(code, message) {
-    const error = new Error(message)
-    error.code = code
-    return error
-  }
-
   function requireSession(sessionId) {
     if (typeof sessionId !== 'string' || sessionId.length === 0) {
       throw editorError('bad-request', 'sessionId must be a non-empty string')
@@ -65,35 +157,6 @@ export function createEditorApi(ctx, sessions, agents, log = () => {}) {
     }
   }
 
-  /** Latest known provider/model: from the last request header, else last assistant message. */
-  function lastModelSource(session) {
-    const events = session.events
-    for (let i = events.length - 1; i >= 0; i--) {
-      const event = events[i]
-      if (event.type === 'request/header') {
-        const config = event.data?.header?.config
-        if (
-          config &&
-          typeof config.provider === 'string' && config.provider.length > 0 &&
-          typeof config.model === 'string' && config.model.length > 0
-        ) {
-          return { provider: config.provider, model: config.model }
-        }
-      }
-      if (event.type === 'assistant/message') {
-        const source = event.data?.message?.source
-        if (
-          source && source.kind === 'model' &&
-          typeof source.provider === 'string' && source.provider.length > 0 &&
-          typeof source.model === 'string' && source.model.length > 0
-        ) {
-          return { provider: source.provider, model: source.model }
-        }
-      }
-    }
-    return null
-  }
-
   /** Locate the durable seq of a user/assistant message by its stable message id. */
   function findMessageSeq(session, messageId) {
     if (typeof messageId !== 'string' || messageId.length === 0) {
@@ -169,42 +232,6 @@ export function createEditorApi(ctx, sessions, agents, log = () => {}) {
     }
   }
 
-  /**
-   * Append the invisible replacement marker that shadows [span.start..span.end].
-   * An empty assistant message is a valid surface node yet derives to *no*
-   * model message, so the LLM context simply rewinds. `turn: null` declares a
-   * session-level event (the client location index maps it to SESSION_LOCATION,
-   * keeping it out of every turn's node list). `editor` carries the reference
-   * facts the UI uses for the optional "original input" comparison row.
-   */
-  function appendEditorMarker(session, span, op, targetSeq, originalText) {
-    const model = lastModelSource(session)
-    if (!model) {
-      throw editorError(
-        'no-model-header',
-        'This session has no model header yet; send at least one message before recalling or editing.',
-      )
-    }
-    const marker = {
-      id: editorId(op),
-      role: 'assistant',
-      content: [],
-      source: { kind: 'model', provider: model.provider, model: model.model },
-    }
-    return session.append('assistant/message', {
-      turn: null,
-      step: null,
-      message: marker,
-      editor: {
-        targetSeq,
-        text: typeof originalText === 'string' ? originalText.slice(0, 2000) : '',
-      },
-    }, {
-      surfaceOp: { op: 'replace', start: span.start, end: span.end },
-      sourceEventSeqs: span.shadowedSeqs.slice(),
-    })
-  }
-
   function extractUserText(content) {
     if (!Array.isArray(content)) return ''
     return content
@@ -267,7 +294,7 @@ export function createEditorApi(ctx, sessions, agents, log = () => {}) {
     if (seq === -1) throw editorError('message-not-found', 'Message not found in this session.')
     const span = roundSpanFrom(session, seq)
     if (!span) throw editorError('target-shadowed', 'This message is no longer part of the active conversation.')
-    const markerEvent = appendEditorMarker(session, span, 'recall', seq, messageTextOf(session, seq))
+    const markerEvent = await appendEditorMarker(session, span, 'recall', seq, messageTextOf(session, seq), hooks.validateMarker)
     await flushSafely(session)
     return {
       op: 'recall',
@@ -309,7 +336,7 @@ export function createEditorApi(ctx, sessions, agents, log = () => {}) {
     if (startSeq === undefined) throw editorError('empty-surface', 'This session has no conversation to edit.')
     const span = shadowSpanFrom(session, startSeq)
     if (!span) throw editorError('target-shadowed', 'This message is no longer part of the active conversation.')
-    appendEditorMarker(session, span, 'edit', seq, originalText)
+    await appendEditorMarker(session, span, 'edit', seq, originalText, hooks.validateMarker)
     await flushSafely(session)
     const message = resendMessage(text.trim(), 'resend')
     agent.followup(message)
@@ -358,7 +385,7 @@ export function createEditorApi(ctx, sessions, agents, log = () => {}) {
     }
     const span = shadowSpanFrom(session, userSeq)
     if (!span) throw editorError('target-shadowed', 'This message is no longer part of the active conversation.')
-    appendEditorMarker(session, span, 'regenerate', userSeq, text)
+    await appendEditorMarker(session, span, 'regenerate', userSeq, text, hooks.validateMarker)
     await flushSafely(session)
     const message = resendMessage(text.trim(), 'resend')
     agent.followup(message)