ethagent 3.3.4 → 4.0.0

package/src/tools/listSkillFilesTool.ts

@@ -1,77 +0,0 @@
-import { z } from 'zod'
-import path from 'node:path'
-import {
-  continuityVaultRef,
-} from '../identity/continuity/storage.js'
-import { listSkillFiles } from '../identity/continuity/skills/loadSkills.js'
-import type { Tool } from './contracts.js'
-
-const schema = z.object({
-  name: z.string().min(1),
-})
-
-export const listSkillFilesTool: Tool<typeof schema> = {
-  name: 'list_private_skill_files',
-  kind: 'private-continuity-read',
-  readOnly: true,
-  description: [
-    'List every file inside a private skill folder for the active identity.',
-    'Returns each file as `- <relativePath> (<bytes>) — <absolutePath>`, including SKILL.md and any supporting files (references, examples, scripts).',
-    'Use this after list_private_skills shows a skill with `(+N supporting files)` to discover what is available, then call read_private_skill with `file` to load text content.',
-    'Pass the absolute path directly to run_bash to execute supporting scripts (e.g. `python "<absolutePath>" <args>`).',
-  ].join(' '),
-  inputSchema: schema,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {
-      name: { type: 'string', description: 'Skill folder name from the private skills index.' },
-    },
-    required: ['name'],
-    additionalProperties: false,
-  },
-  parse(input) {
-    return schema.parse(input)
-  },
-  async buildPermissionRequest(input, context) {
-    const identity = context.config?.identity
-    if (!identity) throw new Error('No active identity; create or load an identity before listing private skill files')
-    const ref = continuityVaultRef(identity)
-    const folder = input.name.replace(/^.*:/, '')
-    const skillDir = path.join(ref.skillsDir, folder)
-    return {
-      kind: 'private-skill-read',
-      path: skillDir,
-      relativePath: `identity-vault/skills/${folder}`,
-      directoryPath: skillDir,
-      title: 'Allow private skill folder list?',
-      subtitle: `List files in ${folder}/`,
-      skillName: input.name,
-      mode: 'list',
-    }
-  },
-  async execute(input, context) {
-    const identity = context.config?.identity
-    if (!identity) {
-      return { ok: false, summary: 'no active identity', content: 'No active identity; cannot list private skill files.' }
-    }
-    try {
-      const folder = input.name.replace(/^.*:/, '')
-      const files = await listSkillFiles(identity, folder)
-      if (files.length === 0) {
-        return { ok: true, summary: `no files in ${folder}`, content: `Skill folder ${folder}/ is empty or does not exist.` }
-      }
-      const lines = files.map(f => `- ${f.relativePath} (${f.sizeBytes} bytes) — ${f.absolutePath}`)
-      return {
-        ok: true,
-        summary: `listed ${files.length} file${files.length === 1 ? '' : 's'} in ${folder}`,
-        content: lines.join('\n'),
-      }
-    } catch (err: unknown) {
-      return {
-        ok: false,
-        summary: 'list failed',
-        content: (err as Error).message,
-      }
-    }
-  },
-}

package/src/tools/listSkillsTool.ts

@@ -1,68 +0,0 @@
-import { z } from 'zod'
-import {
-  continuityVaultRef,
-} from '../identity/continuity/storage.js'
-import { listSkillsTree } from '../identity/continuity/skills/loadSkills.js'
-import type { Tool } from './contracts.js'
-
-const schema = z.object({})
-
-export const listSkillsTool: Tool<typeof schema> = {
-  name: 'list_private_skills',
-  kind: 'private-continuity-read',
-  readOnly: true,
-  description: [
-    'List private skills available in the owner-authored skills tree for the active identity.',
-    'Returns each skill folder name with its one-line description; bodies are loaded separately via read_private_skill.',
-    'When a skill has supporting files beyond SKILL.md, the entry is annotated with (+N supporting files) so you know to call list_private_skill_files.',
-    'Use this when the user mentions a skill not in the injected skill index, or to discover what skills exist.',
-  ].join(' '),
-  inputSchema: schema,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {},
-    additionalProperties: false,
-  },
-  parse(input) {
-    return schema.parse(input ?? {})
-  },
-  async buildPermissionRequest(_input, context) {
-    const identity = context.config?.identity
-    if (!identity) throw new Error('No active identity; create or load an identity before listing private skills')
-    const ref = continuityVaultRef(identity)
-    return {
-      kind: 'private-skill-read',
-      path: ref.skillsDir,
-      relativePath: 'identity-vault/skills',
-      directoryPath: ref.skillsDir,
-      title: 'Allow private skills index read?',
-      subtitle: 'List skill names and descriptions from the private skills tree',
-      skillName: '*',
-      mode: 'list',
-    }
-  },
-  async execute(_input, context) {
-    const identity = context.config?.identity
-    if (!identity) {
-      return { ok: false, summary: 'no active identity', content: 'No active identity; cannot list private skills.' }
-    }
-    const { skills, supportingCounts } = await listSkillsTree(identity)
-    if (skills.length === 0) {
-      return { ok: true, summary: 'no private skills', content: 'The private skills tree is empty.' }
-    }
-    const lines = skills.map(entry => {
-      const display = entry.displayName ?? entry.name
-      const desc = entry.description ? ` — ${entry.description}` : ''
-      const when = entry.whenToUse ? ` (when: ${entry.whenToUse})` : ''
-      const vis = entry.visibility !== 'private' ? ` [visibility: ${entry.visibility}]` : ''
-      const supporting = supportingCounts[entry.name] ?? 0
-      const trailer = supporting > 0 ? ` (+${supporting} supporting file${supporting === 1 ? '' : 's'})` : ''
-      return `- ${display}${desc}${when}${vis}${trailer}`
-    })
-    return {
-      ok: true,
-      summary: `listed ${skills.length} private skill${skills.length === 1 ? '' : 's'}`,
-      content: lines.join('\n'),
-    }
-  },
-}

package/src/tools/mcpResourceTools.ts

@@ -1,95 +0,0 @@
-import { z } from 'zod'
-import type { Tool } from './contracts.js'
-import { normalizeNameForMcp } from '../mcp/names.js'
-
-const ListMcpResourcesInput = z.object({
-  server: z.string().min(1).optional(),
-})
-
-const ReadMcpResourceInput = z.object({
-  server: z.string().min(1),
-  uri: z.string().min(1),
-})
-
-export const listMcpResourcesTool: Tool<typeof ListMcpResourcesInput> = {
-  name: 'list_mcp_resources',
-  kind: 'mcp',
-  readOnly: true,
-  description: 'List resources exposed by connected MCP servers.',
-  inputSchema: ListMcpResourcesInput,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {
-      server: { type: 'string', description: 'Optional MCP server name. Omit to list resources from every connected server.' },
-    },
-  },
-  parse(input) {
-    return ListMcpResourcesInput.parse(input)
-  },
-  async buildPermissionRequest(input) {
-    const serverName = input.server ?? '*'
-    return {
-      kind: 'mcp',
-      title: 'Allow MCP resource listing?',
-      subtitle: input.server ? `list resources from ${input.server}` : 'list resources from all connected MCP servers',
-      serverName,
-      normalizedServerName: normalizeNameForMcp(serverName),
-      toolName: 'list_mcp_resources',
-      toolKey: 'list_mcp_resources',
-      readOnly: true,
-      destructive: false,
-      openWorld: false,
-      canPersistServer: Boolean(input.server),
-    }
-  },
-  async execute(input, context) {
-    if (!context.mcp) return { ok: false, summary: 'MCP unavailable', content: 'MCP runtime is not available.' }
-    return {
-      ok: true,
-      summary: input.server ? `listed MCP resources from ${input.server}` : 'listed MCP resources',
-      content: await context.mcp.listResources(input.server),
-    }
-  },
-}
-
-export const readMcpResourceTool: Tool<typeof ReadMcpResourceInput> = {
-  name: 'read_mcp_resource',
-  kind: 'mcp',
-  readOnly: true,
-  description: 'Read a specific resource from a connected MCP server.',
-  inputSchema: ReadMcpResourceInput,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {
-      server: { type: 'string', description: 'The connected MCP server name.' },
-      uri: { type: 'string', description: 'The resource URI to read.' },
-    },
-    required: ['server', 'uri'],
-  },
-  parse(input) {
-    return ReadMcpResourceInput.parse(input)
-  },
-  async buildPermissionRequest(input) {
-    return {
-      kind: 'mcp',
-      title: 'Allow MCP resource read?',
-      subtitle: `${input.server} / ${input.uri}`,
-      serverName: input.server,
-      normalizedServerName: normalizeNameForMcp(input.server),
-      toolName: 'read_mcp_resource',
-      toolKey: `read_mcp_resource:${normalizeNameForMcp(input.server)}`,
-      readOnly: true,
-      destructive: false,
-      openWorld: false,
-      canPersistServer: true,
-    }
-  },
-  async execute(input, context) {
-    if (!context.mcp) return { ok: false, summary: 'MCP unavailable', content: 'MCP runtime is not available.' }
-    return {
-      ok: true,
-      summary: `read MCP resource ${input.uri}`,
-      content: await context.mcp.readResource(input.server, input.uri, context.abortSignal),
-    }
-  },
-}

package/src/tools/permissionRules.ts

@@ -1,85 +0,0 @@
-import path from 'node:path'
-import type { PermissionDecision, PermissionRequest, SessionPermissionRule } from './contracts.js'
-
-export function buildPermissionRule(
-  decision: PermissionDecision,
-  request: PermissionRequest,
-): SessionPermissionRule | undefined {
-  switch (decision) {
-    case 'allow-kind-project':
-      if (request.kind === 'read' || request.kind === 'edit' || request.kind === 'write' || request.kind === 'cd') return { kind: request.kind, scope: 'kind' }
-      return undefined
-    case 'allow-path-project':
-      if (request.kind === 'read' || request.kind === 'edit' || request.kind === 'write' || request.kind === 'cd') {
-        return { kind: request.kind, scope: 'path', path: request.path }
-      }
-      return undefined
-    case 'allow-directory-project':
-      if (request.kind === 'read' || request.kind === 'edit' || request.kind === 'write' || request.kind === 'cd') {
-        return { kind: request.kind, scope: 'directory', path: request.directoryPath }
-      }
-      return undefined
-    case 'allow-command-project':
-      if (request.kind === 'bash' && request.canPersistExact) {
-        return { kind: 'bash', scope: 'command', command: request.command, cwd: request.cwd }
-      }
-      return undefined
-    case 'allow-command-prefix-project':
-      if (request.kind === 'bash' && request.canPersistPrefix && request.commandPrefix) {
-        return { kind: 'bash', scope: 'prefix', commandPrefix: request.commandPrefix, cwd: request.cwd }
-      }
-      return undefined
-    case 'allow-mcp-tool-project':
-      if (request.kind === 'mcp') return { kind: 'mcp', scope: 'tool', toolKey: request.toolKey }
-      return undefined
-    case 'allow-mcp-server-project':
-      if (request.kind === 'mcp' && request.canPersistServer) {
-        return { kind: 'mcp', scope: 'server', normalizedServerName: request.normalizedServerName }
-      }
-      return undefined
-    default:
-      return undefined
-  }
-}
-
-export function matchPermissionRule(
-  rules: SessionPermissionRule[],
-  request: PermissionRequest,
-): SessionPermissionRule | undefined {
-  return rules.find(rule => matchesPermissionRule(rule, request))
-}
-
-export function shouldPersistPermissionDecision(decision: PermissionDecision): boolean {
-  return decision !== 'allow-once' && decision !== 'deny'
-}
-
-function matchesPermissionRule(rule: SessionPermissionRule, request: PermissionRequest): boolean {
-  if (rule.kind !== request.kind) return false
-
-  if (request.kind === 'read' || request.kind === 'edit' || request.kind === 'write' || request.kind === 'delete' || request.kind === 'cd') {
-    if (request.kind === 'delete') return false
-    if (rule.scope === 'kind') return true
-    if (rule.scope === 'path') return rule.path === request.path
-    if (rule.scope === 'directory') {
-      return request.path === rule.path || request.path.startsWith(`${rule.path}${path.sep}`)
-    }
-    return false
-  }
-
-  if (request.kind === 'bash') {
-    if (rule.scope === 'command') return rule.command === request.command && rule.cwd === request.cwd
-    if (rule.scope === 'prefix') {
-      const normalizedCommand = request.command.trim()
-      return (
-        rule.cwd === request.cwd &&
-        (normalizedCommand === rule.commandPrefix || normalizedCommand.startsWith(`${rule.commandPrefix} `))
-      )
-    }
-  }
-
-  if (request.kind === 'mcp') {
-    if (rule.scope === 'tool') return rule.toolKey === request.toolKey
-    if (rule.scope === 'server') return rule.normalizedServerName === request.normalizedServerName
-  }
-  return false
-}

package/src/tools/privateContinuityEditTool.ts

@@ -1,187 +0,0 @@
-import { z } from 'zod'
-import {
-  preparePrivateContinuityEdit,
-  writePreparedPrivateContinuityEdit,
-} from '../identity/continuity/privateEdit.js'
-import { recordPrivateContinuityHistorySnapshot } from '../identity/continuity/history.js'
-import { readContinuityFiles, readAgentCardFile } from '../identity/continuity/storage.js'
-import type { Tool } from './contracts.js'
-import { formatFileChangeResult } from './fileDiff.js'
-
-const schema = z.object({
-  file: z.preprocess(normalizePrivateContinuityFile, z.enum(['SOUL.md', 'MEMORY.md'])),
-  oldText: z.string().optional(),
-  newText: z.string().optional(),
-  appendToSection: z.string().optional(),
-  appendText: z.string().optional(),
-  replaceAll: z.boolean().optional(),
-  replaceWholeFile: z.boolean().optional(),
-}).superRefine((input, ctx) => {
-  const hasOldText = input.oldText !== undefined
-  const hasNewText = input.newText !== undefined
-  const hasAppendToSection = input.appendToSection !== undefined
-  const hasAppendText = input.appendText !== undefined
-  const targeted = hasOldText || hasNewText
-  const append = hasAppendToSection || hasAppendText
-  if (input.replaceWholeFile) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: 'private continuity files must be edited in place; whole-file replacement is disabled',
-      path: ['replaceWholeFile'],
-    })
-  }
-  if (!targeted && !append) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: 'file alone is not enough; provide either oldText+newText for a targeted edit or appendToSection+appendText for an in-place append',
-    })
-  }
-  if (targeted && append) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: 'provide only one edit mode: oldText+newText or appendToSection+appendText',
-    })
-  }
-  if (targeted && !input.oldText?.trim()) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: 'oldText is required for targeted private continuity edits',
-      path: ['oldText'],
-    })
-  }
-  if (targeted && !hasNewText) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: 'newText is required for targeted private continuity edits',
-      path: ['newText'],
-    })
-  }
-  if (append && !input.appendToSection?.trim()) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: 'appendToSection is required for private continuity appends',
-      path: ['appendToSection'],
-    })
-  }
-  if (append && !input.appendText?.trim()) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: 'appendText is required for private continuity appends',
-      path: ['appendText'],
-    })
-  }
-})
-
-export const privateContinuityEditTool: Tool<typeof schema> = {
-  name: 'propose_private_continuity_edit',
-  kind: 'private-continuity-edit',
-  description: [
-    'Propose an explicit user-approved in-place edit to an existing private identity continuity scaffold.',
-    'Only the identity-vault SOUL.md and MEMORY.md are valid targets; do not create workspace files with these names.',
-    'Do not call read_file, list_directory, or run_bash to locate these files; pass file as SOUL.md or MEMORY.md and this tool resolves the vault path.',
-    'For new memories or preferences call exactly: {"file":"MEMORY.md","appendToSection":"Durable User Preferences","appendText":"- User preference or memory note."}.',
-    'For persona or standing behavior call exactly: {"file":"SOUL.md","appendToSection":"Persona","appendText":"- Persona or standing behavior note."}.',
-    'Prefer appendToSection+appendText to build on an existing scaffold section; use oldText+newText only for targeted replacement after exact text is known.',
-    'Whole-file replacement is disabled for private continuity.',
-    'Approved private continuity edits are not managed by /rewind.',
-  ].join(' '),
-  inputSchema: schema,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {
-      file: { type: 'string', enum: ['SOUL.md', 'MEMORY.md'], description: 'Private continuity file to edit. Use only the file name; do not pass a workspace path.' },
-      oldText: { type: 'string', description: 'Exact existing scaffold text to replace. Required for targeted replacement edits.' },
-      newText: { type: 'string', description: 'Replacement text for oldText. Do not use this as whole-file content.' },
-      appendToSection: { type: 'string', description: 'Existing markdown section heading to append under, for example "Durable User Preferences" or "Persona". Prefer this for new notes.' },
-      appendText: { type: 'string', description: 'New non-empty markdown bullet to append under appendToSection. This builds on the existing scaffold instead of overwriting it.' },
-      replaceAll: { type: 'boolean', description: 'Replace every exact oldText match. Prefer false unless certain.' },
-    },
-    required: ['file'],
-    additionalProperties: false,
-  },
-  parse(input) {
-    return schema.parse(normalizePrivateContinuityInput(input))
-  },
-  async buildPermissionRequest(input, context) {
-    const prepared = await preparePrivateContinuityEdit(input, context.config)
-    return {
-      kind: 'private-continuity-edit',
-      path: prepared.fullPath,
-      relativePath: prepared.relativePath,
-      directoryPath: prepared.directoryPath,
-      title: 'Approve Private Continuity Edit?',
-      subtitle: prepared.fullPath,
-      file: prepared.file,
-      before: prepared.previewBefore,
-      after: prepared.previewAfter,
-      diff: prepared.diff,
-      changeSummary: prepared.changeSummary,
-    }
-  },
-  async execute(input, context) {
-    const prepared = await preparePrivateContinuityEdit(input, context.config)
-    const [previousFiles, previousAgentCard] = await Promise.all([
-      readContinuityFiles(prepared.identity),
-      readAgentCardFile(prepared.identity),
-    ])
-    await recordPrivateContinuityHistorySnapshot({
-      identity: prepared.identity,
-      file: prepared.file,
-      filePath: prepared.fullPath,
-      existedBefore: prepared.existedBefore,
-      previousContent: prepared.previousContent,
-      previousFiles,
-      previousAgentCard,
-      changeSummary: prepared.changeSummary,
-      sessionId: context.checkpoint?.sessionId,
-      turnId: context.checkpoint?.turnId,
-      promptSnippet: context.checkpoint?.promptSnippet,
-      checkpointLabel: context.checkpoint?.checkpointLabel,
-    })
-    await writePreparedPrivateContinuityEdit(prepared)
-    return {
-      ok: true,
-      summary: prepared.changeSummary,
-      content: formatFileChangeResult(
-        formatPrivateContinuityEditResult(prepared.file, prepared.fullPath),
-        prepared.diff,
-      ),
-    }
-  },
-}
-
-function formatPrivateContinuityEditResult(file: 'SOUL.md' | 'MEMORY.md', fullPath: string): string {
-  return [
-    '## Saved private continuity',
-    '',
-    `- File: \`identity-vault/${file}\``,
-    `- Review file: \`${fullPath}\``,
-    '- History: previous version saved to private identity history; `/rewind` does not restore identity continuity',
-    '- Open: Identity Hub > Soul, Memory, and Skills',
-    '- Save: Identity Hub > Recovery > Save Snapshot Now',
-  ].join('\n')
-}
-
-function normalizePrivateContinuityInput(input: Record<string, unknown>): Record<string, unknown> {
-  const normalized = { ...input }
-  if (normalized.appendToSection === undefined) {
-    normalized.appendToSection = normalized.section ?? normalized.heading
-  }
-  if (normalized.appendText === undefined) {
-    normalized.appendText = normalized.note ?? normalized.text ?? normalized.content
-  }
-  for (const key of ['oldText', 'newText', 'appendToSection', 'appendText'] as const) {
-    const value = normalized[key]
-    if (typeof value === 'string' && value.trim() === '') {
-      normalized[key] = undefined
-    }
-  }
-  return normalized
-}
-
-function normalizePrivateContinuityFile(value: unknown): unknown {
-  if (typeof value !== 'string') return value
-  if (/^soul\.md$/i.test(value.trim())) return 'SOUL.md'
-  if (/^memory\.md$/i.test(value.trim())) return 'MEMORY.md'
-  return value
-}

package/src/tools/privateContinuityReadTool.ts

@@ -1,106 +0,0 @@
-import path from 'node:path'
-import { z } from 'zod'
-import {
-  continuityVaultRef,
-  ensureContinuityFiles,
-} from '../identity/continuity/storage.js'
-import type { Tool } from './contracts.js'
-
-const schema = z.object({
-  file: z.preprocess(normalizePrivateContinuityFile, z.enum(['SOUL.md', 'MEMORY.md'])),
-  startLine: z.number().int().positive().optional(),
-  endLine: z.number().int().positive().optional(),
-})
-
-export const privateContinuityReadTool: Tool<typeof schema> = {
-  name: 'read_private_continuity_file',
-  kind: 'private-continuity-read',
-  description: [
-    'Read an explicitly user-approved private identity continuity file from the identity vault.',
-    'Only SOUL.md and MEMORY.md are valid targets; do not use workspace read_file for these files.',
-    'Use this before surgical removals or targeted replacements that need exact oldText.',
-    'Pass file as SOUL.md or MEMORY.md; this tool resolves the vault path.',
-    'Use startLine and endLine to limit the returned range when possible.',
-  ].join(' '),
-  inputSchema: schema,
-  inputSchemaJson: {
-    type: 'object',
-    properties: {
-      file: { type: 'string', enum: ['SOUL.md', 'MEMORY.md'], description: 'Private continuity file to read. Use only the file name; do not pass a workspace path.' },
-      startLine: { type: 'number', description: 'Optional 1-based starting line.' },
-      endLine: { type: 'number', description: 'Optional 1-based ending line.' },
-    },
-    required: ['file'],
-    additionalProperties: false,
-  },
-  parse(input) {
-    return schema.parse(normalizePrivateContinuityReadInput(input))
-  },
-  async buildPermissionRequest(input, context) {
-    const prepared = preparePrivateContinuityRead(input, context.config)
-    return {
-      kind: 'private-continuity-read',
-      path: prepared.fullPath,
-      relativePath: prepared.relativePath,
-      directoryPath: prepared.directoryPath,
-      title: 'Allow private continuity read?',
-      subtitle: input.startLine || input.endLine
-        ? `${prepared.fullPath} · lines ${input.startLine ?? 1}-${input.endLine ?? 'end'}`
-        : prepared.fullPath,
-      file: input.file,
-      range: input.startLine || input.endLine
-        ? `lines ${input.startLine ?? 1}-${input.endLine ?? 'end'}`
-        : 'entire file',
-    }
-  },
-  async execute(input, context) {
-    const prepared = preparePrivateContinuityRead(input, context.config)
-    const files = await ensureContinuityFiles(prepared.identity)
-    return {
-      ok: true,
-      summary: `read private ${input.file}`,
-      content: numberedLineSlice(files[input.file], input.startLine, input.endLine),
-    }
-  },
-}
-
-function preparePrivateContinuityRead(
-  input: z.infer<typeof schema>,
-  config: Parameters<Tool['buildPermissionRequest']>[1]['config'],
-) {
-  const identity = config?.identity
-  if (!identity) {
-    throw new Error('No active identity; create or load an identity before reading private continuity files')
-  }
-  const ref = continuityVaultRef(identity)
-  const fullPath = input.file === 'SOUL.md' ? ref.soulPath : ref.memoryPath
-  return {
-    identity,
-    fullPath,
-    relativePath: `identity-vault/${input.file}`,
-    directoryPath: path.dirname(fullPath),
-  }
-}
-
-function numberedLineSlice(content: string, startLine?: number, endLine?: number): string {
-  const lines = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n')
-  const start = Math.max(1, startLine ?? 1)
-  const end = Math.max(start, endLine ?? lines.length)
-  return lines.slice(start - 1, end).map((line, index) => `${start + index}: ${line}`).join('\n')
-}
-
-function normalizePrivateContinuityReadInput(input: Record<string, unknown>): Record<string, unknown> {
-  const normalized = { ...input }
-  if (normalized.file === undefined) {
-    normalized.file = normalized.path ?? normalized.name
-  }
-  return normalized
-}
-
-function normalizePrivateContinuityFile(value: unknown): unknown {
-  if (typeof value !== 'string') return value
-  const basename = path.basename(value.replaceAll('\\', '/')).trim()
-  if (/^soul\.md$/i.test(basename)) return 'SOUL.md'
-  if (/^memory\.md$/i.test(basename)) return 'MEMORY.md'
-  return value
-}