sign-lang memory report

Type: agentic-system-analyses/types/agentic-system-memory-report.md

Boundary and evidence

SIGN retains authored knowledge and deterministic compilation products. It does not, within the inspected toolchain, own the later model invocation. The boundary remains complete artifact, partial loop: preparation and maintenance signals are included; enclosing agent execution, the external importer and the external drafting skill implementation are excluded. Their exclusion prevents conclusions about deployed retrieval, imported-content admission, agent compliance or experience learning. This is knowledge preparation, not evidence of memory accumulated by agent use.

The source is SRC-1 at the boundary revision. Direct reads covered README.md, spec/skill-reference.md, validator/bin/sign.js, complete validator/src/compile.js, validator/src/parse.js, validator/src/rules.js, .agent/sign/canon.source.json, .agent/sign/src/SL-OVERVIEW.sign, .agent/sign/src/SL-STANDARDS.sign and editor-support/vscode/package.json. These supply implementation and doctrine/design evidence, not observed operation. Supplied runtime findings cover the maintenance modules, validation edge case, other local corpus documents and CI. They are identified below rather than passed off as direct reads. No new source identity is introduced.

Entry point or operation Source paths and inspection basis Coverage and conclusion limit
Author and parse canon Direct: validator/src/parse.js, local overview/standards and corpus configuration MEM-OBJ-canon-source; content author and initial approval unresolved. Other two local documents are represented through runtime coverage, not reread here.
Compile and replace products Direct: validator/src/compile.js, validator/src/rules.js RT-RTE-compile-canon, MEM-OBJ-canon-index, MEM-OBJ-canon-bundle, MEM-OBJ-canon-manifest, MEM-OBJ-bundle-checksum. File-level bundle admission is not document-level withdrawal.
Validate candidate source Supplied runtime; direct rules/parser corroboration RT-RTE-validate-source. No persistent accepted/rejected content ledger; zero-document early success limits the meaning of validation success.
Coverage/drift/diff maintenance CLI dispatch directly read; module details supplied by runtime RT-RTE-source-signals, RT-RTE-corpus-diff. Signals do not repair, persist a queue or prove later review.
Always-injected index and requested full document Direct: README.md, spec/skill-reference.md MEM-RTE-canon-delivery, RT-BAP-canon-guidance. Named external consumer role, no deployed loader/resolver.
Import alternative Direct CLI; supplied runtime RT-RTE-import-delegation. Child package is excluded; imported content, provenance transformations and later readers are unresolved.
Drafting/reference synchronization Direct: spec/skill-reference.md MEM-OBJ-skill-reference. External skill copy and sync implementation excluded; no verified model authoring route.
Other hooks/tools/service operations Direct complete CLI, parser/compiler exports, editor manifest; supplied runtime inventory CLI has six commands. README tool registration is a sketch; editor manifest contributes language/grammar/icons. No model hook is established by these surfaces. This bounded inspection does not prove absence of every possible external integration.
Trace compaction, isolated agent frames, eviction and reload Direct parser/compiler/CLI and README delivery contract Static field omission is covered below; no turn-history or delegated-context mechanism is established in these paths. Host behavior is outside scope, not evidenced absent.

Core ideas

  1. Authored summaries, not model summarization. The parser copies a ## line from the source; compilation emits that line. The transformation selects fields and summarizes anchor patterns by a code rule. It does not derive an explanatory summary from full rule text (MEM-OBJ-canon-index).
  2. Two different retained projections. The index omits rule bodies and full coverage exclusions. The bundle rereads and copies contributing raw files. Thus an index locator and the complete authoring text have different consumers and information content; the index cannot stand in for the authoritative coverage set (MEM-OBJ-canon-bundle).
  3. Trust vocabulary is not authentication. Provenance and human-review labels express intended governance. Structural checks do not authenticate the reviewer, evaluate an inference or turn prose constraints into runtime action barriers. The hash records bytes, not source trust (MEM-OBJ-bundle-checksum, RT-RTE-validate-source).
  4. Retention and delivery stop at different boundaries. Files persist across calls; the host must load the index and implement document resolution. That documented role supports an afforded consumption route, not observed read-back or improved capacity (MEM-RTE-canon-delivery).

Shared records

Components

none declared in this member

Operative objects

MEM-OBJ-canon-source

Label: Authored SIGN canon sources

Source-native identity: .sign files supplied to parseSource, including the shipped .agent/sign/src corpus. Storage: repository or caller-selected filesystem. Form: natural-language definitions, rules and explanations inside symbolic sigil/identity/link/anchor framing. These are distinct operative parts: JavaScript consumes structural fields and opaque anchor strings; the intended agent interprets full text. No embeddings or learned weights are produced by the inspected parser/compiler. Lineage: source authored outside compilation; local source history is not evidence of a trace-fed generation process. Initial human versus model authorship and approval are unresolved. Closest supplied record: RT-RTE-compile-canon consumes these files; it is a transformation, not this retained input object. No supplied object counterpart.

Local configuration names srcDir and distDir; it is path metadata, not a loader. The CLI takes paths explicitly. The standards document contains coding and authoring guidance intended for agents and employees, not an executable enforcement function (SRC-1, .agent/sign/canon.source.json, .agent/sign/src/SL-STANDARDS.sign, validator/bin/sign.js).

@doc SL-STANDARDS [std, active, agents+employees] v1 sha:pending @links SL-OVERVIEW,SL-ARCH

--- .agent/sign/src/SL-STANDARDS.sign

Source trust remains declared. SRC-1, spec/skill-reference.md states:

LLM-estimated facts must carry confidence: derived or confidence: estimated and cannot be promoted to confidence: asserted without human review. --- spec/skill-reference.md

That is a requested content-admission rule, not proof that any actual write was human approved. In the directly read implementation, inference parsing retains field-presence booleans and the rules check presence, not the claimed authority of their contents (SRC-1, validator/src/parse.js, validator/src/rules.js):

if (t.startsWith('confidence:')) fields.confidence = true; --- validator/src/parse.js

if (!infer.src) missing.push('src:'); --- validator/src/rules.js

Consumers: structural checker/compiler now, intended external agent later through compiled products. Raw authoring retains any source-written rationale and provenance that occur in contributing files, but neither their completeness nor their later interpretation is guaranteed.

MEM-OBJ-canon-index

Label: canon-index.sign field projection

Source-native identity: compiler output canon-index.sign. Storage: caller output directory, UTF-8 file. Form: symbolic canon/document headers, IDs, links, version/status and summarized anchor locator; natural-language ## summary supplied by the author. Lineage: parsed active documents → selected fields → hash-bearing header. Consumer: external prompt assembler and agent as documented, not a shipped model client. Authority: orientation and instruction context by interpretation, not a complete coverage contract. Closest supplied record is RT-RTE-compile-canon, its producer; no supplied object counterpart. The intended consumer overlaps RT-BAP-canon-guidance, a path rather than this object.

The summary is copied, and repeated summary lines overwrite the same parsed slot; the rules warn if missing. There is no automatic semantic condensation or exact-one-summary rejection established by these paths (SRC-1, validator/src/parse.js, validator/src/rules.js, validator/src/compile.js).

if (currentDoc) currentDoc.summaryLine = line.slice(3).trim(); --- validator/src/parse.js

if (doc.summaryLine) { indexLines.push(## ${doc.summaryLine}); } --- validator/src/compile.js

The compiler drops anchor excludes, deduplicates include patterns and displays at most four plus a remainder count. It emits no rule bodies or derivation reasons in the index. The budget is an estimated 400 tokens across selected document fields using chars/4, not a bound on full prompts, document retrieval or actual tokenizers. Headers are outside that estimate. Minimum passages and forcing cases are retained in RT-RTE-compile-canon; SRC-1, validator/src/compile.js, validator/src/rules.js corroborate them directly.

MEM-OBJ-canon-bundle

Label: canon-bundle.sign raw contributing files

Source-native identity: canon-bundle.sign. Storage: output UTF-8 file. Form: raw natural-language document bodies with symbolic SIGN structure and added filename comments; not a reconstructed graph or inference-result database. Lineage: source files that contain at least one active identified document → reread raw text → trailing-whitespace trim at file end → concatenation. Consumer: the documented external document resolver and agent; its actual splitting and ID selection are uninspected. Reasons, examples and provenance in raw source can survive even though absent from parsed structured fields and the index. Retention does not establish their eventual delivery.

Closest supplied record: RT-RTE-compile-canon already establishes raw passthrough and mixed-status leakage; this is its distinct output object, not another compile route. No supplied object counterpart. SRC-1, validator/src/compile.js explains the deliberate fidelity choice:

// We use the raw file content for each file that contributes active docs, // rather than reconstructing from the parsed AST, to preserve exact authoring. --- validator/src/compile.js

Changing an inactive status is therefore insufficient to remove that document's bytes when another active document shares its file. This counterexample prevents reading the compiler comment “full content of active docs” as a universal exclusion guarantee. A later host may filter more strongly, but that is not supplied evidence.

MEM-OBJ-canon-manifest

Label: canon-manifest.json build metadata

Source-native identity: canon-manifest.json. Storage: output JSON file. Form: symbolic build metadata: format version, full/short bundle hash, active document count, timestamp and active-document ID/type/status/version list. Lineage: compiler-selected identities and assembled bundle hash, not a record of human decisions, semantic critiques or agent outcomes. Consumer: an external artifact manager could use it; no implemented later consumer is established. Its active list can differ from raw bundle contents under mixed-status files. It is metadata about knowledge, not its rule text. Closest supplied record: RT-RTE-compile-canon, producer; no supplied object counterpart. SRC-1, validator/src/compile.js:

documents: activeDocs.map(({ doc }) => ({ id: doc.id, type: doc.type, status: doc.status, version: doc.version, })), --- validator/src/compile.js

MEM-OBJ-bundle-checksum

Label: canon-bundle.sign.sha256 byte identity

Source-native identity: canon-bundle.sign.sha256. Storage: output text file containing hexadecimal SHA-256 plus newline. Form: symbolic byte-identity value; no opaque model payload. Lineage: assembled bundle UTF-8 bytes → crypto hash. Same value appears in full in the manifest and abbreviated in the index. Consumer: an external verifier is afforded an integrity value; no verifier invocation is wired in the inspected compiler/README retrieval sketch. Authority: can support equality checking, not author authenticity, semantic correctness, active-only content or compliant actions. Closest supplied record: RT-RTE-compile-canon, producer; no supplied object counterpart. SRC-1, validator/src/compile.js:

const sha256 = crypto.createHash('sha256').update(bundleContent, 'utf8').digest('hex'); --- validator/src/compile.js

The checksum and manifest have distinct consumers/roles from agent-facing text, so their retention is not counted as knowledge read-back.

MEM-OBJ-skill-reference

Label: SIGN skill authoring reference

Source-native identity: spec/skill-reference.md. Storage: tracked Markdown, plus a documented external synced copy not inspected. Form: natural-language authoring/governance instructions with symbolic syntax templates. Lineage: attributed to SIGN whitepaper v1.0; source claims it is canonical for the drafting skill. Consumer: external sign-draft skill/reference reader; delivery and compliance uninspected. This is static shipped guidance, not experience memory. Closest supplied records: RT-CLM-agent-contract covers the broader consumption claim, and RT-RTE-import-delegation covers a different external tool, not this skill. No supplied object counterpart. SRC-1, spec/skill-reference.md:

Authoritative sigil vocabulary, syntax rules, operators, and governance model for use by the sign-draft skill. Sourced from SIGN whitepaper v1.0. --- spec/skill-reference.md

The instruction describes a human/operator editing and sync surface; no implemented per-content approval, automatic sync or later runtime loading in this repository is established. Three-layer delivery is described in this reference, but the inspected compiler only writes the two-layer artifacts. It is not evidence of selective-index implementation.

Routes

MEM-RTE-canon-delivery

Label: Documented index injection and requested document delivery

Endpoints/progression: persisted index → host file read/system-prompt assembly → agent sees IDs/links/summary → agent requests get_canon_doc(id) when needed → host-defined canonBundle.getDoc(id) returns full document. Owner: host wires delivery; agent chooses the request; no deployed host implementation is frozen. This is distinct from RT-RTE-compile-canon, which ends with files. It operationalizes the same intended consumption as RT-CLM-agent-contract and RT-BAP-canon-guidance; reconciliation should connect them, not treat them as separate independent consumers. SRC-1, README.md, spec/skill-reference.md supply doctrine/design evidence.

  • design conclusion status: afforded
  • implementation conclusion status: uninspected
  • operation conclusion status: uninspected
  • Immediate return: the documented tool handler returns the result of external canonBundle.getDoc(id); return schema and errors are unspecified.
  • Later read-back: intended across agent invocations through loading retained canon; no run demonstrates it and no use-generated update is established.
  • Delegated visibility: external model receives injected index and requested document content by host design; no isolated sub-agent or separate context is specified.
  • Selection predicate: automatic per-invocation supply selects the whole compiled index; requested full document uses the agent-supplied ID. No query ranking, embedding search, task-derived automatic selection or host authorization filter is implemented here.
  • Invalidation or expiry: uninspected — host cache/reload/version policy unspecified; compiler overwrite alone does not revoke an already loaded prompt or cached document.
  • Activation or effect: intended domain guidance through model interpretation; delivery, changed decisions and benefit remain unobserved.
  • Evidence limits: named external consumer and illustrative handler establish an afforded role, not installed tool registration, valid resolver semantics or complete document delivery.

The targeting input is a document ID, not an implemented relevance score. There is no specified retrieval count, full-document token cap or accumulated-window eviction policy. The reference's 300–500-token full-document size is typical guidance, not enforced delivery budgeting. Minimum SRC-1 passage from README.md:

name: "get_canon_doc", description: "Retrieve full SIGN document by ID", parameters: { id: { type: "string" } }, handler: async ({ id }) => canonBundle.getDoc(id) --- README.md

The always-supplied selector is host prompt assembly, not unsolicited runtime retrieval inferred from storage. RT-BAP-canon-guidance retains the exact injection instruction and consumer authority limits.

Claims

none declared in this member

Evidenced absences

none declared in this member

Behavioral-authority paths

none declared in this member

Annotations

On RT-RTE-compile-canon

Memory-specific lineage: MEM-OBJ-canon-source becomes a lossy MEM-OBJ-canon-index and largely preserved MEM-OBJ-canon-bundle, plus metadata/checksum. The index summary is source-authored, not compiler-generated prose; only anchor summarization is computed. No raw episode-to-derived-memory transformation is established. Admission is fixed software checking; authoring and per-content human approval remain separate unknowns. There is no semantic reviewer or provenance authentication in the directly read compiler/rules. Source error veto and warning behavior have the supplied route's exact scope (SRC-1, validator/src/compile.js, validator/src/rules.js, validator/src/parse.js).

Working-context control: preparation keeps rule bodies, complete anchors and provenance bodies out of the small orientation layer. Those remain in source/contributing bundle files, reachable through the documented external full-document role. This resembles selecting what enters a frame, not creating or popping a runtime agent frame: SIGN does not own that frame or evict material already present. IDs are locators requiring a host resolver, not automatically followable window references. The four-pattern cap and 400-token estimate constrain projection, not an external model's complete context. No alternative transcript checkpoint, compaction summary or retained trace result is established here.

On RT-RTE-source-signals

Curation limit: coverage and drift derive diagnostics from current anchored files and Git comparison, not revised canon. The supplied route's quotations establish the transient report and external review boundary (SRC-1, validator/src/drift.js, validator/bin/sign.js). Later consumer is the caller/platform; no persistent review queue, automatic acceptance or repaired-document read-back is established. This is maintenance support rather than trace-fed learning. Physical stdout emission and command initiation do not establish human content approval.

On RT-RTE-corpus-diff

Curation limit: retained historical Git text is compared with current text, but the result is a transient classification, not a new explanation or updated instruction. The supplied route covers missing deletions and current-path historical reconstruction (SRC-1, validator/src/diff.js, validator/bin/sign.js). No later knowledge consumer of a persisted diff result is wired. The proposed revalidation obligation is distinct from actual admission enforcement.

On RT-RTE-import-delegation

Memory-specific unknowns: original imported input format, transformed retained parts, provenance preservation, human/software content admission and eventual consumers belong to the external package, not the CLI spawn. Known forwarding and inherited stdio cannot resolve those fields. This uncertainty does not suppress the directly known compiler transformations of any subsequently supplied source (SRC-1, validator/bin/sign.js).

Write side

Source acquisition is caller-authored or caller-supplied filesystem input. Directory discovery chooses .sign files; direct-file input accepts a file without an extension filter. The parser extracts structural data but does not persist a new source. Human editing is possible through ordinary files, but neither a generic caller nor starting compilation establishes per-content human approval (MEM-OBJ-canon-source, SRC-1, validator/src/parse.js). External import and external drafting remain separately bounded; no hidden source-generation route is inferred from their names.

Compilation's admission mechanism is recognized parse errors plus fixed rules with strict links. It can veto writes before output creation; warnings do not veto. This is structural admission, not checking truth, provenance authenticity, rule consequences or semantic preservation. Missing ## produces a warning, not forced summary generation. The budget can reject excessive projected characters but does not shorten content automatically (RT-RTE-compile-canon, MEM-OBJ-canon-index).

Successful compilation replaces four fixed filenames. Rejection before writes leaves existing artifacts untouched; it does not mark them expired or withdraw them from already-running consumers. A later filesystem exception can leave a partial update, and no transaction/rollback is implemented in the compiler. Restoring prior source/artifacts and rerunning belongs to the caller. Withdrawal is projection-specific: inactive IDs leave the index/manifest, but their raw text may remain in a file shared with active IDs. Deleting or changing source does not automatically clear a host cache (MEM-OBJ-canon-bundle, RT-RTE-compile-canon).

Maintenance evaluation returns coverage/drift/diff signals, with the supplied runtime's deletion and historical-read limits. It neither lands edits nor proves human review. Cadence and reviewed-date syntax in spec/skill-reference.md express desired maintenance metadata; the directly read rules do not impose expiry based on those dates. No inspected write uses conversation traces, tool outcomes or agent behavior to derive a durable new policy. This bounded finding concerns these preparation paths, not opaque external ingestion or host behavior. Source-written reasons survive raw bundling where present; the index does not retain them, and no actual later rationale reader is established.

Read-back

There are three different consumers, not one universal “memory read.” The parser/rules read source into transient structural objects now. Maintenance commands read current source and Git baselines to emit current diagnostics. The documented external host later reads compiled material for the agent. Only the last describes agent-facing consumption; even there, a repeated static corpus is not by itself memory acquired through use (MEM-RTE-canon-delivery).

For host delivery, the index is automatically supplied whole at each intended invocation, while full documents are selected by the agent's requested ID. Static projection omits text before prompt assembly; it does not trim old turns, summarize conversation, isolate sub-agent work or decide which previous tool results remain. No selection evidence supports semantic retrieval or automatic relevance ranking. The index's links and summarized anchors offer orientation; the repository does not implement traversal from a task to selected governing documents. A full-document request crosses the host resolver boundary, so eventual content completeness, filtering, instruction authority, token budgeting and cache invalidation remain unresolved.

The manifest and checksum establish storage capabilities for artifact identity metadata, not implemented downstream readers. No route is invented for a hypothetical verifier. The drafting reference names an external reader and a sync procedure, but it is static method guidance rather than a retained operational trace. No observed read, compliance, improved later action or causal savings is established for any of these channels.

Integration issues

  • No required correction to supplied runtime facts. Direct reads corroborate its file-level passthrough, field projection, budget estimate, CLI dispatch and external-consumer boundary. This report adds that summaries are copied from a last-written parsed slot and missing-summary warnings do not block compilation (MEM-OBJ-canon-index); it does not contradict the runtime's wording “optional summarized anchor and summary.”
  • Potential overlapping account, not duplicate referents: MEM-RTE-canon-delivery describes the progression underlying RT-CLM-agent-contract and RT-BAP-canon-guidance. The claim/path and route have different kinds but describe the same intended consumer. Afforded design role does not upgrade implementation or observation. Object records have no supplied object counterparts; RT-RTE-compile-canon is their producer, not their container identity.
  • Unresolved host selection and authority: MEM-RTE-canon-delivery and MEM-OBJ-canon-bundle cannot establish getDoc parsing, returned content, filtering, cache policy, compliance or full-document budgets. README is an integration sketch, not the missing implementation. Prevents end-to-end read-back and revocation guarantees.
  • Unresolved write provenance/admission: MEM-OBJ-canon-source, MEM-OBJ-skill-reference and RT-RTE-import-delegation leave initial authorship, actual human review and external transformation controls unknown. The human-review doctrine cannot fill that evidence gap.
  • Metadata consumer not established: MEM-OBJ-canon-manifest and MEM-OBJ-bundle-checksum have known producers but no inspected later verification route. Prevents treating hashes as an enforced trust or consistency gate.
  • Governance and withdrawal limits retained: RT-RTE-source-signals, RT-RTE-corpus-diff and MEM-OBJ-canon-bundle prevent inferring complete rejection, deletion detection or content withdrawal from labels alone. No unresolved question here requires expanding the frozen boundary.

Limitations and checks

The checkout HEAD was rechecked as f4eb1a82b114615754bbe5c2e6f4255a4ec1eeba; git status --short returned no changes. Governing job, member types, worker rules, collection and complete records contract were read, including continuation ranges. Supplied runtime and boundary were read completely. The source identity is unchanged and all new findings use SRC-1 at that pin. No prior characterization, target execution, test, provider call or dependency installation was used.

This member establishes implementation and declared design only. External importer/drafting internals, the host resolver and actual agent invocations are not frozen evidence. Static shipped text does not establish trace-fed learning; retained files do not establish activation; declared provenance does not authenticate it. No claims of exercised learning, improved capacity or self-improvement follow from compilation. No unresolved artifact is hidden behind those limits.

Validation: the prescribed role-specific commonplace-validate command passed after output construction. Its result checks form and quotation occurrence, not semantic acceptance or deployed behavior.