typeclaw 0.20.0 → 0.21.0

package/src/dreams/index.ts

@@ -0,0 +1,134 @@
+import { readDreamCommitLog, readDreamCommitShow, resolveGitRepo, type SpawnGit } from './git'
+import { parseDreamDetail, parseDreamSubject } from './parse'
+import { renderDetail, renderListRow, type RenderOptions, toJsonShape } from './render'
+import type { DreamEntry } from './types'
+
+export type { SpawnGit } from './git'
+export type { DreamEntry } from './types'
+export { renderDetail, renderListRow, toJsonShape } from './render'
+export { parseDreamDetail, parseDreamSubject } from './parse'
+
+export type SelectDreamOptions = {
+  initialSha?: string
+}
+
+export type SelectDream = (entries: DreamEntry[], opts?: SelectDreamOptions) => Promise<DreamEntry | null>
+
+// 'back' re-opens the picker with the just-viewed dream pre-selected.
+export type ViewAction = 'back' | 'exit'
+export type ViewDream = () => Promise<ViewAction>
+
+export type RunDreamsOptions = {
+  agentDir: string
+  json: boolean
+  details: boolean
+  color: boolean
+  limit?: number
+  selectDream: SelectDream
+  viewDream?: ViewDream
+  stdout: (line: string) => void
+  spawnGit?: SpawnGit
+}
+
+export type RunDreamsResult = { ok: true; exitCode: 0 } | { ok: false; exitCode: number; reason: string }
+
+export async function listDreams(
+  agentDir: string,
+  opts: { limit?: number } = {},
+  spawnGit?: SpawnGit,
+): Promise<DreamEntry[]> {
+  const repo = await resolveGitRepo(agentDir, spawnGit)
+  if (!repo.ok) return []
+  const commits = await readDreamCommitLog(repo.root, opts.limit !== undefined ? { limit: opts.limit } : {}, spawnGit)
+  return commits.map((commit) => {
+    const subject = parseDreamSubject(commit.subject)
+    return {
+      sha: commit.sha,
+      shortSha: commit.shortSha,
+      subject: commit.subject,
+      committedAt: commit.committedAt,
+      isDreamCommit: subject.isDreamCommit,
+      summary: subject.summary,
+      emoji: subject.emoji,
+      categories: subject.categories,
+    }
+  })
+}
+
+export async function hydrateDream(agentDir: string, entry: DreamEntry, spawnGit?: SpawnGit): Promise<DreamEntry> {
+  const repo = await resolveGitRepo(agentDir, spawnGit)
+  if (!repo.ok) return entry
+  const show = await readDreamCommitShow(repo.root, entry.sha, spawnGit)
+  if (show === null) return entry
+  return { ...entry, detail: parseDreamDetail(show.nameStatus, show.patch) }
+}
+
+export async function runDreams(opts: RunDreamsOptions): Promise<RunDreamsResult> {
+  const repo = await resolveGitRepo(opts.agentDir, opts.spawnGit)
+  if (!repo.ok) {
+    if (repo.reason === 'not-a-repo') {
+      return {
+        ok: false,
+        exitCode: 1,
+        reason:
+          "Not a git repository. Dreams live in the agent folder's git history — run this from your agent folder.",
+      }
+    }
+    return { ok: false, exitCode: 1, reason: 'git failed while resolving the repository root.' }
+  }
+
+  const entries = await listDreams(opts.agentDir, opts.limit !== undefined ? { limit: opts.limit } : {}, opts.spawnGit)
+  const renderOpts: RenderOptions = { color: opts.color }
+
+  if (opts.json) return runJson(opts, repo.root, entries)
+
+  if (entries.length === 0) {
+    opts.stdout('No dreams yet. The dreaming subagent commits here after it consolidates memory.')
+    return { ok: true, exitCode: 0 }
+  }
+
+  if (!isInteractive()) {
+    for (const entry of entries) opts.stdout(renderListRow(entry, renderOpts))
+    return { ok: true, exitCode: 0 }
+  }
+
+  return runInteractiveLoop(opts, entries, renderOpts)
+}
+
+async function runInteractiveLoop(
+  opts: RunDreamsOptions,
+  entries: DreamEntry[],
+  renderOpts: RenderOptions,
+): Promise<RunDreamsResult> {
+  let initialSha: string | undefined
+  while (true) {
+    const picked = await opts.selectDream(entries, initialSha !== undefined ? { initialSha } : {})
+    if (picked === null) return { ok: true, exitCode: 0 }
+    initialSha = picked.sha
+
+    const hydrated = await hydrateDream(opts.agentDir, picked, opts.spawnGit)
+    opts.stdout(renderDetail(hydrated, renderOpts))
+
+    if (opts.viewDream === undefined) return { ok: true, exitCode: 0 }
+    const action = await opts.viewDream()
+    if (action === 'exit') return { ok: true, exitCode: 0 }
+  }
+}
+
+async function runJson(opts: RunDreamsOptions, root: string, entries: DreamEntry[]): Promise<RunDreamsResult> {
+  for (const entry of entries) {
+    const final = opts.details ? await hydrateEntryFromRoot(root, entry, opts.spawnGit) : entry
+    opts.stdout(JSON.stringify(toJsonShape(final)))
+  }
+  return { ok: true, exitCode: 0 }
+}
+
+async function hydrateEntryFromRoot(root: string, entry: DreamEntry, spawnGit?: SpawnGit): Promise<DreamEntry> {
+  const show = await readDreamCommitShow(root, entry.sha, spawnGit)
+  if (show === null) return entry
+  return { ...entry, detail: parseDreamDetail(show.nameStatus, show.patch) }
+}
+
+function isInteractive(): boolean {
+  return Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY)
+}

package/src/dreams/parse.ts

@@ -0,0 +1,224 @@
+import {
+  type DreamCategory,
+  type DreamEmoji,
+  DREAM_EMOJI_POOL,
+  type DreamEntryDetail,
+  type FragmentEventSummary,
+  type ShardChangeStatus,
+  type SkillCreation,
+  type TopicShardChange,
+} from './types'
+
+const BODY_PREVIEW_MAX = 80
+const EMOJI_SET = new Set<string>(DREAM_EMOJI_POOL)
+const STREAM_PATH = /^memory\/(?:streams\/)?(\d{4}-\d{2}-\d{2})\.jsonl$/
+const TOPIC_PATH = /^memory\/topics\/(.+)\.md$/
+const SKILL_PATH = /^memory\/skills\/([^/]+)\/SKILL\.md$/
+const STATE_PATH = 'memory/.dreaming-state.json'
+
+export type DreamSubject = {
+  isDreamCommit: boolean
+  summary: string | null
+  emoji: DreamEmoji | null
+  categories: DreamCategory[]
+}
+
+export function parseDreamSubject(subject: string): DreamSubject {
+  const match = /^dream:\s+(.*)$/.exec(subject)
+  if (match === null) {
+    return { isDreamCommit: false, summary: null, emoji: null, categories: [] }
+  }
+
+  const rest = (match[1] ?? '').trim()
+  const { summary, emoji } = splitTrailingEmoji(rest)
+  return {
+    isDreamCommit: true,
+    summary: summary.length > 0 ? summary : null,
+    emoji,
+    categories: classifySummary(summary),
+  }
+}
+
+function splitTrailingEmoji(rest: string): { summary: string; emoji: DreamEmoji | null } {
+  const chars = [...rest]
+  const last = chars.at(-1)
+  if (last !== undefined && EMOJI_SET.has(last)) {
+    return { summary: chars.slice(0, -1).join('').trim(), emoji: last as DreamEmoji }
+  }
+  return { summary: rest, emoji: null }
+}
+
+function classifySummary(summary: string): DreamCategory[] {
+  const categories: DreamCategory[] = []
+  if (/\bfragments?\b/.test(summary)) categories.push('fragments')
+  if (/\bskills?\b/.test(summary)) categories.push('skills')
+  if (/watermarks only/.test(summary)) categories.push('watermarks-only')
+  if (/^snapshot$/.test(summary)) categories.push('snapshot')
+  if (categories.length === 0) categories.push('other')
+  return categories
+}
+
+export function parseDreamDetail(nameStatus: string, patch: string): DreamEntryDetail {
+  const warnings: string[] = []
+  const changedTopics: TopicShardChange[] = []
+  const createdSkills: SkillCreation[] = []
+  let stateChanged = false
+
+  for (const { status, path, oldPath } of parseNameStatus(nameStatus)) {
+    if (path === STATE_PATH || oldPath === STATE_PATH) {
+      stateChanged = true
+      continue
+    }
+    const topic = TOPIC_PATH.exec(path)
+    if (topic !== null) {
+      changedTopics.push({ path, slug: topic[1] ?? path, status, additions: null, deletions: null })
+      continue
+    }
+    if (status === 'added') {
+      const skill = SKILL_PATH.exec(path)
+      if (skill !== null) createdSkills.push({ name: skill[1] ?? '', path })
+    }
+  }
+
+  applyTopicLineCounts(changedTopics, patch, warnings)
+  const addedFragments = extractAddedFragments(patch, warnings)
+
+  return { addedFragments, changedTopics, createdSkills, stateChanged, parseWarnings: warnings }
+}
+
+type NameStatusRow = { status: ShardChangeStatus; path: string; oldPath: string | null }
+
+function parseNameStatus(nameStatus: string): NameStatusRow[] {
+  const rows: NameStatusRow[] = []
+  for (const line of nameStatus.split('\n')) {
+    if (line.trim().length === 0) continue
+    const cols = line.split('\t')
+    const code = cols[0] ?? ''
+    if (code.startsWith('R')) {
+      const oldPath = cols[1] ?? ''
+      const newPath = cols[2] ?? ''
+      if (newPath.length > 0) rows.push({ status: 'renamed', path: newPath, oldPath })
+      continue
+    }
+    const path = cols[1] ?? ''
+    if (path.length === 0) continue
+    rows.push({ status: mapStatusCode(code), path, oldPath: null })
+  }
+  return rows
+}
+
+function mapStatusCode(code: string): ShardChangeStatus {
+  const c = code.charAt(0)
+  if (c === 'A') return 'added'
+  if (c === 'M') return 'modified'
+  if (c === 'D') return 'deleted'
+  if (c === 'R') return 'renamed'
+  return 'unknown'
+}
+
+type ParsedHunk = { path: string; addedLines: string[] }
+
+function* iterateHunks(patch: string): Generator<ParsedHunk> {
+  let currentPath: string | null = null
+  let added: string[] = []
+  const flush = function* (): Generator<ParsedHunk> {
+    if (currentPath !== null) yield { path: currentPath, addedLines: added }
+  }
+
+  for (const line of patch.split('\n')) {
+    if (line.startsWith('diff --git ')) {
+      yield* flush()
+      currentPath = null
+      added = []
+      continue
+    }
+    if (line.startsWith('+++ ')) {
+      currentPath = stripDiffPathPrefix(line.slice(4))
+      continue
+    }
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      added.push(line.slice(1))
+    }
+  }
+  yield* flush()
+}
+
+function stripDiffPathPrefix(raw: string): string {
+  const trimmed = raw.trim()
+  if (trimmed === '/dev/null') return trimmed
+  return trimmed.replace(/^b\//, '')
+}
+
+function extractAddedFragments(patch: string, warnings: string[]): FragmentEventSummary[] {
+  const out: FragmentEventSummary[] = []
+  for (const hunk of iterateHunks(patch)) {
+    const streamMatch = STREAM_PATH.exec(hunk.path)
+    if (streamMatch === null) continue
+    const streamDate = streamMatch[1] ?? null
+    for (const line of hunk.addedLines) {
+      if (line.trim().length === 0) continue
+      const fragment = parseFragmentLine(line, streamDate)
+      if (fragment === null) {
+        warnings.push(`unparseable stream line in ${hunk.path}`)
+        continue
+      }
+      if (fragment !== 'skip') out.push(fragment)
+    }
+  }
+  return out
+}
+
+function parseFragmentLine(line: string, streamDate: string | null): FragmentEventSummary | 'skip' | null {
+  let raw: unknown
+  try {
+    raw = JSON.parse(line)
+  } catch {
+    return null
+  }
+  if (typeof raw !== 'object' || raw === null) return null
+  const obj = raw as Record<string, unknown>
+  if (obj.type !== 'fragment') return 'skip'
+  if (typeof obj.id !== 'string' || obj.id.length === 0) return null
+  return {
+    id: obj.id,
+    streamDate,
+    topic: typeof obj.topic === 'string' ? obj.topic : null,
+    bodyPreview: typeof obj.body === 'string' ? preview(obj.body) : null,
+  }
+}
+
+function applyTopicLineCounts(topics: TopicShardChange[], patch: string, warnings: string[]): void {
+  if (topics.length === 0) return
+  const counts = new Map<string, { additions: number; deletions: number }>()
+  let currentPath: string | null = null
+
+  for (const line of patch.split('\n')) {
+    if (line.startsWith('+++ ')) {
+      currentPath = stripDiffPathPrefix(line.slice(4))
+      if (currentPath !== null && !counts.has(currentPath)) counts.set(currentPath, { additions: 0, deletions: 0 })
+      continue
+    }
+    if (currentPath === null) continue
+    const bucket = counts.get(currentPath)
+    if (bucket === undefined) continue
+    if (line.startsWith('+') && !line.startsWith('+++')) bucket.additions++
+    else if (line.startsWith('-') && !line.startsWith('---')) bucket.deletions++
+  }
+
+  for (const topic of topics) {
+    if (topic.status === 'deleted') continue
+    const bucket = counts.get(topic.path)
+    if (bucket === undefined) {
+      if (topic.status === 'modified') warnings.push(`no diff hunk for modified topic ${topic.path}`)
+      continue
+    }
+    topic.additions = bucket.additions
+    topic.deletions = bucket.deletions
+  }
+}
+
+function preview(body: string): string {
+  const oneline = body.replace(/\s+/g, ' ').trim()
+  if (oneline.length <= BODY_PREVIEW_MAX) return oneline
+  return `${oneline.slice(0, BODY_PREVIEW_MAX)}…`
+}

package/src/dreams/render.ts

@@ -0,0 +1,155 @@
+import { styleText } from 'node:util'
+
+import type { DreamCategory, DreamEntry, DreamEntryDetail } from './types'
+
+export type RenderOptions = { color: boolean }
+
+type ColorName = 'dim' | 'cyan' | 'green' | 'yellow' | 'magenta' | 'gray'
+
+function tint(opts: RenderOptions, color: ColorName, text: string): string {
+  if (!opts.color) return text
+  return styleText(color, text)
+}
+
+const CATEGORY_LABELS: Record<DreamCategory, string> = {
+  fragments: 'frag',
+  skills: 'skill',
+  'watermarks-only': 'watermarks',
+  snapshot: 'snapshot',
+  other: 'other',
+}
+
+export function renderListRow(entry: DreamEntry, opts: RenderOptions): string {
+  const emoji = entry.emoji ?? '·'
+  const sha = tint(opts, 'cyan', entry.shortSha)
+  const date = tint(opts, 'dim', formatShortDate(entry.committedAt))
+  const when = tint(opts, 'dim', `(${formatRelative(entry.committedAt)})`)
+  const summary = entry.summary ?? entry.subject
+  const badges = renderCategoryBadges(entry.categories, opts)
+  const head = `${emoji}  ${sha}  ${date} ${when}  ${summary}`
+  return badges.length > 0 ? `${head}  ${badges}` : head
+}
+
+function renderCategoryBadges(categories: DreamCategory[], opts: RenderOptions): string {
+  if (categories.length === 0) return ''
+  const meaningful = categories.filter((c) => c !== 'other')
+  const shown = meaningful.length > 0 ? meaningful : categories
+  const labels = shown.map((c) => CATEGORY_LABELS[c])
+  return tint(opts, 'magenta', labels.map((l) => `[${l}]`).join(' '))
+}
+
+export function renderDetail(entry: DreamEntry, opts: RenderOptions): string {
+  const lines: string[] = []
+  const emoji = entry.emoji ?? '·'
+  lines.push(`${emoji}  ${entry.subject}`)
+  lines.push(
+    tint(
+      opts,
+      'dim',
+      `${entry.shortSha} · ${formatTimestamp(entry.committedAt)} · ${formatRelative(entry.committedAt)}`,
+    ),
+  )
+
+  const detail = entry.detail
+  if (detail === undefined) {
+    lines.push('', tint(opts, 'dim', '(no detail loaded)'))
+    return lines.join('\n')
+  }
+
+  renderFragments(lines, detail, opts)
+  renderTopics(lines, detail, opts)
+  renderSkills(lines, detail, opts)
+
+  if (detail.stateChanged) lines.push('', tint(opts, 'dim', 'state: .dreaming-state.json advanced'))
+  for (const warning of detail.parseWarnings) lines.push(tint(opts, 'yellow', `⚠ ${warning}`))
+
+  if (isQuietDream(detail)) {
+    lines.push('', tint(opts, 'dim', 'No fragments promoted, no shards changed this run.'))
+  }
+  return lines.join('\n')
+}
+
+function renderFragments(lines: string[], detail: DreamEntryDetail, opts: RenderOptions): void {
+  if (detail.addedFragments.length === 0) return
+  lines.push('', section(opts, `fragments folded in (${detail.addedFragments.length})`))
+  for (const f of detail.addedFragments) {
+    const id = tint(opts, 'dim', `${f.streamDate ?? '????'}#${f.id}`)
+    const topic = f.topic !== null ? tint(opts, 'magenta', ` [${f.topic}]`) : ''
+    lines.push(`• ${id}${topic}`)
+    if (f.bodyPreview !== null) lines.push(`    ${tint(opts, 'gray', `"${f.bodyPreview}"`)}`)
+  }
+}
+
+function renderTopics(lines: string[], detail: DreamEntryDetail, opts: RenderOptions): void {
+  if (detail.changedTopics.length === 0) return
+  lines.push('', section(opts, `topic shards changed (${detail.changedTopics.length})`))
+  for (const t of detail.changedTopics) {
+    const counts =
+      t.additions !== null && t.deletions !== null ? tint(opts, 'dim', ` (+${t.additions} −${t.deletions})`) : ''
+    lines.push(`${statusGlyph(t.status, opts)} ${t.slug}${counts}`)
+  }
+}
+
+function renderSkills(lines: string[], detail: DreamEntryDetail, opts: RenderOptions): void {
+  if (detail.createdSkills.length === 0) return
+  lines.push('', section(opts, `skills distilled (${detail.createdSkills.length})`))
+  for (const s of detail.createdSkills)
+    lines.push(`${tint(opts, 'green', '✦')} ${s.name}  ${tint(opts, 'dim', s.path)}`)
+}
+
+export function toJsonShape(entry: DreamEntry): Record<string, unknown> {
+  const base: Record<string, unknown> = {
+    sha: entry.sha,
+    shortSha: entry.shortSha,
+    committedAt: entry.committedAt,
+    subject: entry.subject,
+    isDreamCommit: entry.isDreamCommit,
+    summary: entry.summary,
+    emoji: entry.emoji,
+    categories: entry.categories,
+  }
+  if (entry.detail !== undefined) base.detail = entry.detail
+  return base
+}
+
+function isQuietDream(detail: DreamEntryDetail): boolean {
+  return detail.addedFragments.length === 0 && detail.changedTopics.length === 0 && detail.createdSkills.length === 0
+}
+
+function section(opts: RenderOptions, label: string): string {
+  return tint(opts, 'dim', `── ${label} ──`)
+}
+
+function statusGlyph(status: string, opts: RenderOptions): string {
+  if (status === 'added') return tint(opts, 'green', '✚ added   ')
+  if (status === 'modified') return tint(opts, 'yellow', '✎ modified')
+  if (status === 'deleted') return tint(opts, 'dim', '✖ deleted ')
+  if (status === 'renamed') return tint(opts, 'cyan', '→ renamed ')
+  return '? unknown '
+}
+
+function formatRelative(iso: string): string {
+  const ms = Date.parse(iso)
+  if (Number.isNaN(ms)) return iso
+  const diff = Date.now() - ms
+  if (diff < 60_000) return 'just now'
+  if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}m ago`
+  if (diff < 86_400_000) return `${Math.floor(diff / 3_600_000)}h ago`
+  return `${Math.floor(diff / 86_400_000)}d ago`
+}
+
+function formatTimestamp(iso: string): string {
+  const ms = Date.parse(iso)
+  if (Number.isNaN(ms)) return iso
+  const d = new Date(ms)
+  const pad = (n: number): string => String(n).padStart(2, '0')
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`
+}
+
+function formatShortDate(iso: string): string {
+  const ms = Date.parse(iso)
+  if (Number.isNaN(ms)) return iso
+  const d = new Date(ms)
+  const pad = (n: number): string => String(n).padStart(2, '0')
+  return `${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`
+}

package/src/dreams/types.ts

@@ -0,0 +1,50 @@
+// Mirrored from the bundled memory plugin's dreaming subagent rather than
+// imported: this host-stage viewer must stay decoupled from runtime plugin
+// internals, and only needs to RECOGNIZE the emoji set, not own it. The
+// grammar test asserts this list stays in sync with the runtime's pool.
+export const DREAM_EMOJI_POOL = ['💤', '🌙', '⭐', '🛌', '😴', '🧠', '💭', '🔮'] as const
+export type DreamEmoji = (typeof DREAM_EMOJI_POOL)[number]
+
+export type DreamCategory = 'fragments' | 'skills' | 'watermarks-only' | 'snapshot' | 'other'
+
+export type DreamEntry = {
+  sha: string
+  shortSha: string
+  subject: string
+  committedAt: string
+  isDreamCommit: boolean
+  summary: string | null
+  emoji: DreamEmoji | null
+  categories: DreamCategory[]
+  detail?: DreamEntryDetail
+}
+
+export type DreamEntryDetail = {
+  addedFragments: FragmentEventSummary[]
+  changedTopics: TopicShardChange[]
+  createdSkills: SkillCreation[]
+  stateChanged: boolean
+  parseWarnings: string[]
+}
+
+export type FragmentEventSummary = {
+  id: string
+  streamDate: string | null
+  topic: string | null
+  bodyPreview: string | null
+}
+
+export type ShardChangeStatus = 'added' | 'modified' | 'deleted' | 'renamed' | 'unknown'
+
+export type TopicShardChange = {
+  path: string
+  slug: string
+  status: ShardChangeStatus
+  additions: number | null
+  deletions: number | null
+}
+
+export type SkillCreation = {
+  name: string
+  path: string
+}

package/src/server/index.ts

@@ -12,6 +12,7 @@ import { runPluginDoctorChecks, runPluginDoctorFix } from '@/agent/doctor'
 import type { LiveSessionRegistry } from '@/agent/live-sessions'
 import type { LiveSubagentRegistry } from '@/agent/live-subagents'
 import { detectProviderError } from '@/agent/provider-error'
+import { requestContainerRestart } from '@/agent/restart'
 import { consumeRestartHandoff, type RestartHandoff } from '@/agent/restart-handoff'
 import type { SessionOrigin } from '@/agent/session-origin'
 import { parseSubagentCompletedPayload, renderSubagentCompletionReminder } from '@/agent/subagent-completion-reminder'
@@ -652,6 +653,11 @@ export function createServer({
             return
           }
 
+          if (msg.type === 'restart') {
+            await handleRestart(ws, state, containerName, agentDir, stream)
+            return
+          }
+
           if (msg.type === 'doctor') {
             await handleDoctor(ws, msg.requestId, pluginRuntime, agentDir)
             return
@@ -1437,3 +1443,46 @@ async function handleReload(
     })
   }
 }
+
+async function handleRestart(
+  ws: Ws,
+  state: SessionState | undefined,
+  containerName: string | undefined,
+  agentDir: string | undefined,
+  stream: Stream | undefined,
+): Promise<void> {
+  if (containerName === undefined) {
+    send(ws, {
+      type: 'restart_result',
+      status: 'failed',
+      error: 'restart unavailable: no container name configured',
+    })
+    return
+  }
+
+  // Pass stream so requestContainerRestart fans out the container-restarting
+  // notice — the originating session's subscribeRestartNotice appends the
+  // typeclaw.restart-self entry to its JSONL before the handoff is written, so
+  // the rebooted container resumes with the "I'm back" instruction (same path
+  // the agent restart tool uses).
+  const originatingSessionFile = state?.sessionManager?.getSessionFile()
+  const result = await requestContainerRestart({
+    containerName,
+    ...(agentDir !== undefined ? { agentDir } : {}),
+    ...(state?.sessionFileId !== undefined ? { originatingSessionId: state.sessionFileId } : {}),
+    ...(originatingSessionFile !== undefined ? { originatingSessionFile } : {}),
+    ...(stream !== undefined ? { stream } : {}),
+  })
+  if (!result.ok) {
+    send(ws, { type: 'restart_result', status: 'failed', error: result.reason })
+    return
+  }
+
+  // hostd's supervisor ACKs first, then runs stop+start in the background;
+  // this process should not self-exit or it could race the daemon-owned stop.
+  send(ws, {
+    type: 'restart_result',
+    status: 'accepted',
+    message: 'restart scheduled; reconnecting when the new container is up',
+  })
+}

package/src/shared/protocol.ts

@@ -130,6 +130,7 @@ export type InspectServerMessage =
 export type ClientMessage =
   | { type: 'prompt'; text: string; delivery?: PromptDelivery }
   | { type: 'reload'; scope?: string }
+  | { type: 'restart' }
   | { type: 'abort' }
   | { type: 'queue_cancel'; messageId: string }
   | { type: 'doctor'; requestId: DoctorRequestId }
@@ -213,6 +214,7 @@ export type ServerMessage =
   | { type: 'done' }
   | { type: 'error'; message: string }
   | { type: 'reload_result'; results: ReloadResultPayload[] }
+  | { type: 'restart_result'; status: 'accepted' | 'failed'; message?: string; error?: string }
   | { type: 'notification'; payload: unknown; replyTo?: string; meta?: Record<string, string> }
   | { type: 'queue_state'; pending: QueueStateItem[] }
   | { type: 'prompt_started'; messageId: string; text: string }

package/src/skills/typeclaw-channel-github/SKILL.md

@@ -118,15 +118,9 @@ The `reviewer` subagent is the analyst; you are the integration layer between it
 
    The returned `id`/`state` is your proof the formal review posted. If the call errored or the review is absent, do **not** fall back to a top-level `channel_reply` that _claims_ a review was posted — fix the payload (most often a `line` that isn't part of the diff; re-anchor it or move that finding to the top-level `body`) and resubmit. A trace reply that says "Posted review" when no review exists is worse than silence.
 
-6. **Drop the decoy reviewer — App auth only, request-path only.** When this review was triggered by an explicit review-request inbound (path A) **and** you are running under **GitHub App** auth, remove the decoy reviewer from the PR's requested-reviewers list once the review has landed (after step 5 confirms it). Why: GitHub auto-adds **you** (the App account) to the PR's reviewers the moment your formal review posts, so the "reviewed" state is already recorded under the App identity — but the **decoy** account stays pinned in the requested-reviewers list as a perpetual "review requested", as if the review never happened. Removing it is the natural "I'm done, drop me" cleanup a human reviewer gets for free. The decoy login is the App slug — `selfLogin` with the trailing `[bot]` removed (`my-app[bot]` → `my-app`); see [GitHub decoy reviewer](/docs/internals/github-decoy-reviewer).
+6. **The decoy reviewer is dropped for you — no action needed.** Under **GitHub App** auth, the adapter automatically removes the decoy reviewer from the PR's requested-reviewers list the moment your formal review lands (it reacts to your own `pull_request_review.submitted` webhook). Why this matters: GitHub auto-adds **you** (the App account) to the PR's reviewers when your review posts, but the **decoy** account would otherwise stay pinned as a perpetual "review requested", as if the review never happened. You do **not** need to issue a `DELETE /requested_reviewers` yourself — and you should not, since it would race the adapter's own cleanup. The removal is self-loop-safe: the adapter's `DELETE` is authenticated as the App, so the `review_request_removed` webhook carries your bot actor (`slug[bot]`) as `sender`, which the classifier drops (see "Self-loop safety" below). This is a no-op under **PAT** auth (no decoy) and for **plain-language**/**team** requests (no decoy user was placed). See [GitHub decoy reviewer](/docs/internals/github-decoy-reviewer).
 
-   ```sh
-   gh api -X DELETE /repos/owner/repo/pulls/<N>/requested_reviewers -f 'reviewers[]=<decoy-login>'
-   ```
-
-   **Skip this entirely** when (a) you are under **PAT** auth — there is no decoy; the bot is a real user GitHub keeps listed as a reviewer, and removing yourself there is not wanted — or (b) the review came from a **plain-language** ask (path B) or a **team** request, where no decoy user was ever placed on the requested-reviewers list and the DELETE would be a no-op/404. The removal is safe under the adapter's self-loop guard: you make the `DELETE` authenticated as the App, so the `review_request_removed` webhook GitHub emits has your bot actor (`slug[bot]`) as `sender`, which the classifier drops, so it never wakes a fresh session (see "Self-loop safety" below). Treat a failure here as non-fatal — the review already landed; do not retry in a loop or surface it to the PR thread.
-
-7. **End the turn with `skip_response`, not a trace reply.** The formal review from step 4 already landed _in this PR_ — it carries the summary, the verdict, and the inline comments. A `channel_reply` here does **not** go to a separate operator channel; on GitHub it posts another public comment on the same PR. A one-line "Posted review on PR #N: …" narrated into the PR thread is meta-commentary addressed to a phantom operator, and it reads absurdly next to the review it claims to point at. So once step 5 confirms the review exists (and step 6 has dropped the decoy, if applicable), call `skip_response({ reason: "review posted via gh api" })` to close the turn silently. Only fall back to `channel_reply` when there was **no** formal review to post — the zero-actionable-findings branch below uses `channel_reply`/issue comments _as_ the substantive reply.
+7. **End the turn with `skip_response`, not a trace reply.** The formal review from step 4 already landed _in this PR_ — it carries the summary, the verdict, and the inline comments. A `channel_reply` here does **not** go to a separate operator channel; on GitHub it posts another public comment on the same PR. A one-line "Posted review on PR #N: …" narrated into the PR thread is meta-commentary addressed to a phantom operator, and it reads absurdly next to the review it claims to point at. So once step 5 confirms the review exists, call `skip_response({ reason: "review posted via gh api" })` to close the turn silently. Only fall back to `channel_reply` when there was **no** formal review to post — the zero-actionable-findings branch below uses `channel_reply`/issue comments _as_ the substantive reply.
 
 ### Zero actionable findings
 
@@ -156,4 +150,4 @@ For App auth, `GH_TOKEN` is an installation access token that refreshes automati
 
 The adapter will **not** wake you when you assign yourself as a reviewer (e.g., via `gh pr edit --add-reviewer`). It will only wake you when someone else requests your review.
 
-The same guard covers **removing** a reviewer: when you drop the decoy after a review (step 6 of the PR review flow), you act as the App, so the `review_request_removed` webhook GitHub emits carries your bot actor (`slug[bot]`) as its `sender`, which the classifier drops. So the cleanup never echoes back as a fresh wake. Both directions — add and remove — are matched on `sender.login` (against either the bot actor or its decoy), so any reviewer-list mutation you make yourself stays silent.
+The same guard covers **removing** a reviewer: when the adapter drops the decoy after your review lands (step 6 of the PR review flow), the `DELETE` is authenticated as the App, so the `review_request_removed` webhook GitHub emits carries your bot actor (`slug[bot]`) as its `sender`, which the classifier drops. So the cleanup never echoes back as a fresh wake. Both directions — add and remove — are matched on `sender.login` (against either the bot actor or its decoy), so any reviewer-list mutation made under your identity stays silent.