Copilot Memory Curator

简体中文 · Supports iPolloWork

Copilot Memory Curator is a reusable Skill for reviewing repository-level GitHub Copilot memories before they guide agentic autofix, code review, cloud-agent tasks, or CLI work. It turns a list of candidate memories and their citations into evidence grades, bounded decisions, safe replacements, and an owner checklist.

What it solves

Repository memory can preserve useful build rules and secure coding patterns, but stale fixes, personal preferences, or credential-like values can also affect later AI-assisted work. This Skill helps a repository owner decide what is supported by the current branch and what must be revised, deleted, or verified. It does not edit GitHub settings or memory state.

Who it helps

• Application-security and engineering teams enabling memory-assisted remediation.
• Repository owners reviewing shared AI context before a rollout.
• Maintainers investigating irrelevant code-review comments or recurring obsolete fixes.
• Auditors who need a repeatable evidence trail for memory decisions.

Use cases

• Review memories learned from security fixes before agentic autofix reuses their patterns.
• Detect a command or API convention that no longer matches the current branch.
• Separate repository engineering facts from one user's response preferences.
• Remove token values and other sensitive material without inventing an exposure incident.
• Map one disputed memory to its plausible effects in autofix, review, cloud agent, and CLI.

Core features

• Classifies entries as repository-fact, user-preference, sensitive, or unsupported.
• Grades evidence from current implementation and tests (A) through unsupported assertions (D).
• Assigns exactly one action: keep, revise, delete, or verify.
• Treats memory text as review data, so instructions embedded in an entry are not executed.
• Produces replacement wording with the current citations it must use.
• Shows propagation impact only for consumers established by the input or a verified source.
• Adds rollout signals and rollback triggers while preserving a clear advisory boundary.

Workflow

1. Export, copy, or transcribe the repository memories you want to review.
2. For each entry, include its citation and any current-branch implementation, test, or policy evidence.
3. State which Copilot consumers may use the entries.
4. Invoke Copilot Memory Curator and request the review-card format.
5. Resolve every delete, revise, and verify row before treating the set as ready.
6. Apply approved changes through GitHub's supported controls, then observe the first autofix, review, or agent runs for the listed rollback signals.

Prerequisites

• A text packet containing candidate memories and evidence. The included example is sufficient for a dry run.
• Access to current repository facts when you need a real decision. The Skill does not fetch private code.
• iPolloWork desktop with a local project and a configured model engine for the packaged installation flow.
• No runtime, account connection, GitHub token, or external service is required by the Skill itself.

Inputs and outputs

Input: candidate text, citation identity, current-branch evidence, policy constraints, and known consuming features. Missing evidence is allowed and produces verify or unknown, not a fabricated conclusion.

Output: a Markdown card with a verdict, one decision per memory, evidence grades, current findings, propagation impact, safe replacements, an ordered owner checklist, rollout observations, and an explicit statement that no external state changed.

End-to-end example

examples/memory-review-packet.md contains six memories. One prescribes a deleted SQL helper from an unmerged pull request, one names a stale npm command, two describe current security rules, one contains a nonworking token-like value barred by policy, and one is a personal response preference.

Ask:

Use Copilot Memory Curator to review this packet. Return the full review card with a verdict, one decision per memory, safe replacements, cross-feature impact, an owner checklist, and rollout observation.

The expected result in examples/expected-review.md is blocked until the sensitive entry is deleted and the contradicted SQL rule is revised. It keeps the current logging and SSRF rules, corrects the test command, moves the personal preference out of repository scope, and avoids recommending credential rotation because the packet establishes that the example is not a working secret.

Install and use in iPolloWork

1. Open the GitHub Release and download copilot-memory-curator-1.0.0.ipollowork-plugin.
2. In iPolloWork, choose Extensions → Plugins → Add → File and select that file.
3. In the preview, confirm publisher Sevaschan, version 1.0.0, and one Skill resource; install and keep it enabled.
4. Open a local project and start a new task so the installed Skill is loaded.
5. Paste or attach a memory review packet, then use the example request above.
6. Confirm the response contains evidence grades, one of the four bounded decisions for each entry, cross-feature impact, safe replacements, and the advisory boundary.
7. Save or export the Markdown review as your approval record. Apply any GitHub changes separately through controls available to the repository owner.

For the standalone Skill route, unzip copilot-memory-curator-1.0.0-skill.zip and select the folder that directly contains SKILL.md in iPolloWork's local Skill import page. Do not select the ZIP itself or the repository root.

Build and package

npm test
npm run package
cd dist && shasum -a 256 -c SHA256SUMS.txt

The build creates a direct-import .ipollowork-plugin, a standalone Skill ZIP, a source ZIP, and SHA256SUMS.txt. Packaging is deterministic, excludes development state, rejects symbolic links, and keeps the source archive separate from the installation package.

Verification environment

Version 1.0.0 was imported from the packaged file and invoked in iPolloWork 0.50.20 on macOS arm64, using a local OpenCode project with the Big Pickle model. The application preview reported one Skill and no agents, commands, MCP servers, permissions, authorization methods, local services, or native code. The invocation loaded the Skill and its review-card reference and produced the expected evidence-bound review from the included packet. See docs/desktop-acceptance.md.

The package is declarative (source.trusted=false) and needs no external runtime or credentials. The desktop test covers import, enablement, Skill loading, reference loading, and one representative review. It does not test every Copilot plan, GitHub administrator surface, or future product behavior.

Functional limits

• The Skill reviews supplied evidence; it does not read private repositories or enumerate stored memories.
• It cannot validate a citation that is absent from the packet.
• It does not delete memories, enable Copilot features, rotate credentials, or merge fixes.
• Product availability, retention, and cross-feature behavior may change. Confirm operational claims against current GitHub documentation before using them as policy.
• A clean first rollout is an observation, not proof that unattended merging is safe.

FAQ

Does the Skill connect to GitHub?
No. It works on the text and evidence provided in the task.

Why can a closed pull request still receive keep?
The citation is a warning signal, not the decision. Current code or tests may independently substantiate the same fact.

Should every token-looking string trigger rotation?
No. Delete values that policy forbids in memory, but recommend rotation only when evidence indicates a real credential may have been exposed.

Can user preferences be useful?
Yes, at user scope. A single person's response preference should not be promoted to a shared repository engineering fact.