Method create

src/node/services/memoryService.ts:700–734

(
    ctx: MemoryScopeContext,
    virtualPath: string,
    fileText: string,
    actor: MemoryActor
  )

  }

  async create(
    ctx: MemoryScopeContext,
    virtualPath: string,
    fileText: string,
    actor: MemoryActor
  ): Promise<MemoryCommandResult> {
    return this.runCommand(async () => {
      const parsed = parseMemoryPath(virtualPath);
      const scope = this.requireFilePath(parsed, virtualPath);
      assertWithinFileSizeCap(fileText);
      // create is a write: materialize the scope root on first use.
      const store = await this.resolveStore(ctx, scope, parsed.relPath, { createRoot: true });
      return this.locks.withLock(store.physicalRoot, async () => {
        const existing = await store.kind(parsed.relPath);
        if (existing !== null) {
          throw new MemoryCommandError(
            `A ${existing === "dir" ? "directory" : "file"} already exists at ${virtualPath}. To overwrite a file, delete it first, then create it.`
          );
        }
        const files = await store.listFiles();
        if (files.length >= MEMORY_MAX_FILES_PER_SCOPE) {
          throw new MemoryCommandError(
            `The ${scope} memory scope is full (${MEMORY_MAX_FILES_PER_SCOPE} files); delete unused files first`
          );
        }
        await store.writeFile(parsed.relPath, fileText);
        await this.recordUsage(ctx, scope, parsed.relPath, { write: true });
        this.emitChange(ctx, scope, parsed.relPath, actor);
        return {
          success: true as const,
          output: `Created ${toVirtualPath(scope, parsed.relPath)}`,
        };
      });
    });
  }

  async strReplace(
    ctx: MemoryScopeContext,