Add agent-memory-discipline skill and agent-memory plugin

.github/plugin/marketplace.json

@@ -48,6 +48,12 @@
         "ref": "v0.1.3"
       }
     },
+    {
+      "name": "agent-memory",
+      "source": "plugins/agent-memory",
+      "description": "Standing rules that make Copilot actually use long-term memory: when to recall before acting, what is worth saving after a decision or a correction, and how to close a fact that stopped being true instead of deleting it. Backend-neutral, works with repository files or any connected MCP memory server.",
+      "version": "1.0.0"
+    },
     {
       "name": "ai-ready",
       "description": "Analyze any repository and generate AI-ready configuration — AGENTS.md, copilot-instructions.md, CI workflows, issue templates, and more. Mines your PR review patterns and creates files customized to your stack.",

docs/README.plugins.md

@@ -29,6 +29,7 @@ See [CONTRIBUTING.md](../CONTRIBUTING.md#adding-plugins) for guidelines on how t
 | ---- | ----------- | ----- | ---- |
 | [accessibility-kanban](../plugins/accessibility-kanban/README.md) | Kanban board to manage accessibility issues, allow you to plan, track, and complete remediation work. | 1 items | accessibility, github-issues, issue-triage, kanban-board, planning-workflow, status-tracking |
 | [acreadiness-cockpit](../plugins/acreadiness-cockpit/README.md) | Drive Microsoft AgentRC from Copilot chat: assess AI readiness, generate Copilot instructions (flat or nested with applyTo globs for monorepos), and manage policies. Produces a self-contained static HTML dashboard at reports/index.html. | 4 items | agentrc, ai-readiness, copilot-instructions, readiness-report, monorepo, policy, dashboard |
+| [agent-memory](../plugins/agent-memory/README.md) | Standing rules that make Copilot actually use long-term memory: when to recall before acting, what is worth saving after a decision or a correction, and how to close a fact that stopped being true instead of deleting it. Backend-neutral, works with repository files or any connected MCP memory server. | 1 items | memory, context, mcp, persistence, conventions, agent-behavior |
 | [ai-team-orchestration](../plugins/ai-team-orchestration/README.md) | Run a lightweight, role-separated AI development team with flexible tools, developer-selected models, proportionate planning, and optional QA. | 4 items | ai-team, multi-agent, sprint-planning, brainstorm, project-management, orchestration, developer-workflow |
 | [apng-studio](../plugins/apng-studio/README.md) | Interactive GitHub Copilot app canvas extension for building Animated PNG (APNG) files from frames. Draw or upload frames, tune per-frame timing and compositing, preview live, send the result to your phone by QR, and export an animated .png. | 1 items | animated-png, apng, copilot-canvas, frame-animation, image-export, interactive-canvas |
 | [arcade-canvas](../plugins/arcade-canvas/README.md) | Play five retro Phaser mini-games in a Copilot canvas while agents work. | 1 items | arcade-games, copilot-canvas, interactive-canvas, phaser, retro-games, session-breaks |

docs/README.skills.md

@@ -35,6 +35,7 @@ See [CONTRIBUTING.md](../CONTRIBUTING.md#adding-skills) for guidelines on how to
 | [add-educational-comments](../skills/add-educational-comments/SKILL.md)<br />`gh skills install github/awesome-copilot add-educational-comments` | Add educational comments to the file specified, or prompt asking for file to comment if one is not provided. | None |
 | [adobe-illustrator-scripting](../skills/adobe-illustrator-scripting/SKILL.md)<br />`gh skills install github/awesome-copilot adobe-illustrator-scripting` | Write, debug, and optimize Adobe Illustrator automation scripts using ExtendScript (JavaScript/JSX). Use when creating or modifying scripts that manipulate documents, layers, paths, text frames, colors, symbols, artboards, or any Illustrator DOM objects. Covers the complete JavaScript object model, coordinate system, measurement units, export workflows, and scripting best practices. | `references/object-model-quick-reference.md`<br />`scripts/batch-export-png.jsx`<br />`scripts/create-color-grid.jsx`<br />`scripts/find-replace-text.jsx` |
 | [agent-governance](../skills/agent-governance/SKILL.md)<br />`gh skills install github/awesome-copilot agent-governance` | Patterns and techniques for adding governance, safety, and trust controls to AI agent systems. Use this skill when:<br />- Building AI agents that call external tools (APIs, databases, file systems)<br />- Implementing policy-based access controls for agent tool usage<br />- Adding semantic intent classification to detect dangerous prompts<br />- Creating trust scoring systems for multi-agent workflows<br />- Building audit trails for agent actions and decisions<br />- Enforcing rate limits, content filters, or tool restrictions on agents<br />- Working with any agent framework (PydanticAI, CrewAI, OpenAI Agents, LangChain, AutoGen) | None |
+| [agent-memory-discipline](../skills/agent-memory-discipline/SKILL.md)<br />`gh skills install github/awesome-copilot agent-memory-discipline` | Teaches Copilot when to recall from long-term memory before acting and when to save durable decisions, corrections and failures afterwards. Use when an MCP memory server is connected but Copilot is not calling it consistently, when the user says the assistant keeps forgetting conventions or past decisions between sessions, or when setting up persistent memory for a repository. Backend-neutral, working with a folder of Markdown notes, a local MCP memory server, or a hosted one. | None |
 | [agent-owasp-compliance](../skills/agent-owasp-compliance/SKILL.md)<br />`gh skills install github/awesome-copilot agent-owasp-compliance` | Check any AI agent codebase against the OWASP Agentic Security Initiative (ASI) Top 10 risks.<br />Use this skill when:<br />- Evaluating an agent system's security posture before production deployment<br />- Running a compliance check against OWASP ASI 2026 standards<br />- Mapping existing security controls to the 10 agentic risks<br />- Generating a compliance report for security review or audit<br />- Comparing agent framework security features against the standard<br />- Any request like "is my agent OWASP compliant?", "check ASI compliance", or "agentic security audit" | None |
 | [agent-skill-stack](../skills/agent-skill-stack/SKILL.md)<br />`gh skills install github/awesome-copilot agent-skill-stack` | Find, evaluate, and assemble the smallest compatible set of AI Agent Skills for an end-to-end natural-language goal. Use when a user wants Skills for a multi-step workflow, asks which Skills fit a project, needs an installed-Skill audit or conflict check, has low Skill recall, wants indirect helpers such as humanizers or compliance checks, or wants a project-specific Skill Stack with controlled installation. Search local Skills, registries, GitHub, and OpenCLI; compare adoption, verified fit, safety, and overlap. Do not use for locating one known or common Skill; use the generic find-skills workflow. | `agents`<br />`references/discovery-ranking.md`<br />`references/local-index-and-profiles.md`<br />`references/security-installation.md`<br />`references/workflow-model.md`<br />`scripts/inventory_skills.py`<br />`scripts/project_profile.py`<br />`scripts/render_stack_card.py`<br />`scripts/skill_index.py`<br />`scripts/stage_install.py` |
 | [agent-supply-chain](../skills/agent-supply-chain/SKILL.md)<br />`gh skills install github/awesome-copilot agent-supply-chain` | Verify supply chain integrity for AI agent plugins, tools, and dependencies. Use this skill when:<br />- Generating SHA-256 integrity manifests for agent plugins or tool packages<br />- Verifying that installed plugins match their published manifests<br />- Detecting tampered, modified, or untracked files in agent tool directories<br />- Auditing dependency pinning and version policies for agent components<br />- Building provenance chains for agent plugin promotion (dev → staging → production)<br />- Any request like "verify plugin integrity", "generate manifest", "check supply chain", or "sign this plugin" | None |

plugins/agent-memory/README.md

@@ -0,0 +1,28 @@
+# Agent Memory
+
+Connecting a memory tool does not make an agent use it. The tools register, the session runs, and nothing is recalled or saved. This plugin supplies the missing half: the standing rules that turn an available memory tool into a habit.
+
+## What it does
+
+- **Recall before acting** on repository-specific work, and skip the recall on self-contained questions where it would only cost context.
+- **Save after deciding**: decisions that outlive the week, user corrections, approaches that failed and why. One memory, one fact.
+- **Close facts instead of deleting them.** "We use Redux" was true from January to June; deleting it destroys the explanation for the code written in that window.
+- **Surface contradictions** rather than silently returning whichever entry sits closer in embedding space.
+
+## What it does not do
+
+It does not ship a memory backend and does not require any particular one. The rules read the same whether memory is a `memory/` folder in the repository, a local MCP server, or a hosted one. Nothing here fails without a specific vendor.
+
+## How it differs from repository instructions
+
+`.github/copilot-instructions.md` carries stable project rules that a human curates. Memory carries what accumulates during work: decisions, corrections, failures. Instructions are read every session by design; memory has to be asked for, which is exactly why these rules exist.
+
+## Contents
+
+| Skill | Purpose |
+|---|---|
+| `agent-memory-discipline` | When to recall, when to save, how to write an entry that is still useful in three weeks |
+
+## Author
+
+Maintained by the team behind [Mnemoverse](https://mnemoverse.com), a hosted memory service reachable over MCP. The discipline is deliberately backend-neutral and was written to be useful without it.

plugins/agent-memory/plugin.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "agent-memory",
+  "description": "Standing rules that make Copilot actually use long-term memory: when to recall before acting, what is worth saving after a decision or a correction, and how to close a fact that stopped being true instead of deleting it. Backend-neutral, works with repository files or any connected MCP memory server.",
+  "version": "1.0.0",
+  "author": {
+    "name": "Mnemoverse",
+    "url": "https://mnemoverse.com"
+  },
+  "repository": "https://github.com/github/awesome-copilot",
+  "license": "MIT",
+  "keywords": [
+    "memory",
+    "context",
+    "mcp",
+    "persistence",
+    "conventions",
+    "agent-behavior"
+  ],
+  "extensions": {
+    "com.github.awesome-copilot": {
+      "skills": [
+        "./skills/agent-memory-discipline/"
+      ]
+    }
+  }
+}

skills/agent-memory-discipline/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: agent-memory-discipline
+description: "Teaches Copilot when to recall from long-term memory before acting and when to save durable decisions, corrections and failures afterwards. Use when an MCP memory server is connected but Copilot is not calling it consistently, when the user says the assistant keeps forgetting conventions or past decisions between sessions, or when setting up persistent memory for a repository. Backend-neutral, working with a folder of Markdown notes, a local MCP memory server, or a hosted one."
+metadata:
+  author: mnemoverse
+  version: "1.0"
+compatibility: "Backend-neutral. Assumes some memory surface exists, either repository files or a connected MCP memory server. No specific vendor required."
+---
+
+# Agent memory discipline
+
+Connecting a memory tool does not make an agent use it. The tools register, the session runs, and nothing gets recalled or saved. This skill supplies the missing part: standing rules for when to read memory and when to write it.
+
+Everything below is backend-neutral. It works the same whether memory lives in a `memory/` folder in the repository, in a local MCP server, or in a hosted one.
+
+Note the distinction from repository instructions. `.github/copilot-instructions.md` holds **stable project rules** that a human curates. Memory holds **what accumulated during work**: decisions, corrections, failures. Instructions are read every session by design; memory has to be asked for, which is why the rules below exist.
+
+## Recall before acting
+
+Read memory **before** doing any of these, not after:
+
+- starting work on a repository you have touched before
+- choosing a library, pattern, or tool
+- writing tests, commits, or documentation, where conventions apply
+- answering "how do we usually do X here"
+- anything the user phrases as "again", "like last time", or "as we agreed"
+
+Do **not** recall for one-off factual questions, arithmetic, or anything fully specified in the current message. A recall costs a tool call and context budget; spending it on a self-contained question is waste.
+
+Search with the words the user actually used, plus the repository name. If the first search returns nothing useful, try one broader query, then proceed without memory rather than looping.
+
+## Save after deciding
+
+Write to memory when one of these has just happened:
+
+- a **decision** was made that will still matter next week, such as "we use pnpm" or "the billing module stays untouched"
+- the user **corrected** you, which is the strongest signal there is
+- an approach **failed**, and why it failed
+- a preference was stated that applies beyond the current task
+- a fact about the environment was discovered the hard way, such as a port, a flag, or a service that must be running
+
+Do **not** save: the contents of files you can read again, restatements of the current task, transient state, anything the user marked as temporary, and anything containing secrets, tokens, or personal data.
+
+One memory, one fact. A paragraph holding four decisions cannot be superseded cleanly when one of them changes.
+
+## Write it so it survives
+
+A memory that is useless in three weeks was written wrong. Each entry should carry, in the text itself if the backend has no fields for it:
+
+- **what** was decided or observed, in one sentence
+- **why**, briefly, because the reason outlives the decision
+- **when** it became true, and when it stopped being true if it has
+- **where it came from**: a file, a commit, a conversation, a test run
+
+Prefer the user's own words over your paraphrase. Paraphrase drifts.
+
+## Do not overwrite the past, close it
+
+When something changes, the old memory is not wrong. It is **closed**.
+
+If the project moved from Redux to Zustand, "we use Redux" was true from January to June. Deleting it destroys the explanation for every component written in that window. Mark it superseded, keep its validity window, and write the new entry alongside.
+
+This is the single most destructive habit in agent memory, and it stays invisible until someone asks a question about old code.
+
+## Keep contradictions instead of resolving them silently
+
+If a recall returns two entries that disagree, do not pick the closer match and carry on. Surface both, with their dates, and ask or flag.
+
+A convention that a recent failure contradicts is exactly the situation where the user needs to be told, not smoothed over.
+
+## Evidence and policy carry different weight
+
+- **Evidence** is what happened: one run, one failure, one observation. Cheap, plentiful, individually unreliable.
+- **Policy** is what should happen: a convention, a decision, a rule. Expensive to produce, and it should be hard to change by accident.
+
+An observation becomes policy when a human confirms it, when it lands in a merged pull request or decision record, or when it has worked repeatedly. Never promote a single observation to a rule on your own.
+
+## A worked example
+
+The user says: *"stop using npm here, we're on pnpm."*
+
+1. This is a correction, the strongest save signal there is. Save it.
+2. Write: `Repository uses pnpm, not npm. Stated by the user on 2026-08-11 after a lockfile conflict. Applies to every package in this repo.`
+3. Do not also save "the user was annoyed", "I ran npm install", or the lockfile contents.
+4. Next session, before running any package command here, recall first and find it.
+
+## Checklist
+
+Before acting on repository-specific work: **did I recall?**
+
+After a decision, correction, or failure: **did I save it, in one sentence, with its reason?**
+
+When something changed: **did I close the old entry instead of deleting it?**
+
+## Backends
+
+This skill assumes a memory surface exists. Any of these work:
+
+- **Files.** A `memory/` folder of Markdown notes, one fact per file. No dependencies, greppable, versioned in git with the code it describes.
+- **A local MCP memory server.** Keeps everything on your machine. Several open-source options exist.
+- **A hosted memory service over MCP.** Adds portability across tools and machines, at the cost of your data living elsewhere.
+
+The rules above do not change with the choice. What changes is who can read the memory: files are per repository, a local server is per machine, and a hosted one can be shared across the editors and agents one person uses.
+
+---
+
+*Written and maintained by the team behind [Mnemoverse](https://mnemoverse.com), which is one hosted implementation. The discipline above is deliberately backend-neutral and was written to be useful without it.*