Method insert

src/node/services/memoryService.ts:774–808

(
    ctx: MemoryScopeContext,
    virtualPath: string,
    insertLine: number,
    insertText: string,
    actor: MemoryActor
  )

  }

  async insert(
    ctx: MemoryScopeContext,
    virtualPath: string,
    insertLine: number,
    insertText: string,
    actor: MemoryActor
  ): Promise<MemoryCommandResult> {
    return this.runCommand(async () => {
      const parsed = parseMemoryPath(virtualPath);
      const scope = this.requireFilePath(parsed, virtualPath);
      const store = await this.resolveStore(ctx, scope, parsed.relPath);
      return this.locks.withLock(store.physicalRoot, async () => {
        const content = await this.readTextFileForEdit(store, parsed.relPath, virtualPath);
        const lines = content === "" ? [] : content.split("\n");
        if (insertLine < 0 || insertLine > lines.length) {
          throw new MemoryCommandError(
            `insert_line must be between 0 and ${lines.length} (0 inserts at the top; N inserts after line N)`
          );
        }
        const insertedLines = insertText.split("\n");
        // Trailing newline in insert_text would otherwise produce a stray blank line.
        if (insertedLines.at(-1) === "") insertedLines.pop();
        lines.splice(insertLine, 0, ...insertedLines);
        const updated = lines.join("\n");
        assertWithinFileSizeCap(updated);
        await store.writeFile(parsed.relPath, updated);
        await this.recordUsage(ctx, scope, parsed.relPath, { write: true });
        this.emitChange(ctx, scope, parsed.relPath, actor);
        return {
          success: true as const,
          output: `Inserted ${insertedLines.length} line(s) into ${toVirtualPath(scope, parsed.relPath)} after line ${insertLine}`,
        };
      });
    });
  }

  async deletePath(
    ctx: MemoryScopeContext,