Method write

src/filesystem/transaction.ts:69–124

(filePath: string, content: string)

    private toolCallId?: string,
  ) {}

  async write(filePath: string, content: string): Promise<void> {
    this.ensureOpen();
    const abs = path.resolve(filePath);

    // ─── Autonomy-contract scope gate (--scope) ───
    // When a headless contract run pins a write scope, edits outside it are refused
    // BEFORE anything touches disk. No-op unless a scope root is registered (see
    // autonomy-contract.ts). Rollback/undo paths write via fs directly — never gated.
    {
      const denial = checkWriteScope(abs);
      if (denial) {
        logger.info('Scope gate refused write', { txnId: this.id, path: abs });
        throw new Error(denial);
      }
    }

    let beforeContent: string | null = null;
    let beforeHash: string | null = null;
    let isCreate = false;

    try {
      beforeContent = await fs.readFile(abs, 'utf-8');
      beforeHash = hashContent(beforeContent);
    } catch (e: any) {
      if (e.code === 'ENOENT') {
        isCreate = true;
      } else {
        throw e;
      }
    }

    // ─── Pre-commit syntax gate ───
    // Parse the candidate content (tree-sitter, in-process) BEFORE it touches the
    // disk. Refuses only when the edit would turn a clean-parsing file into a broken
    // one (baseline tolerance) — see syntax-check.ts. The throw surfaces to the model
    // as a [SYNTAX_REJECTED] tool-result observation; the file on disk stays intact.
    // Rollback/undo paths use fs.writeFile directly and are NOT gated.
    // Off-switch: discipline.syntaxGate: false
    {
      const { checkSyntaxForWrite } = await import('../tools/ast/syntax-check.js');
      const rejection = await checkSyntaxForWrite(abs, beforeContent, content);
      if (rejection) {
        logger.info('Syntax gate refused write', { txnId: this.id, path: abs });
        throw new Error(rejection);
      }
    }

    if (beforeContent !== null) {
      await this.journal.storeBlob(beforeHash!, beforeContent);
    }

    const afterHash = hashContent(content);
    await this.journal.storeBlob(afterHash, content);

    await fs.mkdir(path.dirname(abs), { recursive: true });
    await writeFileAtomic(abs, content, { encoding: 'utf-8' });