RECALL: The Source That Knows Who Wrote It

The Authorship Problem

Git blame tells you which commit last touched a line. It does not tell you whether a human typed it, whether an AI generated it and a human accepted it, or whether an orchestrated agent wrote it as part of a larger pipeline that no individual ever reviewed line by line.

That distinction did not used to matter. Now it does.

When AI writes a meaningful fraction of a codebase, the signal carried by authorship changes. A commit from a human who typed every character means something different from a commit where a human reviewed AI output at the diff level and pressed merge. Both appear identically in git. Both are attributed to the same name. The audit trail — the thing that gives provenance meaning — collapses at exactly the moment it becomes most important.

RECALL v1.1 introduces AUDIT DIVISION. It is a formal division of the language, declared after PROCEDURE DIVISION, that makes authorship a compile-time constraint — not a convention, not a comment, not a commit message format. A typed field.

What the Division Looks Like

The syntax is consistent with the rest of RECALL — explicit, declarative, structured like a form you fill in rather than code you write.

AUDIT DIVISION.
   CREATED-BY.   Human.
   CREATED-DATE. 2026-04-11.
   CHANGE-LOG.
      2026-04-11 "Human"         "Initial authoring.".
      2026-04-11 "AI compositor" "Expanded WITH INTENT CALLOUT block.".
      2026-04-11 "AI agent"      "Added STAT-GRID via pipeline run.".

Three fields. CREATED-BY declares who authored the initial version. CREATED-DATE is an ISO 8601 date, validated at compile time. CHANGE-LOG is a sequence of dated entries — each with an author kind and a description.

None of this is documentation. Each field is enforced by the compiler. A malformed date fires RCL-028. A change entry dated before CREATED-DATE fires RCL-029. An unrecognised author kind fires RCL-030 and aborts compilation.

The Three Author Kinds

The constraint on CREATED-BY and every CHANGE-LOG author entry is exact. Exactly three values are permitted. Click any row to expand.

The three kinds model the three actual ways a RECALL source gets written. A human opens a file and types. An AI compositor — invoked via recall expand — works within the compiler's constraints: it receives the live element registry, the DATA DIVISION fields, and the COMMENT annotations, and produces valid RECALL source that the compiler validates before writing. An AI agent calls the compiler programmatically as part of a pipeline, producing output at a distance with no human in the loop.

The distinction between AI compositor and AI agent is not aesthetic. A compositor is constrained — it operates through the RECALL CLI, its output is type-checked before it is accepted, and the field types it works with are declared in the DATA DIVISION it can read. An agent is unconstrained in this sense — it may produce the source, validate it, and write it as part of an orchestrated run. The authorship trail needs to carry that difference.

recall diff: the Change Record Writes Itself

v1.1 also ships recall diff — a semantic diff between two .rcl sources at the AST level, not the text level. Where a text diff reports that lines changed, recall diff reports that a DATA DIVISION field was renamed, that a PIC type changed from X(60) to X(120), that a DISPLAY statement was added in the PROCEDURE DIVISION. Git revision syntax works directly:

recall diff HEAD~1 HEAD page.rcl
recall diff v1.rcl v2.rcl --format json
recall diff HEAD~1 HEAD page.rcl --suggest-audit

The --suggest-audit flag is the connection between the two features. It produces a ready-made CHANGE-LOG entry from the diff output — dated, with a blank author field to fill in:

2026-04-11 "Human" "Added HERO-STAT field (PIC 9(6)). Added STAT-GRID to RENDER section."

The workflow collapses to: make a change, run the diff, paste the suggestion into AUDIT DIVISION, fill in the author kind. The change record writes itself from the semantic diff. The authorship is the one thing only the author knows.

The Compiled Output

RECALL compiles to self-contained HTML. The AUDIT DIVISION does not produce visible output — it compiles into a structured comment block embedded before the closing body tag, invisible to readers but present in view-source and parseable by any tool that looks for it:

<!-- RECALL AUDIT
  created-by:   Human
  created-date: 2026-04-11
  change-log:
    2026-04-11 | Human         | Initial authoring.
    2026-04-11 | AI compositor | Expanded WITH INTENT CALLOUT block.
    2026-04-11 | AI agent      | Added STAT-GRID via pipeline run.
-->

Every compiled artifact carries its own provenance. Not in a sidecar file. Not in a database. In the artifact itself — the same artifact that can be opened directly in a browser, copied, archived, or inspected a decade from now with no toolchain. The source remembers. So does the output.

LSP: The Other Side of the Same Coin

The same v1.1 release ships @semanticintent/recall-lsp — a Language Server Protocol implementation that brings RECALL into VS Code, Cursor, and any LSP-capable editor.

The connection to AUDIT DIVISION is not superficial. LSP is the protocol that Copilot and Cursor use to understand what is in an open file. With the LSP active, RECALL's field types, PIC declarations, COMMENT annotations, and diagnostic codes are visible to AI coding assistants — not just to the developer reading them. A Copilot suggestion for a DISPLAY statement is now informed by the actual DATA DIVISION fields that exist in the file.

The point is not editor ergonomics — though those matter. The point is that the AI tools writing RECALL now have the same structural understanding of the source that the compiler has. Field types are not inferred from context. They are declared, validated, and surfaced via LSP to whatever reads the file next — human or AI.

What v1.1 Actually Is

Taken together, AUDIT DIVISION, recall diff, and the LSP are the same feature expressed three ways.

AUDIT DIVISION is the answer to: who wrote this, and what changed? recall diff is the mechanism that makes tracking changes precise enough to be worth recording. The LSP is what makes AI tools aware of the structure they are writing into.

The underlying question all three answer is: as AI writes more of the source, what does it mean for the source to be trustworthy? The answer RECALL v1.1 proposes is formal provenance — not as a convention or a process, but as a language construct, enforced at compile time, embedded in every artifact the compiler produces.

A RECALL source that compiles is valid. A RECALL source with a valid AUDIT DIVISION is also traceable. The compiler enforces both. The author supplies the one thing the compiler cannot infer: who did the work.