agentsclimarketplace

Learn

Skill HomericIntelligence/Athena/skills/learn

Preserve a verified Mnemosyne lesson without a duplicate. Store prior versions in `.history` and evidence in `.notes.md`. Discovery requires a usable checkout. Read-only work can use a stale checkout. A new pull request requires an isolated worktree from a synchronized current default-branch base. An existing pull request uses only its bound head. Otherwise, report without changes.From its SKILL.md

Install
npx -y skills add HomericIntelligence/Athena --skill learn

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

  • 2 stars2 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its file declares

Copied from the file, not written here

The file declares its own license as BSD-3-Clause. That is the author’s claim about this one file, and it is not the same thing as the license GitHub reports for the repository, which is listed with the other numbers below.

SKILL.md

18.1 KB, as published. Nobody here has run it

Learn

Purpose: Preserve one concise general rule. Do not preserve many copies that apply to only one session. First, determine if the source contains a verified change that can help future work. Then put current guidance, history, and supporting notes in their specified artifacts. If the user requests a write, deliver it through a pull request (PR) from an isolated worktree.

Apply the ASD-STE100 technical-English policy to this skill and to all prose that it produces.

Engineering principles

Use the canonical engineering-principles catalog through these workflow-specific rules:

Prepare the knowledge repository

Use the canonical dependency-resolution contract to prepare Mnemosyne at $HOME/.agent_brain/knowledge. Report the resolved repository, commit identifier, and trust basis. Before discovery or a write, require a usable knowledge checkout. Normal preparation can create the checkout under the dependency-resolution contract. If checkout or inspection fails, stop learn. During read-only discovery, you can delay upstream resolution, authentication, update, and revalidation. At the delivery boundary, you must complete these actions.

Use read-only discovery

Require the existing checkout. Do not require upstream resolution, fetch, fast-forward, or automatic-fork revalidation. Bind discovery to the current HEAD. Use the checked-out content as a best effort. Report these items:

  • repository;
  • revision;
  • origin and trust status; and
  • each freshness or verification limit.

If no usable checkout exists or inspection fails, report blocked. In that case, stop. Do not substitute a different repository. Do not continue to analyze possible duplicates.

Before you create a new PR, complete the normal dependency-resolution update and revalidation. Use the canonical default branch. Bind the delivery worktree to that exact current commit identifier. Planning and read-only discovery can use a stale checkout. PR delivery cannot use a stale checkout.

Decide before you write

This phase is read-only.

The steps below require the existing checkout. In read-only discovery, if the required checkout is not available, do not select a durable write disposition. Stop.

  1. Run advise with the proposed lesson and its planning-mode best-effort behavior.
  2. Define retrieval intent by the trigger, context, desired outcome, constraints, and failure mode.
  3. Do not use a title, issue number, or session wording as identity.
  4. Resolve the installed advise/scripts/list_retrievable_skills.py helper.
  5. Run the helper by its absolute path against the knowledge checkout.
  6. If the selector is missing or fails, report blocked.
  7. If the selector is missing or fails, stop.
  8. Do not replace the selector with a custom file-pattern search. A replacement can change the retrieval boundary.
  9. Group only the returned main-skill paths by intent.
  10. Inspect each selected candidate, its .history, its applicable .notes.md, and Git history.
  11. Use this inspection to find provenance and prior consolidation.
  12. Enumerate the changed flat skills/*.md artifacts in each open PR in the resolved Mnemosyne repository.
  13. Derive intent from the changed content.
  14. Do not use a title or path as sufficient duplicate evidence. A title or path can identify a candidate.
  15. Before a write, record exactly one disposition.

The available dispositions are:

DispositionUse whenAction
amendOne canonical entry has a material verified change.Update that canonical artifact set only.
consolidateTwo or more current entries share intent.Select one canonical artifact set. Merge all rules that were not superseded. Retire duplicates in the same PR.
createIntent is materially distinct.Add one precisely named artifact set.
rejectNo verified change remains useful after this session.Report no learnable change; leave Mnemosyne unchanged.
blockedA blocking condition applies.Leave Mnemosyne unchanged and request direction.

Select blocked if one of these conditions applies:

  • provenance is uncertain;
  • more than one open PR targets the selected canonical entry;
  • the selected PR is not safe to write; or
  • retirement is unsafe.

Do not create a near-duplicate to avoid a blocked consolidation. If exactly one open PR changes the selected canonical entry, use that PR as the delivery target. Enter Existing-PR mode. Add the verified change to that PR. Do not create a competing PR. If multiple open PRs target the entry, stop. Do not guess. Do not report learn complete after reject or blocked.

Use repo-review for repository audits. Use pr-review for PR audits. Select the review depth for the active mode.

Keep retrieval bounded

Store each lesson in three artifact types. Do not use the main skill as an append-only record.

ArtifactContainsExcludes
skills/<name>.mdCurrent general triggers, decision rules, workflow, failures, parameters, and zero to three short examples. Each example must materially change a decision.Prior versions, changelog text, session history, transcripts, and repeated project cases.
skills/<name>.historySuperseded main-skill versions and append-only records for version, change, and provenance.Active instructions that exist only in this file.
skills/<name>.notes.mdSource details that pass privacy checks, long examples, commands, measurements, verification reports, and useful supporting evidence.Rules that the skill requires for operation.

For each amendment, rewrite the main entry around the smallest reusable change. Do not append the session. Merge overlapping rules. Remove superseded guidance. Keep no more than three examples. Each example must show a materially different decision branch. It must be shorter than the rule that it shows. A repository name, issue narrative, transcript, or another instance of an established pattern is evidence. It is not a new main-skill example.

If .history does not contain the version, archive the complete prior retrievable content before you replace the main entry. Add the new version and provenance record to .history. Put useful detailed evidence for the current rule in .notes.md. Do not move prohibited sensitive content to another artifact.

Keep only the schema-required current version identifier in the main-file frontmatter. Put prior versions, change summaries, provenance, and other version-control information in .history. Obey the main-skill size limit of the resolved repository. For Mnemosyne, a new or changed retrievable main file must not be more than 30,000 bytes. Keep notes and history outside normal retrieval.

Protect private and proprietary information

Assume that the session, its repositories, and all discovery output are sensitive. Store only the general pattern, decision rule, and evidence that is safe to share. Do not store the following items in a main skill, notes, history, filename, frontmatter, example, commit, or PR description:

  • personally identifiable information (PII) or identifiers that can identify a person, account, customer, or organization;
  • product, project, customer, vendor, or organization names and other non-public identifiers;
  • internal paths, hostnames, URLs, repository names, issue IDs, environment names, or infrastructure details;
  • proprietary source, configuration, prompts, logs, data, metrics, or operational details; or
  • secrets, credentials, tokens, or other access material.

Replace sensitive details with a correct general pattern. For example, use "an isolated checkout" instead of a local path. If public information gives an equivalent example, cite or describe it. Do not copy internal evidence. Do not invent an equivalent public example, a result, or verification evidence. If the lesson is not useful without sensitive or proprietary information, select reject. Leave Mnemosyne unchanged. Report that no safe learnable change exists.

If a lesson requires Athena implementation, complete the normal development first. Follow development.md. Keep helpers in skills/<name>/scripts/. Add behavior-based executable tests under tests/unit/. Do not add inline executable Markdown, wording tests, or artifacts that have no consumer only to support a lesson.

Scope

Read-only discovery does not increase the requested scope. If the task requests durable learning, you can use the resolved repository and full delivery path. Use a new PR or the single Existing-PR target that discovery selected. A recommendation or indirect invocation is read-only. For read-only work, return the proposed repository, base, branch, files, and PR target.

Use an existing PR

Use this mode if discovery identifies exactly one open PR that changes the selected canonical entry. Before you edit, fetch these identity fields again. Bind the work to these values:

  • canonical repository;
  • URL and number;
  • OPEN state;
  • source repository and ref; and
  • head object ID (OID).

Create an isolated worktree on that source ref at the bound head OID. Verify its HEAD. Do not change the shared checkout or default branch.

Immediately before publication, fetch the same identity and head again. Push only to the bound PR source ref. Use lease protection that binds the push to the expected head. If the ref moves, the source repository is not safe to write, or a binding is different, preserve the worktree. Then stop. Do not create a branch. Do not open another PR. Do not change the target of the work. Use the disposition-specific write allowlist below.

Coordinate safely

If the host supports parallel work, divide independent discovery, overlap analysis, draft work, and verification into bounded work items. Otherwise, do the work in sequence. Use the same evidence requirements. New-PR writers must use isolated worktrees from the same resolved default-branch commit identifier. Existing-PR writers must use only the bound PR head. Give writers ownership that does not overlap. Read-only work items must not edit. The coordinator must do these tasks:

  • own each canonical entry or assign one integration owner;
  • reject unrelated edits;
  • run focused validation after each integration;
  • run all applicable validation after the combined result.

Only the coordinator can commit, push, and open a new PR when applicable.

If ownership overlaps, the base changes, or the scope is not expected, stop.

If native isolation is not available, use the installed ../git-worktrees/scripts/prepare_worktree.py by its absolute path only for new-PR work. Keep the resolved checkout as the current directory. Use these exact values:

  • branch skill/<slug>;
  • --path $HOME/.agent_brain/worktrees/knowledge-<slug>;
  • --path-root $HOME/.agent_brain/worktrees; and
  • --start-point <resolved-default-SHA>.

Do not use this fallback to reconstruct an Existing-PR worktree.

Deliver a requested change

  1. Do not change the shared checkout.

  2. Before you create a new-PR worktree, complete the delayed dependency-resolution update.

  3. Bind the worktree to the exact current default-branch commit identifier.

  4. Derive slug and name from lowercase letters a through z, digits, and single hyphens with the pattern [a-z0-9][a-z0-9-]*.

  5. Reject these values:

    • an empty value;
    • a control character;
    • /;
    • ..; or
    • a value that starts with -.
  6. If necessary, add a suffix that prevents a collision.

  7. For new-PR work, before creation, resolve $HOME/.agent_brain/worktrees/knowledge-<slug>.

  8. Require the path to be directly below $HOME/.agent_brain/worktrees.

  9. Reject each parent or destination that is a symbolic link.

  10. For new-PR work, create skill/<slug> at $HOME/.agent_brain/worktrees/knowledge-<slug> from the resolved default-branch commit identifier.

  11. Use this path for new-PR create and consolidate work.

  12. Do not use this path for Existing-PR mode.

  13. Before you edit, make a complete list of exact repository-relative paths that this operation can write.

  14. Include only the paths that the selected disposition permits:

DispositionAllowed paths
amendThe canonical .md, its .history, and its .notes.md if supporting detail exists.
createOne new .md, its initial .history, and its .notes.md if supporting detail exists.
consolidateThe three canonical artifacts, each named duplicate for retirement, and each verified active consumer that must migrate.
  1. Name each companion and retirement in the list.

  2. Do not add write paths after an edit starts.

  3. For create, read the resolved Mnemosyne template, schema, and validation rules before you make a draft.

  4. For create, use each required frontmatter field. These fields include name, description, category, date, and the current version.

  5. For create, use the required section structure.

  6. For create, keep searchable intent, generalized use, workflow, applicable failed approaches, and parameters in the main entry.

  7. For create, make the initial version-and-provenance record in .history.

  8. For create, put useful supporting details in .notes.md.

  9. Apply the selected disposition only to paths in its allowlist.

  10. For amend or consolidate, archive each superseded canonical version before you rewrite the main entry.

  11. Except for the required historical snapshot, do not copy content between artifact types.

  12. Give current rules, history records, and notes evidence one owner each.

  13. During consolidation, migrate verified active consumers.

  14. After the consumer migration, retire each named duplicate.

  15. Before you commit, review each proposed artifact and delivery text against the private and proprietary information rules.

  16. Remove or generalize sensitive details.

  17. Use a correct public equivalent only if one exists.

  18. If safe generalization is not possible, reject the lesson.

  19. Run all applicable Mnemosyne validation.

  20. Verify these conditions:

    • exactly one active entry remains for the intent;
    • its main file is in the configured size limit;
    • notes and history are not in normal retrieval;
    • there is no duplicate intent;
    • there is no version history in the main entry; and
    • there is no stale consolidated name.
  21. Create a signed commit with a Developer Certificate of Origin (DCO) attestation.

  22. For a new PR, push the feature branch.

  23. For a new PR, open a PR against the resolved default branch.

  24. For Existing-PR mode, push only to the bound source ref.

  25. For Existing-PR mode, do not open another PR.

  26. Do not merge automatically.

  27. Report these items:

    • disposition;
    • bound or new PR URL;
    • main-file byte size;
    • archived version;
    • companion files;
    • retired entries, if any; and
    • exact validation evidence.

A write disposition succeeds only if it has a PR URL. If validation, push, or PR creation fails, preserve the isolated worktree. In that case, report the blocker. Do not use Athena, a default branch, or a different repository as a fallback. Preserve delegated and delivery worktrees until their unique work is integrated or explicitly rejected.

Cleanup is a separate operation. Remove only a worktree that this invocation created. Require user authority for the removal. Before removal, confirm that no uncommitted or unintegrated state remains. If these conditions are not satisfied, leave each applicable worktree intact. For each worktree, report its path, owner, revision, cleanliness, and integration state. Do not delete branches. Do not discard changes. Do not force removal. Do not change a pre-existing worktree.

Failed approaches

  • If delivery requires a synchronized default-branch base, do not write from an unsynchronized checkout.
  • Do not bypass the private and proprietary information rules. Do not invent a public equivalent if safe generalization is not possible.
  • Do not put prior versions in the main entry. Archive them in .history.
  • If an open PR targets the selected canonical entry, do not create a competing PR.

Keep looking

Skills are one crate of 609,689. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.