A supply chain for your coding agent's work. Every change goes through defined stages: the department that owns it, your decision among the optimal options, evidence, gates and review. It comes out with a verifiable record: what it was built with, who decided what and when, what was proven, which commit it produced.
For Claude Code, Codex, Cursor, Gemini CLI, OpenCode and any agent that reads Agent Skills (SKILL.md).
A waymark is the sign that marks a trail: it shows the way, and you choose the path. Agents often reach the right answer only after many attempts: they guess APIs, edit the wrong element, rebuild what the project already has, forget yesterday's fix and take decisions you would not have taken. Waymark shortens that path. At every real decision the agent lays out the optimal options with their files, risk and cost and marks the one it recommends; you decide, because the recommended one may not be what you need.
It is not an orchestrator and it spawns no agent pipelines. It is a set of skills that makes the agent work like a software company. Every non-trivial task goes through the department that owns it. The department decides:
- what gets built, why and for whom;
- where it lives in the architecture;
- how it is done, and which skills and MCP servers to use.
The task then closes with a Definition of Done (typecheck, lint, tests, build, architecture conformance). Finally the agent learns from the result.
Stack- and language-agnostic: department rules are generic. Stack and architecture specifics live in profiles.
Waymark is a chain of custody for the work an agent does on your code. For each task it keeps one record, chained by hash and anchored in git, of what governed the task, what you decided, what the hooks proved and which commit came out; and it lets someone who was not there check that record.
It is not an environment installer, not an orchestrator that runs agents, and not a workflow framework: it is skills the agent reads, hooks that run beside it and a record. It does not audit your dependencies.
What it records, and where each statement is tested:
| Statement | Source |
|---|---|
| One record per task, chained by hash; an edited, deleted or re-chained log is detected | tests/supply-chain.test.mjs, tests/verify.test.mjs |
The log is anchored in git (refs/notes/waymark-anchor) and a clone rebuilds its memory from git |
tests/supply-chain.test.mjs, tests/memory-chain.test.mjs |
| Your decision is the answer you gave in the choice window, recorded as given with its position before or after the first change | tests/hooks.test.mjs |
| Gates, tests, review and build are computed by the hooks from the tool calls, not declared by the agent | skills/waymark/routine.json, tests/integrity.test.mjs |
| Evidence is checked against the task's tool calls; a fact no call shows is marked | tests/supply-chain.test.mjs |
Each record pins the rules that governed it (department, procedures, routine.json, profiles) by hash |
tests/verify.test.mjs |
| The cost of each task is split into routine, work and reply | tests/hooks.test.mjs, docs/audit-context.md |
| The review is required where the risk is: L3, a sensitive path, many files or lines | tests/risk.test.mjs |
| Reading or editing secret-bearing paths is blocked where the agent's hook runs before the tool | tests/guard.test.mjs |
waymark.mjs verify checks the chain, the installed files against MANIFEST.json and the release signature; attest exports one task |
tests/verify.test.mjs |
| Stack profiles for 13 ecosystems and 6 architectures, measured on five outside repositories | skills/waymark/stacks, tests/external.test.mjs |
What it does not do, so that nobody has to find out later:
- The records are not signed. Without a signature the chain resists accidents and partial edits, not someone who can rewrite the repository and chain it again. The release is signed with git when the maintainer's key is in
skills/waymark/ALLOWED_SIGNERS;verifyreportsunsignedas a warning, and--require-signaturemakes it fail. An exported attestation is not signed either. - It stops only where the agent lets a hook run. The table below says, per agent, what is enforced and what is only asked. The sensitive-path guard does not stop a search that reaches a secret without naming it (
grep -r, a script). - The cost figures are measured per task and per part, not compared with any other tool. There is no published token comparison.
- Outside the author's own projects it was measured on five repositories (Rust, Laravel, Terraform, Python data science, documentation only), for detection, profiles and gate recognition. The memory bootstrap, the routing and the token cost of a change there were not measured; a repository with a JS framework and a PHP backend is classed Node; Kotlin or Swift apps, a multi-language monorepo and embedded C are not yet in the corpus.
A software supply chain tracks how an artifact was built: its inputs, the steps it went through and who approved them, with records that cannot be altered unnoticed. Waymark applies that to the agent's work. The hooks build the record locally from what the session transcript proves, not from what the agent says, and cost 0 model tokens.
| Link | What Waymark records | How it is verified |
|---|---|---|
| Inputs | your request in your words; the project memory; a manifest per task: Waymark and agent version, model, MCP servers used, hashes of the instruction files | read from the transcript and the files at the end of the turn |
| Department | the department that owns the task (frontend, backend, data, security, QA, devops, architecture, UX/UI, product, devex): its procedure, rules, tools and Definition of Done | the owner named in the routing line must have been invoked, and its procedure read before the first change; the record keeps declared vs invoked. A question that turns into a change is re-routed, or it is stopped |
| Decision | the options put to you, the one you picked and the ones you discarded, on a dated task ID (2026-10-02 · T3), each answer with its position (before or after the first change) |
your answer in the choice window, recorded as is: no file changes, by edit or by shell, until you were asked; the agent never restates it |
| Evidence | what was observed vs inferred, and the check you were given before the fix | written by the agent, and checked by the hook: «observada» needs a tool call that checked the state after the last change (a commit or push is none), and each fact it cites (84/84, exit 0, a hash, text in backticks) is looked up in the task's tool calls, never in the agent's own edits; a file:line also counts when a call named the file and printed that line (grep -n, Read); one no call shows is recorded as sin respaldo and shown as ⚠, without lowering the score. The hook also judges actions: a failing gate needs a clean-copy check, a command failing twice needs a docs call before the next run (docs/adr/0025) |
| Gates and review | lint, typecheck, tests, build, code review (a browser check only when the user asks), memory and procedure used, with the time each gate took and whether it failed | computed by the hooks from the tool calls, never declared by the agent (the platform generates the provenance, as in SLSA). What blocks and what is only scored is one contract, skills/waymark/routine.json, that you can change: by default the project memory searched (waymark.mjs pack) before the first change, a gate after the last change and, at L2+ with code, code-review (or waymark.mjs review in agents without it) and the build at the end. Everything is scored in an automatic evaluation of each task (✔/✘ per step, tokens, estimated quota), shown to you in one line |
| Output | the files changed and the commits | the files git saw change between your message and the end of the turn, whatever tool changed them; each commit carries Waymark-Task: <task ID> and the record keeps its hash |
| Record | one line per task in <project>/.waymark/provenance.jsonl (with a commit: the whole record as a git note on it, refs/notes/waymark), and tasks.md next to it: in progress, pending, next step, done |
each line holds the hash of the previous one (and of its note): editing or deleting a past task breaks the chain. Each record also anchors the log's length and last hash in git (refs/notes/waymark-anchor, travels with the notes), so a log rewritten and chained again breaks it too; a removal you ask for goes through waymark.mjs forget, which leaves a rewrite anchor with your reason (docs/adr/0025). What has no commit (a question, a task without one) rides in git too (refs/notes/waymark-log), a task committed in several repos has its note in each, and a clone or a cleaned project with no .waymark/ gets its memory and tasks.md rebuilt from git at session start (docs/adr/0012, 0013). The folder is local (kept out of git through the project's .gitignore) and plain Markdown/JSONL, so any agent (Codex, Cursor, a new session) resumes from it |
What it is not: an SBOM or a dependency audit. Dependencies are dept-security's job; this chain covers the work the agent does on your code. Decisions: docs/adr/.
Hooks differ by agent, so what Waymark can stop differs too. The tables are generated from the code, not written by hand. A read through a shell command that names no file (grep -r, a script) is not stopped by the sensitive-path guard on any agent.
Hook events Waymark registers, per agent (from agents/agents.json):
| Agent | SessionStart | UserPromptSubmit | PreToolUse | PostToolUse | Stop |
|---|---|---|---|---|---|
| Claude Code | yes | yes | yes | — | yes |
| Codex | yes | yes | yes | — | yes |
| Gemini CLI | yes | yes | yes | yes | yes |
| OpenCode | yes | yes | yes | yes | yes |
| Cursor | yes | yes | yes | yes | yes |
| Antigravity | yes | yes | yes | yes | yes |
| Kiro | yes | yes | yes | yes | yes |
| Copilot CLI | yes | yes | yes | yes | yes |
What each agent enforces. enforced: a hook runs and can stop the turn or hand the agent the text. advisory: the agent is told in its instructions and nothing blocks it.
| Agent | End-of-turn checks | Decision gate and commit trailer | Memory and procedures handed over | Sensitive paths: edits and shell | Sensitive paths: reads | Context brake |
|---|---|---|---|---|---|---|
| Claude Code | enforced | enforced | enforced | enforced | enforced | enforced |
| Codex | enforced | enforced | enforced | enforced | advisory | enforced |
| Gemini CLI | enforced | enforced | enforced | enforced | advisory | enforced |
| OpenCode | enforced | enforced | enforced | enforced | advisory | enforced |
| Cursor | enforced | enforced | enforced | enforced | advisory | enforced |
| Antigravity | enforced | enforced | enforced | enforced | advisory | advisory |
| Kiro | enforced | enforced | enforced | enforced | advisory | advisory |
| Copilot CLI | enforced | enforced | enforced | enforced | advisory | advisory |
Agents Waymark knows with no adapter yet (nothing is recorded or checked there): Windsurf, Qwen Code, Droid, Amp, Crush.
Tell your agent:
Install Waymark from https://github.com/LiriRaid/waymark following its INSTALL.md
(en español: "Instálame Waymark desde https://github.com/LiriRaid/waymark siguiendo su INSTALL.md")
There is no installer script. INSTALL.md is written for the agent, and the agent runs it step by step:
- Detects which agent it is and where that agent keeps skills and instructions (
adapters/). - Clones the repo and backs up anything already installed.
- Offers to remove the third-party skills this one replaces.
- Copies the skills and creates your private layer
~/.waymark/. - Writes a managed block of general working rules into each agent's instructions file (
CLAUDE.md,AGENTS.md,GEMINI.md…). The rest of that file stays as it is. - Registers Waymark's hooks in each agent: settings for Claude Code, Codex and Gemini CLI,
hooks.jsonfor Cursor, a plugin for OpenCode,hooks/waymark.jsonfor Copilot CLI and Kiro, and awaymarkhook in Antigravity'sconfig/hooks.json. In Claude Code it also sets Waymark's status line (5h 41% · esta sesión ≈12% · 7d … · contexto …). - Sets up engram, the learned memory every agent shares (installs it after your yes if it is missing), proposes MCP servers (
context7; stack-specific ones only for stacks you use) and runssync.mjs. - Lists every file it created or modified, asks you to restart, and gives you a smoke test.
It can configure every agent on the machine in one run (Claude Code, Codex, OpenCode, Gemini CLI, Cursor…); all of them share the same memory, so you can start a task in one agent and continue it in another: .waymark/tasks.md and the git notes say where the work stands, and engram what each task learned. Known agents are data (skills/waymark/scripts/agents/agents.json: Copilot CLI, Kiro and Antigravity with their hooks, and Windsurf, Qwen Code and others with the pointer, besides the five above). An agent Waymark does not know is detected by its home folder: it gets the pointer to .waymark/tasks.md, and writing its adapter is a procedure (docs/adr/0022). The task records are git notes, so they travel with the repo: in a repo with Waymark memory the session hook makes fetches bring them, and another machine sees what this one did (docs/adr/0020).
When a new version is published, waymark.mjs check reports it (the session hook asks the agent to run it once a week) and the agent asks whether to update. Update without reinstalling: "actualiza Waymark desde https://github.com/LiriRaid/waymark siguiendo su INSTALL.md". The agent compares VERSION, shows the CHANGELOG, keeps what your skills learned and replaces the rest. The same sentence with "uninstall" removes it (uninstall.mjs). Node.js 18+ is required: the skill links, the hooks, the status line and every script run on it.
Nothing is preloaded "just in case". Loading is layered:
| Part | Loaded | What it is | Characters |
|---|---|---|---|
| instructions block | every session | instructions block in CLAUDE.md / AGENTS.md: levels, routing, the testigos, memory | 6,494 |
| skill descriptions | every session | Waymark's 17 skill descriptions, which the agent lists | 3,492 |
| reminder (full) | every prompt | the rule line of the per-prompt reminder (the task ID, stack and git line come on top) | 99 |
| reminder (short) | every prompt after a reply that followed the routine | the short reminder | 37 |
| protocol L2 | an L2 task | the protocol an L2 reads | 3,907 |
| protocol L3 | an L3 task | the protocol an L3 reads (L2 and L3 parts) | 5,285 |
| held message (max) | only after the context brake | the largest line the session hook adds for a held message | 637 |
Other parts, loaded when they apply: a department's dept-*/SKILL.md once per session per department (about 5 to 7 thousand characters), its procedures.md (the hook hands it over at the task's first change), the project card once per session (a few hundred characters here; it grows with the project's open work and learned memory), the core references and the stack and architecture profiles only in the situations they list. Project memory and its Project map replace re-exploring the project each session.
A small L1 task loads the block plus one department and one procedure. node <skills-dir>/waymark/scripts/size.mjs measures each of these for the project you run it in, including the lines the session hook may add after the card (docs/adr/0024). Memory (project map, verified gate commands, engram) avoids re-discovering the same things every session.
The bigger saving is not the size of each attempt but the number of attempts: a task costs attempts × cost per attempt. Waymark's fields (the ask and what each screenshot points at, evidence before the fix, reuse, verified APIs, the two-strike rule) aim at one attempt per task. Large tasks keep their plan as checkpoints in the project memory, so a context compaction does not make the agent guess what was done.
Measured on real tasks (docs/audit-context.md), each model response re-reads the whole context (~58 k tokens in Claude Code), so the cost driver is the number of responses. The hooks do the routine's own steps instead of the agent: the git status comes with each prompt, each file's history at its first edit, a department loads once per session, and what was learned is saved at the close. A step the agent could forget is a step the hook does.
Your MCP servers stay registered where you put them. In each project, scripts/mcp-fit.mjs reads its manifests and blocks (a deny rule in that project's private .claude/settings.local.json, after your yes) the framework servers it does not use: no Angular CLI or PrimeNG in a React app or a docs repo, no React docs in an Angular app. When the project adopts the framework the rule is lifted. Docs and memory servers are never blocked. waymark.mjs check reports it for the project it runs in.
Each listed skill costs its description in every session. scripts/skill-fit.mjs finds the skills you added but have not invoked in 30 days and, after your yes, lists only their names (still invocable); unused plugins are disabled. Waymark's 17 descriptions went from 8,558 characters (1.x, CHANGELOG.md) to the figure in the table above. Resuming a large session after an hour idle re-writes its whole context (the cache expired), so a new task is cheaper in a new session. These are reported, not enforced: node <skills-dir>/waymark/scripts/waymark.mjs check lists what is pending (a newer version, skills changed, MCP fit, skill fit, the migration, unconnected agents, a large idle session), and the session hook reminds the agent to run it once a week. The hooks themselves hold only the chain (docs/adr/0008).
Say "evalúa tu trabajo" at the end of a task: the agent audits it with references/evaluation.md (versioned with Waymark), citing its own tool calls. A field it declared without a call behind it is reported as a false declaration.
node "$HOME/.agents/skills/waymark/scripts/measure.mjs" --turns 3-5It reads the agent's own session transcript (offline, no model call) and shows, per prompt: the context it started with (its growth is what every later response re-reads), responses, tool calls, images, new vs cached input tokens, output and sub-agent tokens; the fixed context the session started with; and for a range of prompts (one task) the number of attempts.
In Claude Code with a Pro or Max plan, Waymark's status line reads the real % of the 5-hour window and measures each task's % from its first prompt to its close, with no question to you (docs/adr/0019). The window is your account's, so several sessions spend from the same %. Each rise is split among the open sessions by what each one spent, so every terminal shows its own part (5h 41% · esta sesión ≈12% · tokens 5.9M). The tokens are everything the session's tasks used, its subagents and cache included (the sum of their evaluations). The line refreshes every 30 s, so a quiet terminal also sees what the others spent. A task that shared the window closes with medido, con otra sesión activa; esta sesión ≈ X%, prorrateado por costo. The first reading Waymark sees with none before it (a new install), or of a new window read long after the last reset, is a baseline: what the window already held is no session's. Claude's desktop app shows no status line, but its hooks record what each of its sessions spends (from the transcript, at list price), so a rise is split with it too and a terminal shows only its own part. A rise while no Claude Code session spent (claude.ai, Codex, another machine) goes to none of them; while a session also spent, that session takes it. Elsewhere the % is estimated from your measured tasks of the same model.
Three layers keep the agent on track, without an orchestrator: each skill's description (the trigger, with the phrases people actually type), the instructions block (Rule 0: every request runs recall → department → skills → verify → learn; questions run in read-only consult mode), and a tiny per-prompt Rule 0 reminder hook (scripts/rule0-hook.mjs, installed by default where the agent supports hooks). The hook runs locally and adds ~120 tokens per prompt (~60 once the previous reply followed the routine; the task ID and the git status stay). It stops a message only once, before the model, when resuming a very large or idle session would re-write its whole context (docs/adr/0016, 0018); the end-of-turn hook stops a turn once when a routine step is missing. Every reply starts with Waymark → L<n> · <dept>, so you can see at a glance that the routine ran.
"quiero crear un modal" → dept-frontend → brief → ui-build → gates → learn
"nuevo endpoint de pagos" → dept-backend (+ dept-security, dept-qa)
"refactoriza a hexagonal" → dept-architecture (L3: plan + ADR)
"cambia el color del botón" → L0: done directly, no department
| Level | Example | What runs |
|---|---|---|
| L0 | a color, a text, a typo | nothing, done directly |
| L1 | bug in one known file | short Entry · department Quick ref · gates without build |
| L2 | new screen, endpoint, integration | full Entry · department rules and skills · gates + build + review |
| L3 | refactor, migration, new module | L2 + dept-architecture + plan before coding + ADR |
skills/
waymark/ core: triage, Entry/Exit protocols, skill registry, learning loop
SKILL.md (triage, departments, what to read when) · skill-map.json · skill-registry.md (generated)
references/ protocol, project-detection, learning, skills (find / install / create), maintenance
scripts/sync.mjs
stacks/ angular, react, node, nestjs, rails, python, go, java, dotnet, rust, php, terraform, generic
architectures/ screaming, feature-sliced, hexagonal, clean, layered, modular-monolith
templates/ department, stack, architecture, tool skill, project skill, project memory,
instructions.md (block for CLAUDE.md / AGENTS.md), private-layer/
dept-product dept-architecture dept-frontend dept-ux-ui dept-backend
dept-data dept-security dept-qa dept-devops dept-devex ← 10 departments (SKILL.md + procedures.md)
ui-build ui-refine ui-system ui-audit browser-verify library-docs ← own tool skills
adapters/ per-agent paths and MCP registration
INSTALL.md install / update / uninstall, written for the agent
scripts/export.mjs copy your installed (improved) skills back into the repo
.claude-plugin/ optional Claude Code plugin manifest
| Skill | Owns |
|---|---|
dept-product |
requirements, scope, acceptance criteria |
dept-architecture |
structure, layers, boundaries, patterns, ADRs |
dept-frontend |
UI code in any framework |
dept-ux-ui |
visual design, accessibility, motion, design system |
dept-backend |
APIs, services, jobs, realtime, integrations |
dept-data |
schema, migrations, queries, caching, client state |
dept-security |
authn/authz, secrets, OWASP, dependencies |
dept-qa |
tests, verification, review, Definition of Done |
dept-devops |
build, CI/CD, git, environments, deploy |
dept-devex |
agent tooling, Waymark, docs |
When a department needs a capability no installed skill provides, the agent installs a known one (asking first) or creates a new skill with its trigger description, registers it in skill-map.json, adds it to the department's Tools table and uses it. General skills go to the agent's skills folder; project-specific ones into the project.
sync.mjs indexes every skill it can find, not only Waymark's: the agent's own folder, other agents' folders (~/.cursor/skills, ~/.codex/skills, ~/.agents/skills, Gemini, OpenCode), plugins and each project's .claude/, .cursor/, .agents/… skills/. Each one gets a department and a capability from its description and its path in skill-registry.md, so a department can read and follow it even when the agent did not load it. waymark.mjs check reports new or removed skills, and waymark.mjs sync refreshes the registry. The six community skills Waymark replaces are listed as Replaced and never used.
ui-build, ui-refine, ui-system, ui-audit, browser-verify and library-docs are original skills. Each one is owned by a department and starts with a precondition that loads that department first. They grow as you work through patterns/, rules/, facts/ and ## Learned notes.
library-docs routes documentation lookups to the right MCP server: angular-cli for Angular, primeng for PrimeNG and context7 for everything else.
Nothing personal ships in this repository: no stack, no preferences, no projects. Your private layer ~/.waymark/ starts generic and fills itself as you work:
| File | Fills itself when… |
|---|---|
profile.md |
a project of a new stack, package manager or architecture is detected |
projects.md (index) + <project>/.waymark/memory.md |
you work in a project for the first time; it is the project manual (identity, map, gates, conventions), local and never committed. What each task learned goes to engram, saved by the end-of-turn hook on this machine and never committed (docs/adr/0017) |
preferences.md |
you correct how the agent answers or delivers code |
subagents.md |
a search or delegation rule proves wrong or missing |
agent.md |
the installer records where your agent keeps skills and instructions |
coexistence.md |
the installer finds another agent framework (see below) |
The same layer serves every agent, so switching from Claude Code to Codex keeps your memory. Memory has three layers (docs/adr/0015): git holds what was done (commits, trailers, notes), engram what was learned (written by the hooks, shared by every agent on the machine, never committed: docs/adr/0017), and memory.md the project manual.
Waymark is not an orchestrator: an orchestrator decides who does the work, Waymark gives the criteria and the memory the work is done with. So it adapts to whoever arrived first:
| On this machine | Waymark |
|---|---|
| no orchestrator | leads: Rule 0 block, the hooks in every agent, full routine |
| an orchestrator already installed (e.g. gentle-ai) | guest: no hooks, no block; its departments reach the orchestrator through the orchestrator's own skill registry, its memory through engram |
| Waymark first, an orchestrator later | keeps leading; the newcomer's rules are sorted into adopted, fallback (its skills back Waymark up) or resolved, and you are asked once whether Waymark should step down to guest |
You can always pick another mode and move any rule. The other framework's files are never edited (~/.waymark/coexistence.md holds the adaptation), and uninstalling Waymark leaves it exactly as it was.
What the hook learns by itself (docs/adr/0023): at each close it writes into the project memory only what it observed:
- the Quality gates that passed after the last change (dated; a command already written is never replaced);
- the Areas each task touched;
- how many tasks repeated the same procedure.
The rest is proposed, once in the session card and in waymark.mjs check, and written only after your yes:
- a repeated procedure → a project skill inside that project;
- an incident that keeps failing → a Learned rule of the owner department;
- a correction you made in two tasks → your
preferences.md.
What the agent learns: after every L1+ task it keeps only what was new and non-obvious. The lesson goes in the Cierre's Aprendido (the hook saves it to engram and to the task's line in Work in progress), or in exactly one of these places:
| The lesson is about… | It goes to |
|---|---|
| this project | <project>/.waymark/memory.md |
| a stack | stacks/<stack>.md |
| a tool skill | its ## Learned notes |
| a department, in any stack | its ## Learned rules |
| unsure / seen once | ~/.waymark/learnings/dept-<dept>.md (staging) |
When a list grows long, the agent folds it into the skill body, so the skills evolve.
Every design decision is written down in docs/adr, numbered; an accepted one is never edited, it is superseded.
- 0001 · Provenance chain of the agent's work
- 0002 · Waymark is a supply chain of the agent's work
- 0003 · Strict decision gate, evidence from tool calls only
- 0004 · Provenance generated by the hooks, not declared by the agent
- 0005 · Three blocks, everything else recorded and scored
- 0006 · One routine contract
- 0007 · Project memory lives in the project
- 0008 · One agent-agnostic core, a thin adapter per agent, hooks only for the chain
- 0009 · Codex adapter: the rollout as core lines, decisions asked in chat, steps an agent lacks
- 0010 · Every applicable step blocks once; the branch and the browser are the user's
- 0011 · The browser only on request, no secrets in the chain, and turns counted from the last close
- 0012 · Testigos, one decision, git as the source of truth, and a fixed context card (step 3e)
- 0013 · Every agent in the chain, one memory, notes that travel
- 0014 · The final test across agents: notes that travel alone, one ID per commit, Recordar and review in every agent
- 0015 · Three layers of memory, written by the hooks; fewer responses per task
- 0016 · Context brake, one project-skills folder, no-change tasks recorded
- 0017 · The agents' folders stay local, one real copy per skill, fewer extra responses
- 0018 · Dead hooks reported, an idle brake, merges that keep the notes
- 0019 · The quota % measured by the status line
- 0020 · Testigos without false ✔ or false ✘, and a memory chain that travels
- 0021 · Every agent on the machine with one install, Cursor included
- 0022 · Agents as data, and the agents Waymark does not know
- 0023 · The project learns from its records: the hook writes what it observed, the rest is proposed
- 0024 · The context Waymark costs: the protocol by level, a card that asks nothing, a size report that measures it all
- 0025 · The log anchored in git, forget for the removals you ask for, and an Evidencia backed by a check
- 0026 · One classifier for what a command runs, and an open failure when the hook cannot tell
- 0027 · Cost per link, review by risk, procedures by the hook, a chain anyone can verify
Your installed skills get better as you use them. To publish those improvements:
node scripts/export.mjs "$HOME/.agents/skills" --strip-learned
git diff--strip-learned drops personal learned entries; leave it off when the lessons are general. The private layer is never exported.
- Stack: copy
templates/stack.template.md→stacks/<slug>.md, add its detection signal towaymark/SKILL.md§6. - Architecture: copy
templates/architecture.template.md. - Department: copy
templates/department.template.md→skills/dept-<name>/SKILL.md, add it to the core table and tosync.mjs. - Agent: every agent Waymark knows is one entry in
skills/waymark/scripts/agents/agents.json(folder, instructions file, skills folder, hooks, docs). An agent installed later, or one Waymark does not know (a hidden home folder with an instructions file,skills/or hooks), is reported bywaymark.mjs checkand said once in the session card; it gets the pointer block first. Its hooks cost one module inskills/waymark/scripts/agents/fromtemplates/agent-adapter.template.mjs(the exports ofclaude.mjs), itsadapterinagents.jsonandadapters/<agent>.md:dept-devexprocedures → Add an agent (docs/adr/0022).
MIT. The tool skills are original work inspired by the approach of community skills; credits are in skill-map.json → inspiredBy. External skills you vendor later with sync.mjs --vendor keep their upstream license in NOTICE.md.