Manage project memories - constraints, decisions, conventions with conflict detection and resolution
Manages project-wide memory in `.taskmanager/memories.json` to capture constraints, decisions, and conventions. Automatically detects and resolves conflicts between stored memories and current codebase, tracking usage to surface important knowledge.
/plugin marketplace add mwguerra/claude-code-plugins/plugin install docs-specialist@mwguerra-marketplaceThis skill is limited to using the following tools:
You manage the project-wide memory for this repository.
Your goal is to:
.taskmanager/memories.json valid, structured, and consistent with its JSON Schema.Always work relative to the project root.
.taskmanager/memories.jsonYou MAY read the JSON Schema:
.taskmanager/schemas/memories.schema.jsonDo not delete or rename any .taskmanager files.
.taskmanager/memories.json is a JSON document with:
version – semantic version of the memory file format.project – object with id, name, optional description.memories – array of memory entries.Each memory entry has (see schema for exact types):
id – stable ID, e.g. "M-0001".title – short summary (<= 140 chars).kind – one of: constraint, decision, bugfix, workaround,
convention, architecture, process, integration, anti-pattern, other.whyImportant – concise explanation of why this memory matters.body – detailed description / rationale / examples.tags – free-form tags, e.g. ["testing", "laravel", "pest"].scope – object describing where this applies:
project – project ID or name.files – paths/globs, e.g. ["app/", "tests/Feature/"].tasks – task IDs like "1", "2.3", "4.1.2".commands – names/paths of commands this is relevant to.agents – names of agents this is relevant to.domains – conceptual areas, e.g. ["testing", "architecture"].source – object describing who set this:
type – "user" | "agent" | "command" | "hook" | "other".name – human/agent/command identifier.via – free-text, e.g. "cli", "tests/run-test-suite".importance – integer 1–5 (how critical).confidence – float 0–1 (how sure we are).status – "active" | "deprecated" | "superseded" | "draft".supersededBy – optional ID of newer memory.links – optional links to docs/PRs/etc.createdAt, updatedAt, lastUsedAt – ISO timestamps.useCount – integer usage counter.autoUpdatable – boolean indicating if system can update without user approval (derived from source.type != "user").lastConflictAt – ISO timestamp of the last detected conflict (or null).conflictResolutions – array of conflict resolution history entries.You MUST keep the file consistent with the MWGuerraTaskManagerMemories JSON Schema.
When you start working:
Read to load .taskmanager/memories.json if it exists.versionproject (with plausible id/name from context)memories array..taskmanager/schemas/memories.schema.json as the contract:
useCount → set to 0).If you cannot make the JSON valid without guessing, prefer to explain the inconsistency in comments/logs rather than silently discarding data.
Given a natural-language description of the current work (files, task IDs, domains):
domains (e.g. testing, performance, security, architecture).files / directories.memories to those where:
status = "active", andscope.domains with inferred domainsscope.files with affected files/dirsscope.tasks with relevant task IDstags with inferred keywords.importance.useCount.lastUsedAt.id, title, kind, whyImportant.You should never dump the entire memory file into context unless explicitly asked; always select the smallest relevant subset.
When a user or another skill makes a decision that should persist for future work:
kind + overlapping tags/scope).M-0001, M-0002, …) without reusing IDs.title, kind, whyImportant, body.tags and scope.source (type, name, via if known).importance and confidence (default importance 3, confidence 0.8+).status = "active" (or "draft" if still tentative).createdAt and updatedAt set to current time.lastUsedAt = null, useCount = 0.memories array and write the file back.When in doubt whether something deserves a memory, ask: “Will this decision/convention matter for future tasks?” If yes, create a memory.
When an existing memory is refined or corrected:
body, tags, scope, etc.).updatedAt.status = "superseded" or "deprecated".supersededBy = "<new-id>".Never silently rewrite history in a way that hides past decisions.
Whenever a memory directly influences planning or execution:
id.useCount (e.g., useCount += 1).lastUsedAt to current ISO timestamp.This allows future tools to treat highly-used, high-importance memories as more trustworthy.
When planning or executing non-trivial work (new features, refactors, risky changes):
This way, .taskmanager/memories.json becomes the single, durable "project brain" that all agents/commands/skills can rely on.
Task-scoped memories are temporary memories that live only for the duration of a single task. They are stored in .taskmanager/state.json under the taskMemory array.
When a user provides --task-memory "description" or -tm "description" to a command:
.taskmanager/state.json.{
"content": "<the description>",
"addedAt": "<current ISO timestamp>",
"taskId": "<current task ID>",
"source": "user"
}
state.json.taskMemory[].state.json back.System-generated task memories use "source": "system".
Before executing a task:
state.json.taskMemory[].taskId matches the current task or is "*" (applies to all tasks).At task completion (before marking "done"):
Check if any task memories exist for this task.
If task memories exist, use AskUserQuestion to ask:
"The following task memories were used during this task. Should any be promoted to global (persistent) memory?"
Options for each memory:
For promoted memories:
memories.json with appropriate kind, tags, scope.source.type = "user" if originally from user, or "agent" if from system.Clear the task memories for this task from state.json.taskMemory[].
Conflict detection runs automatically at the start and end of every task execution.
For each active memory that was loaded for this task:
File/Pattern Obsolescence Check:
scope.files is defined:
Glob to check if referenced files/directories still exist.Implementation Divergence Check:
memory.body for specific implementation requirements.tsconfig.json has strict: false.Test Failure Check:
scope.domains includes testing-related domains:
Classify conflicts by severity:
importance >= 4 has a divergence conflict.importance < 4 has any conflict.When a conflict is detected, the resolution process depends on the memory's ownership.
source.type == "user")NEVER auto-update. ALWAYS ask the user.
Use AskUserQuestion with options:
"Keep memory as-is"
conflictResolutions[] with resolution: "kept"."Update memory to reflect current state"
body, tags, or scope to match current implementation.updatedAt.conflictResolutions[] with resolution: "modified"."Deprecate this memory"
status = "deprecated".updatedAt.conflictResolutions[] with resolution: "deprecated"."Supersede with new memory"
status = "superseded" and supersededBy = "<new-id>".conflictResolutions[] with resolution: "superseded".source.type != "user")For system-created memories (source.type is "agent", "command", "hook", or "other"):
Refinements (small updates that don't reverse the decision):
body, bump updatedAt.conflictResolutions[] with resolution: "modified".Reversals (substantial change or contradiction):
AskUserQuestion with same options as 8.1.Every conflict resolution MUST be recorded in the memory's conflictResolutions[] array:
{
"timestamp": "<ISO timestamp>",
"resolution": "kept" | "modified" | "deprecated" | "superseded",
"reason": "<brief explanation>",
"taskId": "<task ID where conflict was detected>"
}
Also update lastConflictAt to the current timestamp.
During autonomous task execution (/run-tasks):
If a critical conflict is detected:
If a warning or info conflict is detected:
autoUpdatableWhen creating a memory, set autoUpdatable based on source.type:
autoUpdatable = (source.type != "user")
source.type == "user" → autoUpdatable = falsesource.type == "agent" | "command" | "hook" | "other" → autoUpdatable = true| Source Type | Small Update | Substantial Change |
|---|---|---|
user | Ask user | Ask user |
agent | Auto-update | Ask user |
command | Auto-update | Ask user |
hook | Auto-update | Ask user |
other | Auto-update | Ask user |
Memories are never deleted. They are either:
"active""deprecated" (no longer relevant)"superseded" with a pointer to the new memoryThis preserves decision history and audit trail.
This skill MUST write to the log files under .taskmanager/logs/ for all memory operations.
errors.log — ALWAYS append when:
Example:
2025-12-11T10:00:00Z [ERROR] [sess-abc123] Failed to parse memories.json: invalid JSON
2025-12-11T10:00:01Z [ERROR] [sess-abc123] Conflict: M-0001 references deleted file app/OldAuth.php
2025-12-11T10:00:02Z [ERROR] [sess-abc123] Memory M-9999 not found when attempting update
decisions.log — ALWAYS append when:
Example:
2025-12-11T10:00:00Z [DECISION] [sess-abc123] Created memory M-0005: "Always validate API inputs"
2025-12-11T10:00:01Z [DECISION] [sess-abc123] Applied memories to task 1.2: M-0001, M-0003, M-0005
2025-12-11T10:00:02Z [DECISION] [sess-abc123] Conflict resolved for M-0001: kept (user decision)
2025-12-11T10:05:00Z [DECISION] [sess-abc123] Deprecated M-0002: "No longer using old auth pattern"
2025-12-11T10:05:01Z [DECISION] [sess-abc123] Promoted task memory to global: M-0006
debug.log — ONLY append when state.json.logging.debugEnabled == true:
Example:
2025-12-11T10:00:00Z [DEBUG] [sess-abc123] Querying memories for task 1.2.3 (domain: auth)
2025-12-11T10:00:01Z [DEBUG] [sess-abc123] Checking 8 active memories for relevance
2025-12-11T10:00:02Z [DEBUG] [sess-abc123] M-0001: matched by scope.domains (contains "auth")
2025-12-11T10:00:03Z [DEBUG] [sess-abc123] M-0002: skipped (importance 2 < threshold 3)
2025-12-11T10:00:04Z [DEBUG] [sess-abc123] Conflict detection: checking file existence for M-0003.scope.files
2025-12-11T10:00:05Z [DEBUG] [sess-abc123] File check: app/Services/Auth.php EXISTS
When running conflict detection, log:
Start of detection (DEBUG):
[DEBUG] Starting conflict detection for N active memories
Per-memory checks (DEBUG):
[DEBUG] Checking M-XXXX for conflicts...
[DEBUG] - File check: <path> EXISTS/MISSING
[DEBUG] - Implementation check: <result>
Conflicts found (ERROR):
[ERROR] Conflict: M-XXXX - <conflict description>
Resolution outcome (DECISION):
[DECISION] Conflict resolved for M-XXXX: <resolution> (<reason>)
This skill reads state.json.logging.debugEnabled to determine whether to write debug logs.
debugEnabled == true: Write verbose DEBUG entries to debug.logdebugEnabled == false: Skip DEBUG entries, only write ERROR and DECISIONThe calling command is responsible for setting debugEnabled based on --debug flag.
Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.