Function handle

src/tools/remember.ts:69–157

(
  args: Record<string, unknown>,
  ctx: ToolContext
)

};

export async function handle(
  args: Record<string, unknown>,
  ctx: ToolContext
): Promise<ToolResponse> {
  const args_typed = args as {
    type?: MemoryType;
    category: MemoryCategory;
    memory: string;
    reason: string;
    scope?: MemoryScope;
  };

  const { type = 'decision', category, memory, reason } = args_typed;
  const scope = normalizeMemoryScope(args_typed.scope);

  try {
    const crypto = await import('crypto');
    const memoryPath = ctx.paths.memory;

    const hashContent = buildMemoryIdentityParts({ type, category, memory, reason, scope });
    const hash = crypto.createHash('sha256').update(hashContent).digest('hex');
    const id = hash.substring(0, 12);

    const newMemory: Memory = {
      id,
      type,
      category,
      memory,
      reason,
      date: new Date().toISOString(),
      ...(scope && { scope })
    };

    const result = await appendMemoryFile(memoryPath, newMemory);

    if (result.status === 'duplicate') {
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(
              {
                status: 'info',
                message: 'This memory was already recorded.',
                memory: result.memory
              },
              null,
              2
            )
          }
        ]
      };
    }

    return {
      content: [
        {
          type: 'text',