{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-othmanadi--planning-with-files","slug":"othmanadi--planning-with-files","name":"planning-with-files","type":"skill","url":"https://github.com/OthmanAdi/planning-with-files","page_url":"https://unfragile.ai/othmanadi--planning-with-files","categories":["automation"],"tags":["adal","agent-skills","antigravity","claude","claude-code","claude-skills","copilot","copilot-skills","hermes","hermes-agent","hermes-skill","kilocode","manus","mastra","openclaw","openclaw-skills","pi","pi-agent","planning"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-othmanadi--planning-with-files__cap_0","uri":"capability://memory.knowledge.persistent.markdown.working.memory.system","name":"persistent-markdown-working-memory-system","description":"Implements a three-file markdown-based external memory system (task_plan.md, findings.md, progress.md) that persists across AI agent context window resets and session boundaries. The system treats the filesystem as non-volatile disk storage analogous to RAM, automatically serializing agent state, decisions, and discoveries to markdown files that survive /clear commands and context loss. Each file serves a distinct purpose: task_plan.md tracks phases and decisions, findings.md captures research and technical decisions, progress.md logs session history and test results.","intents":["Preserve agent state and context across multiple chat sessions without losing work","Maintain a persistent audit trail of decisions, errors, and discoveries for complex multi-phase projects","Enable agents to recover from context window resets and resume work from the last known state","Track goal drift and prevent agents from wandering off-task after 50+ tool calls"],"best_for":["AI agent developers building persistent coding assistants","Teams implementing Manus-style agentic workflows","Projects requiring multi-session context preservation across Claude Code, Cursor, or Continue IDEs","Complex tasks with 50+ steps where context window volatility causes failure"],"limitations":["Requires manual file initialization and adherence to markdown schema — no automatic schema validation","Markdown parsing is text-based; no structured query interface for findings or progress logs","File size grows unbounded with session history; no built-in archival or log rotation","Depends on agent discipline to read files before deciding — no enforcement mechanism","Git checkpoint workflow requires manual commit discipline; no automatic state snapshots"],"requires":["Python 3.8+ (for helper scripts)","Git repository initialized in project directory","Write access to project filesystem for markdown file creation","Claude Code, Cursor, Continue IDE, or compatible agent platform","Manual setup of three markdown files in project root"],"input_types":["markdown files (task_plan.md, findings.md, progress.md)","agent task descriptions","research notes and technical decisions","session logs and test results"],"output_types":["markdown files with structured sections","phase completion status","decision logs with timestamps","error recovery records"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_1","uri":"capability://memory.knowledge.three.file.schema.based.state.tracking","name":"three-file-schema-based-state-tracking","description":"Enforces a structured markdown schema across three files with specific sections and update frequencies: task_plan.md tracks phases, decisions, and error logs (updated after phase completion); findings.md captures research discoveries and technical decisions (updated every 2 view/browser operations); progress.md logs session history and test results (updated throughout session). Each file has a defined structure with headers, status indicators, and timestamp tracking, creating a queryable state representation that agents can read before deciding on next actions.","intents":["Establish a canonical source of truth for project state that agents can query before taking actions","Track which phases are complete, in-progress, or blocked with explicit status indicators","Maintain a searchable log of all technical decisions and their rationale","Enable error recovery by recording what failed and why, preventing repeated mistakes"],"best_for":["Teams standardizing on Manus-style agent workflows across multiple projects","Projects requiring audit trails of agent decisions for compliance or debugging","Multi-agent systems where agents need to coordinate via shared markdown state","Long-running projects (100+ steps) where state fragmentation causes failures"],"limitations":["Schema is convention-based, not enforced — agents can write malformed markdown","No built-in validation that files conform to specification","Update frequency rules (e.g., 'every 2 view operations') are agent-dependent, not automated","No conflict resolution for concurrent writes from multiple agents","Markdown parsing requires custom logic; no standard library support for this schema"],"requires":["Understanding of task_plan.md, findings.md, and progress.md specifications","Agent platform that supports file read/write operations","Manual discipline to follow update frequency rules","Helper scripts for file initialization (provided in repository)"],"input_types":["phase descriptions","decision rationale","research findings","test results and error messages"],"output_types":["markdown sections with status indicators","timestamped decision logs","phase completion records","error recovery documentation"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_10","uri":"capability://planning.reasoning.phase.based.task.decomposition.and.tracking","name":"phase-based-task-decomposition-and-tracking","description":"Decomposes complex tasks into explicit phases tracked in task_plan.md with status indicators (not-started, in-progress, complete, blocked). Each phase has a clear objective, success criteria, and dependencies on prior phases. The system uses phase boundaries to scope context windows, create git checkpoints, and trigger state updates. Agents read the current phase from task_plan.md before deciding on actions, ensuring work stays focused on the current phase rather than drifting across multiple objectives. Phase completion triggers automatic updates to task_plan.md and can trigger git commits, creating explicit checkpoints in the project history.","intents":["Decompose complex tasks into manageable phases with explicit success criteria","Track phase status and prevent agents from jumping between phases or drifting off-task","Create natural checkpoint boundaries for git commits and state snapshots","Enable agents to understand task structure and current progress at a glance"],"best_for":["Complex multi-phase projects (5+ phases) where task decomposition is critical","Projects where agents tend to drift off-task or jump between objectives","Teams requiring explicit progress tracking and phase-based checkpoints","Tasks with clear phase dependencies where out-of-order execution causes failures"],"limitations":["Phase decomposition is manual; no automated task analysis to identify phases","Phase boundaries are subjective; different decompositions may be equally valid","Agents may not respect phase boundaries; no enforcement mechanism","Phase dependencies are implicit in task_plan.md; no explicit dependency tracking","Changing phase structure mid-project requires manual updates to task_plan.md"],"requires":["Clear task decomposition into phases before starting","task_plan.md with phase definitions and status tracking","Agent discipline to read current phase before deciding on actions","Clear success criteria for each phase"],"input_types":["task description and objectives","phase definitions with success criteria","phase dependencies and ordering","current phase status"],"output_types":["phase status indicators (not-started, in-progress, complete, blocked)","phase completion records with timestamps","git commits at phase boundaries","progress tracking across phases"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_11","uri":"capability://memory.knowledge.findings.discovery.and.technical.decision.logging","name":"findings-discovery-and-technical-decision-logging","description":"Maintains findings.md as a searchable reference of research discoveries, technical decisions, and their rationale. Agents update findings.md after every 2 view/browser operations or significant discoveries, recording: what was discovered, why it matters, what decision was made, and what alternatives were considered. This creates a queryable knowledge base that agents can reference before making similar decisions, avoiding redundant research and enabling consistent decision-making across sessions. Findings are organized by topic or decision category, making them searchable without requiring full file reads. The pattern enables agents to build institutional knowledge that persists across sessions and can be shared with other agents.","intents":["Build a persistent knowledge base of discoveries and decisions that survives session resets","Enable agents to reference prior research and decisions before making similar choices","Avoid redundant research by maintaining a searchable findings database","Enable knowledge sharing between agents working on the same project"],"best_for":["Research-heavy projects where agents need to reference prior discoveries","Projects with many technical decisions where consistency is important","Teams with multiple agents working on the same codebase","Long-running projects where institutional knowledge accumulates"],"limitations":["Findings logging is manual; agents must decide what's worth recording","Update frequency (every 2 view operations) is heuristic; optimal frequency varies","No automated deduplication; similar findings may be recorded multiple times","Findings are unstructured markdown; no schema validation or consistency checking","Searching findings requires manual scanning; no full-text search capability"],"requires":["findings.md file initialized and maintained throughout project","Agent discipline to log discoveries and decisions regularly","Clear organization scheme for findings (by topic, decision type, etc.)","Understanding of what constitutes a 'finding' worth recording"],"input_types":["research discoveries and findings","technical decisions and rationale","alternatives considered and rejected","design decisions and trade-offs"],"output_types":["findings entries with discovery descriptions","decision logs with rationale and alternatives","organized findings by topic or category","searchable knowledge base"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_12","uri":"capability://memory.knowledge.progress.logging.and.session.history.tracking","name":"progress-logging-and-session-history-tracking","description":"Maintains progress.md as a session log that records all actions taken, test results, and session history throughout the agent's work. Entries are timestamped and include: what action was taken, what the result was, what was learned, and what comes next. Progress.md grows throughout the session and serves as a detailed audit trail of everything the agent did. Unlike task_plan.md (which tracks phases) and findings.md (which tracks discoveries), progress.md tracks the moment-by-moment execution history. This enables agents to review what was attempted in prior sessions, understand why certain approaches were taken, and avoid repeating failed attempts.","intents":["Maintain a detailed audit trail of all agent actions and results for debugging and compliance","Enable agents to review prior session history and understand what was attempted","Track test results and outcomes to identify patterns in what works and what doesn't","Provide context for understanding why certain decisions were made in prior sessions"],"best_for":["Projects requiring detailed audit trails for compliance or debugging","Long-running agents where session history is critical for understanding context","Teams debugging agent behavior by reviewing detailed execution logs","Projects where understanding 'why' a decision was made is important"],"limitations":["progress.md grows unbounded; no automatic archival or log rotation","Large progress.md files slow parsing and increase token consumption","Logging is verbose; filtering relevant entries from large logs is difficult","No structured format for log entries; parsing requires custom logic","Session history is linear; no easy way to query specific time ranges or action types"],"requires":["progress.md file initialized and maintained throughout project","Timestamped log entries for session boundary detection","Clear format for log entries (action, result, learning, next steps)","Strategy for managing log file size (archival, rotation, or cleanup)"],"input_types":["agent actions and tool calls","action results and outcomes","test results and error messages","learning and insights from actions"],"output_types":["timestamped log entries","action history with results","test result tracking","session history and audit trail"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_2","uri":"capability://planning.reasoning.read.before.decide.workflow.pattern","name":"read-before-decide-workflow-pattern","description":"Implements a critical workflow pattern where agents must read the three markdown files (task_plan.md, findings.md, progress.md) before making decisions or taking actions. This pattern breaks the stateless agent loop by forcing agents to check current state, previous decisions, and error history before proceeding. The pattern is enforced through hook system automation and critical rules that prevent agents from acting without first consulting the persistent state files, creating a synchronous decision-making loop tied to filesystem state.","intents":["Prevent agents from repeating failed actions or decisions already recorded in findings.md","Ensure agents are aware of current phase status before proceeding to next phase","Enable agents to adapt decisions based on previous discoveries and error logs","Create a decision audit trail by forcing agents to acknowledge and reference prior state before acting"],"best_for":["Complex multi-phase projects where decision context is critical","Error-prone tasks where repeated failures must be prevented","Compliance-sensitive work requiring decision documentation","Teams implementing strict agent governance patterns"],"limitations":["Requires agent discipline to follow the pattern — no enforcement mechanism","Adds latency to every decision (file read + parse + decision cycle)","Pattern breaks if agents skip the read step or ignore findings","No automatic validation that agents actually read and understood the files","Assumes agents can parse and interpret markdown state correctly"],"requires":["Agent platform supporting file read operations before tool execution","Hook system or similar mechanism to enforce read-before-decide ordering","Agent instruction set that emphasizes reading state before deciding","Three markdown files initialized and maintained per schema"],"input_types":["task_plan.md (phase status, decisions, error log)","findings.md (research discoveries, technical decisions)","progress.md (session logs, test results)"],"output_types":["decision logs with references to prior state","action plans informed by previous findings","error recovery strategies based on failure history"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_3","uri":"capability://memory.knowledge.session.recovery.and.context.restoration","name":"session-recovery-and-context-restoration","description":"Enables agents to recover from context window resets, /clear commands, or session interruptions by reading the three markdown files to reconstruct the prior session state. When a session resumes, the agent reads task_plan.md to identify the last completed phase, findings.md to understand prior discoveries and decisions, and progress.md to review session history and test results. This restoration process reconstructs the agent's understanding of project state without re-running prior work, allowing seamless continuation from the last known checkpoint.","intents":["Resume work after a context window reset without losing progress or repeating completed phases","Reconstruct agent understanding of project state from persistent markdown files","Identify the last completed phase and next action from task_plan.md status indicators","Recover from session interruptions (network, IDE crash, user context clear) with full state restoration"],"best_for":["Long-running projects (100+ steps) where context window exhaustion is inevitable","Teams using Claude Code with frequent context resets","Projects requiring uninterrupted progress across multiple sessions","Agents handling complex tasks that exceed single-session token budgets"],"limitations":["Restoration is manual — requires agent to explicitly read and parse markdown files","No automatic detection of session boundaries or context resets","Partial state loss if markdown files are corrupted or out-of-sync","Recovery latency depends on file size (large progress.md files slow parsing)","Assumes markdown files are the source of truth; no conflict resolution if in-memory state diverges"],"requires":["Three markdown files maintained throughout prior sessions","Agent platform supporting file read operations on session start","Clear phase markers in task_plan.md indicating completion status","Timestamped entries in progress.md for session boundary detection"],"input_types":["task_plan.md with phase status and completion markers","findings.md with prior discoveries and decisions","progress.md with session logs and timestamps"],"output_types":["reconstructed project state","identified last completed phase","next action plan based on prior state","session continuation log"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_4","uri":"capability://automation.workflow.git.checkpoint.workflow.integration","name":"git-checkpoint-workflow-integration","description":"Integrates git commits as explicit checkpoints in the agent workflow, allowing agents to create git snapshots after completing phases or achieving milestones. The workflow uses git commits to mark stable states in the three markdown files and project code, enabling rollback to prior states if errors are discovered. Agents can reference git commit hashes in task_plan.md and progress.md, creating a version-controlled audit trail of state changes. This pattern combines filesystem persistence with git's version control, providing both recovery and history tracking.","intents":["Create explicit checkpoints in git after completing phases, enabling rollback if errors occur","Maintain a version-controlled history of state changes in markdown files and project code","Enable agents to reference specific git commits when documenting decisions or errors","Provide a recovery mechanism that's stronger than filesystem state alone (git history)"],"best_for":["Projects where code changes and state changes must be tracked together","Teams requiring full audit trails of agent decisions and code modifications","Complex projects where rollback to prior states is necessary for error recovery","Compliance-sensitive work requiring immutable change history"],"limitations":["Requires manual git commit discipline — no automatic checkpoint creation","Git history grows with every checkpoint; large projects accumulate many commits","Merge conflicts possible if multiple agents commit to same files","Rollback requires manual git operations; no automated rollback mechanism","Checkpoint frequency is agent-dependent, not enforced by system"],"requires":["Git repository initialized in project directory","Agent platform supporting git operations (commit, log, checkout)","Clear phase boundaries in task_plan.md for checkpoint timing","Git configuration (user.name, user.email) for commit authorship"],"input_types":["project code changes","markdown file updates","phase completion status","error logs and recovery decisions"],"output_types":["git commits with descriptive messages","git commit hashes referenced in markdown files","version-controlled history of state changes","rollback points for error recovery"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_5","uri":"capability://automation.workflow.hook.system.and.automation.triggers","name":"hook-system-and-automation-triggers","description":"Implements a hook system that automatically triggers actions at specific points in the agent workflow, such as after phase completion, before tool execution, or on error conditions. Hooks can enforce critical rules (e.g., read-before-decide), update markdown files automatically, or trigger git commits. The system uses event-based triggers tied to agent actions, allowing automation of repetitive state management tasks without requiring explicit agent instructions. Hooks are defined in configuration and executed by the agent platform (Claude Code, Cursor, Continue) when conditions are met.","intents":["Automatically update markdown files at specific workflow points without explicit agent instructions","Enforce critical rules (read-before-decide, phase tracking) through automated triggers","Create git checkpoints automatically after phase completion","Prevent agents from skipping required state management steps through hook enforcement"],"best_for":["Teams implementing strict agent governance with mandatory state management","Projects requiring consistent automation across multiple agents","Workflows where manual state updates are error-prone or frequently forgotten","Platforms (Claude Code, Cursor, Continue) with hook system support"],"limitations":["Hook system is platform-specific — not all agent platforms support hooks","Hook configuration is declarative; complex logic requires custom scripts","Hooks add latency to agent execution (trigger evaluation + action execution)","Debugging hook failures is difficult; errors may be silent or logged obscurely","Hook ordering matters; incorrect ordering can cause state inconsistencies"],"requires":["Agent platform with hook system support (Claude Code, Cursor, Continue)","Hook configuration file (.claude-plugin/plugin.json or equivalent)","Understanding of hook event types and trigger conditions","Helper scripts for hook actions (file updates, git commits)"],"input_types":["hook event triggers (phase-complete, tool-execute, error-detected)","hook configuration with conditions and actions","agent state and markdown file contents"],"output_types":["automated markdown file updates","git commits triggered by hooks","enforcement of critical rules","hook execution logs"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_6","uri":"capability://planning.reasoning.manus.principles.based.agent.loop.architecture","name":"manus-principles-based-agent-loop-architecture","description":"Implements the six Manus principles that define the agent loop architecture: (1) persistent external memory via markdown files, (2) read-before-decide pattern, (3) phase-based task decomposition, (4) error tracking and recovery, (5) context engineering for KV-cache optimization, and (6) session management with checkpoints. These principles work together to create a stateful agent loop where each iteration reads state, makes decisions informed by prior discoveries, executes actions, logs results, and updates persistent state. The architecture treats the agent as a state machine with explicit transitions between phases rather than a stateless function.","intents":["Implement a proven agent architecture pattern (Manus) that enabled $2B acquisition","Create stateful agent loops that maintain consistency across context window resets","Enable agents to learn from prior discoveries and avoid repeated mistakes","Decompose complex tasks into phases with explicit state tracking and recovery"],"best_for":["Teams building production AI agents requiring reliability and persistence","Projects implementing the Manus AI pattern (Meta acquisition reference)","Complex coding tasks requiring multi-phase decomposition and error recovery","Organizations standardizing on a proven agent architecture pattern"],"limitations":["Requires understanding of all six Manus principles; learning curve is steep","Implementation is pattern-based, not framework-based — requires manual adherence","No automated validation that agent loop follows all six principles","KV-cache optimization requires platform-specific knowledge (Claude, Anthropic)","Context engineering strategies are heuristic-based, not algorithmically determined"],"requires":["Deep understanding of Manus principles (documented in DeepWiki)","Agent platform supporting persistent file operations and session management","Familiarity with phase-based task decomposition","Knowledge of context engineering and KV-cache optimization"],"input_types":["complex task descriptions","phase definitions and decomposition","context engineering strategies","KV-cache optimization parameters"],"output_types":["phase-based task execution","persistent state updates","error recovery logs","session checkpoints"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_7","uri":"capability://planning.reasoning.context.engineering.and.kv.cache.optimization","name":"context-engineering-and-kv-cache-optimization","description":"Implements context engineering strategies to optimize token usage and KV-cache efficiency in agent loops. The system uses phase-based decomposition to keep context windows focused on current phase, reads only relevant sections of markdown files to minimize token consumption, and structures prompts to maximize KV-cache reuse across multiple agent turns. Context engineering includes strategies like: keeping task_plan.md concise by archiving completed phases, using findings.md as a searchable reference to avoid re-reading full progress logs, and structuring progress.md with clear section boundaries for efficient parsing. These strategies reduce token consumption and improve response latency by optimizing what context is loaded into the KV-cache.","intents":["Reduce token consumption in long-running agent loops by optimizing context window usage","Improve agent response latency by maximizing KV-cache reuse across turns","Keep context windows focused on current phase rather than loading full project history","Enable longer agent sessions by reducing token burn rate through context optimization"],"best_for":["Long-running agent sessions (100+ turns) where token consumption is critical","Cost-sensitive deployments where token usage directly impacts operating costs","Projects with large codebases where full context exceeds token budgets","Teams optimizing for latency and throughput in agent loops"],"limitations":["Context engineering is heuristic-based; optimal strategies vary by task and model","Requires manual tuning of what context to include/exclude per phase","KV-cache optimization is model-specific (Claude, GPT-4, etc.); strategies don't generalize","Over-aggressive context pruning can cause agents to miss important information","No automated tools to measure KV-cache efficiency or token savings"],"requires":["Understanding of KV-cache mechanics and token counting","Knowledge of model-specific context optimization strategies","Ability to measure token consumption and latency","Familiarity with phase-based task decomposition for context scoping"],"input_types":["task_plan.md (phase definitions for context scoping)","findings.md (searchable reference to avoid full log reads)","progress.md (structured sections for efficient parsing)","context engineering parameters (phase scope, reference depth)"],"output_types":["optimized context windows per phase","reduced token consumption metrics","improved response latency","KV-cache efficiency measurements"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_8","uri":"capability://tool.use.integration.platform.specific.agent.skill.integration","name":"platform-specific-agent-skill-integration","description":"Provides platform-specific implementations of the planning-with-files pattern for Claude Code, Cursor, Continue IDEs, Kilocode, and other agent platforms. Each platform has specific integration points: Claude Code uses .claude-plugin/plugin.json for skill configuration, Cursor and Continue use similar plugin systems, Kilocode uses its own skill registry. The system provides helper scripts and configuration templates for each platform, enabling agents to use the three-file pattern without reimplementing core logic. Platform-specific guides document how to initialize the skill, configure hooks, and adapt the pattern to platform constraints.","intents":["Enable the planning-with-files pattern to work across multiple agent platforms without reimplementation","Provide platform-specific configuration and setup for Claude Code, Cursor, Continue, Kilocode","Adapt the three-file pattern to platform-specific constraints and capabilities","Enable teams to standardize on the pattern across heterogeneous agent platforms"],"best_for":["Teams using multiple agent platforms (Claude Code, Cursor, Continue) who want consistent patterns","Organizations standardizing on planning-with-files across different IDEs and tools","Developers building agent skills for specific platforms","Projects requiring portability across agent platforms"],"limitations":["Platform-specific implementations may diverge; consistency is not guaranteed","Some platforms have limited file system access or hook support, limiting functionality","Configuration is platform-specific; moving between platforms requires reconfiguration","Platform updates may break integrations; maintenance burden increases with platform count","Not all platforms support all features (e.g., hooks, git integration)"],"requires":["Platform-specific SDK or plugin system (Claude Code, Cursor, Continue, Kilocode)","Platform-specific configuration files (.claude-plugin/plugin.json, etc.)","Understanding of platform-specific constraints and capabilities","Platform-specific helper scripts and templates (provided in repository)"],"input_types":["platform-specific configuration files","skill definitions and parameters","platform-specific hook configurations"],"output_types":["platform-specific skill implementations","configured plugin files","platform-specific helper scripts"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-othmanadi--planning-with-files__cap_9","uri":"capability://planning.reasoning.error.recovery.and.failure.tracking.pattern","name":"error-recovery-and-failure-tracking-pattern","description":"Implements a structured error recovery pattern where agents log failures in task_plan.md error logs, analyze root causes in findings.md, and document recovery strategies in progress.md. When an error occurs, the agent records: what failed, why it failed, what was attempted, and what recovery strategy was used. This creates a queryable error history that agents can reference before attempting similar actions, preventing repeated failures. The pattern includes anti-patterns documentation that identifies common failure modes (e.g., reading findings.md without acting on it, skipping error log checks) and provides recovery strategies for each.","intents":["Prevent agents from repeating the same failures across sessions by maintaining error history","Enable agents to analyze failure patterns and adjust strategies based on prior errors","Create an audit trail of errors and recovery attempts for debugging and compliance","Identify and document anti-patterns that lead to repeated failures"],"best_for":["Complex projects with high failure rates where learning from errors is critical","Teams requiring detailed error audit trails for debugging and root cause analysis","Long-running agents where repeated failures accumulate and compound","Projects implementing strict error governance and recovery protocols"],"limitations":["Error logging is manual — requires agent discipline to record all failures","No automated error detection; agents must recognize and log failures","Error analysis is agent-dependent; no automated root cause analysis","Error history grows unbounded; no automatic archival or cleanup","Assumes agents will read error logs before attempting similar actions (not enforced)"],"requires":["task_plan.md with dedicated error log section","findings.md with root cause analysis entries","progress.md with recovery strategy documentation","Agent discipline to log all failures and recovery attempts"],"input_types":["error messages and stack traces","failure descriptions and context","recovery attempts and outcomes","root cause analysis"],"output_types":["error log entries with timestamps","root cause analysis in findings.md","recovery strategy documentation","failure pattern analysis"],"categories":["planning-reasoning","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":39,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+ (for helper scripts)","Git repository initialized in project directory","Write access to project filesystem for markdown file creation","Claude Code, Cursor, Continue IDE, or compatible agent platform","Manual setup of three markdown files in project root","Understanding of task_plan.md, findings.md, and progress.md specifications","Agent platform that supports file read/write operations","Manual discipline to follow update frequency rules","Helper scripts for file initialization (provided in repository)","Clear task decomposition into phases before starting"],"failure_modes":["Requires manual file initialization and adherence to markdown schema — no automatic schema validation","Markdown parsing is text-based; no structured query interface for findings or progress logs","File size grows unbounded with session history; no built-in archival or log rotation","Depends on agent discipline to read files before deciding — no enforcement mechanism","Git checkpoint workflow requires manual commit discipline; no automatic state snapshots","Schema is convention-based, not enforced — agents can write malformed markdown","No built-in validation that files conform to specification","Update frequency rules (e.g., 'every 2 view operations') are agent-dependent, not automated","No conflict resolution for concurrent writes from multiple agents","Markdown parsing requires custom logic; no standard library support for this schema","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.3843734621373651,"quality":0.5,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.15,"quality":0.25,"ecosystem":0.1,"match_graph":0.45,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.063Z","last_scraped_at":"2026-05-03T13:58:39.623Z","last_commit":"2026-05-01T19:19:17Z"},"community":{"stars":20249,"forks":1824,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=othmanadi--planning-with-files","compare_url":"https://unfragile.ai/compare?artifact=othmanadi--planning-with-files"}},"signature":"nXL8mbu7vyZ2XuOhsM9WkKBKaf5UJCVE8Af1mae6Ak5XMK/YbBVrXxrUI5CPbJ+vgPyaWQbCVb+XmeM/X1s0AA==","signedAt":"2026-06-22T01:38:06.250Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/othmanadi--planning-with-files","artifact":"https://unfragile.ai/othmanadi--planning-with-files","verify":"https://unfragile.ai/api/v1/verify?slug=othmanadi--planning-with-files","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}