claude-code-workflow 6.3.53 → 7.0.0

package/.codex/skills/issue-discover/phases/04-quick-execute.md

@@ -0,0 +1,241 @@
+# Phase 4: Quick Plan & Execute
+
+> 来源: 分析会话 `ANL-issue-discover规划执行能力-2026-02-11`
+
+## Overview
+
+直接将高置信度 discovery findings 转换为 `.task/*.json` 并内联执行。
+跳过 issue 注册和完整规划流程，适用于明确可修复的问题。
+
+**Core workflow**: Load Findings → Filter → Convert to Tasks → Pre-Execution → User Confirmation → Execute → Finalize
+**Trigger**: Phase 2/3 完成后，用户选择 "Quick Plan & Execute"
+**Output Directory**: 继承 discovery session 的 `{outputDir}`
+**Filter**: `confidence ≥ 0.7 AND priority ∈ {critical, high}`
+
+## Prerequisites
+
+- Phase 2 (Discover) 或 Phase 3 (Discover by Prompt) 已完成
+- `{outputDir}` 下存在 discovery 输出 (perspectives/*.json 或 discovery-issues.jsonl)
+
+## Auto Mode
+
+When `--yes` or `-y`: 自动过滤 → 自动生成任务 → 自动确认执行 → 失败自动跳过 → 自动 Done。
+
+## Execution Steps
+
+### Step 4.1: Load & Filter Findings
+
+**加载优先级** (按顺序尝试):
+
+```
+1. perspectives/*.json  — Phase 2 多视角发现 (每个文件含 findings[])
+2. discovery-issues.jsonl — Phase 2/3 聚合输出 (每行一个 JSON finding)
+3. iterations/*.json — Phase 3 迭代输出 (每个文件含 findings[])
+→ 如果全部为空: 报错 "No discoveries found. Run discover first." 并退出
+```
+
+**过滤规则**:
+
+```
+executableFindings = allFindings.filter(f =>
+  (f.confidence || 0) >= 0.7 &&
+  ['critical', 'high'].includes(f.priority)
+)
+```
+
+- 如果 0 个可执行 findings → 提示 "No executable findings (all below threshold)"，建议用户走 "Export to Issues" 路径
+- 如果超过 10 个 findings → ASK_USER 确认是否全部执行或选择子集 (Auto mode: 全部执行)
+
+**同文件聚合**:
+
+```
+按 finding.file 聚合:
+- 同文件 1 个 finding → 生成 1 个独立 task
+- 同文件 2+ findings → 合并为 1 个 task (mergeFindingsToTask)
+```
+
+### Step 4.2: Generate .task/*.json
+
+对每个 filtered finding (或 file group)，生成 task-schema.json 格式的任务文件。
+
+#### 单 Finding 转换 (convertFindingToTask)
+
+```
+Finding 字段           → Task-Schema 字段        → 转换逻辑
+─────────────────────────────────────────────────────────────
+id (dsc-bug-001-...)   → id (TASK-001)           → 重新编号: TASK-{sequential:3}
+title                  → title                   → 直接使用
+description+impact+rec → description             → 拼接: "{description}\n\nImpact: {impact}\nRecommendation: {recommendation}"
+(无)                   → depends_on              → 默认 []
+(推导)                 → convergence             → 按 perspective/category 模板推导 (见下表)
+suggested_issue.type   → type                    → 映射: bug→fix, feature→feature, enhancement→enhancement, refactor→refactor, test→testing
+priority               → priority                → 直接使用 (已匹配 enum)
+file + line            → files[]                 → [{path: file, action: "modify", changes: [recommendation], target: "line:{line}"}]
+snippet + file:line    → evidence[]              → ["{file}:{line}", snippet]
+recommendation         → implementation[]        → [recommendation]
+(固定)                 → source                  → {tool: "issue-discover", session_id: discoveryId, original_id: finding.id}
+```
+
+**Type 映射**:
+
+```
+suggested_issue.type → task type:
+  bug → fix, feature → feature, enhancement → enhancement,
+  refactor → refactor, test → testing, docs → enhancement
+
+perspective fallback (无 suggested_issue.type 时):
+  bug/security → fix, test → testing, quality/maintainability/best-practices → refactor,
+  performance/ux → enhancement
+```
+
+**Effort 推导**:
+
+```
+critical priority → large
+high priority → medium
+其他 → small
+```
+
+#### 合并 Finding 转换 (mergeFindingsToTask)
+
+同文件 2+ findings 合并为一个 task:
+
+```
+1. 按 priority 排序: critical > high > medium > low
+2. 取最高优先级 finding 的 priority 作为 task priority
+3. 取最高优先级 finding 的 type 作为 task type
+4. title: "Fix {findings.length} issues in {basename(file)}"
+5. description: 按 finding 编号逐条列出 (### Finding N: title + description + impact + recommendation + line)
+6. convergence.criteria: 每个 finding 独立生成 criterion
+7. verification: 选择最严格的验证命令 (jest > eslint > tsc > Manual)
+8. definition_of_done: "修复 {file} 中的 {N} 个问题: {categories.join(', ')}"
+9. effort: 1个=原始, 2个=medium, 3+=large
+10. source.original_id: findings.map(f => f.id).join(',')
+```
+
+#### Convergence 模板 (按 perspective/category 推导)
+
+| Perspective | criteria 模板 | verification | definition_of_done |
+|-------------|--------------|-------------|-------------------|
+| **bug** | "修复 {file}:{line} 的 {category} 问题", "相关模块测试通过" | `npx tsc --noEmit` | "消除 {impact} 风险" |
+| **security** | "修复 {file} 的 {category} 漏洞", "安全检查通过" | `npx eslint {file} --rule 'security/*'` | "消除 {impact} 安全风险" |
+| **test** | "新增测试覆盖 {file}:{line} 场景", "新增测试通过" | `npx jest --testPathPattern={testFile}` | "提升 {file} 模块的测试覆盖" |
+| **quality** | "重构 {file}:{line} 降低 {category}", "lint 检查通过" | `npx eslint {file}` | "改善代码 {category}" |
+| **performance** | "优化 {file}:{line} 的 {category} 问题", "无性能回退" | `npx tsc --noEmit` | "改善 {impact} 的性能表现" |
+| **maintainability** | "重构 {file}:{line} 改善 {category}", "构建通过" | `npx tsc --noEmit` | "降低模块间的 {category}" |
+| **ux** | "改善 {file}:{line} 的 {category}", "界面测试验证" | `Manual: 检查 UI 行为` | "改善用户感知的 {category}" |
+| **best-practices** | "修正 {file}:{line} 的 {category}", "lint 通过" | `npx eslint {file}` | "符合 {category} 最佳实践" |
+
+**低置信度处理**: confidence < 0.8 的 findings，verification 前缀 `Manual: `
+
+**输出**: 写入 `{outputDir}/.task/TASK-{seq}.json`，验证 convergence 非空且非 vague。
+
+### Step 4.3: Pre-Execution Analysis
+
+> Reference: analyze-with-file/EXECUTE.md Step 2-3
+
+复用 EXECUTE.md 的 Pre-Execution 逻辑:
+
+1. **依赖检测**: 检查 `depends_on` 引用是否存在
+2. **循环检测**: 无环 → 拓扑排序确定执行顺序
+3. **文件冲突分析**: 检查多个 tasks 是否修改同一文件 (同文件已聚合，此处检测跨 task 冲突)
+4. **生成 execution.md**: 任务列表、执行顺序、冲突报告
+5. **生成 execution-events.md**: 空事件日志，后续记录执行过程
+
+### Step 4.4: User Confirmation
+
+展示任务概要:
+
+```
+Quick Execute Summary:
+- Total findings: {allFindings.length}
+- Executable (filtered): {executableFindings.length}
+- Tasks generated: {tasks.length}
+- File conflicts: {conflicts.length}
+```
+
+ASK_USER:
+
+```javascript
+ASK_USER([{
+  id: "confirm_execute",
+  type: "select",
+  prompt: `${tasks.length} tasks ready. Start execution?`,
+  options: [
+    { label: "Start Execution", description: "Execute all tasks" },
+    { label: "Adjust Filter", description: "Change confidence/priority threshold" },
+    { label: "Cancel", description: "Skip execution, return to post-phase options" }
+  ]
+}]);
+// Auto mode: Start Execution
+```
+
+- "Adjust Filter" → 重新 ASK_USER 输入 confidence 和 priority 阈值，返回 Step 4.1
+- "Cancel" → 退出 Phase 4
+
+### Step 4.5: Direct Inline Execution
+
+> Reference: analyze-with-file/EXECUTE.md Step 5
+
+逐任务执行 (按拓扑排序):
+
+```
+for each task in sortedTasks:
+  1. Read target file(s)
+  2. Analyze current state vs task.description
+  3. Apply changes (Edit/Write)
+  4. Verify convergence:
+     - Execute task.convergence.verification command
+     - Check criteria fulfillment
+  5. Record event to execution-events.md:
+     - TASK_START → TASK_COMPLETE / TASK_FAILED
+  6. Update .task/TASK-{id}.json _execution status
+  7. If failed:
+     - Auto mode: Skip & Continue
+     - Interactive: ASK_USER → Retry / Skip / Abort
+```
+
+**可选 auto-commit**: 每个成功 task 后 `git add {files} && git commit -m "fix: {task.title}"`
+
+### Step 4.6: Finalize
+
+> Reference: analyze-with-file/EXECUTE.md Step 6-7
+
+1. **更新 execution.md**: 执行统计 (成功/失败/跳过)
+2. **更新 .task/*.json**: `_execution.status` = completed/failed/skipped
+3. **Post-Execute 选项**:
+
+```javascript
+// 计算未执行 findings
+const remainingFindings = allFindings.filter(f => !executedFindingIds.has(f.id))
+
+ASK_USER([{
+  id: "post_quick_execute",
+  type: "select",
+  prompt: `Quick Execute: ${completedCount}/${tasks.length} succeeded. ${remainingFindings.length} findings not executed.`,
+  options: [
+    { label: "Retry Failed", description: `Re-execute ${failedCount} failed tasks` },
+    { label: "Export Remaining", description: `Export ${remainingFindings.length} remaining findings to issues` },
+    { label: "View Events", description: "Display execution-events.md" },
+    { label: "Done", description: "End workflow" }
+  ]
+}]);
+// Auto mode: Done
+```
+
+**"Export Remaining" 逻辑**: 将未执行的 findings 通过现有 Phase 2/3 的 "Export to Issues" 流程注册为 issues，进入 issue-resolve 完整管道。
+
+## Edge Cases
+
+| 边界情况 | 处理策略 |
+|---------|---------|
+| 0 个可执行 findings | 提示 "No executable findings"，建议 Export to Issues |
+| 只有 1 个 finding | 正常生成 1 个 TASK-001.json，简化确认对话 |
+| 超过 10 个 findings | ASK_USER 确认全部执行或选择子集 |
+| finding 缺少 recommendation | criteria 退化为 "Review and fix {category} in {file}:{line}" |
+| finding 缺少 confidence | 默认 confidence=0.5，不满足过滤阈值 → 排除 |
+| discovery 输出不存在 | 报错 "No discoveries found. Run discover first." |
+| .task/ 目录已存在 | ASK_USER 追加 (TASK-{max+1}) 或覆盖 |
+| 执行中文件被外部修改 | convergence verification 检测到差异，标记为 FAIL |
+| 所有 tasks 执行失败 | 建议 "Export to Issues → issue-resolve" 完整路径 |
+| finding 来自不同 perspective 但同文件 | 仍合并为一个 task，convergence.criteria 保留各自标准 |

package/.codex/skills/memory-compact/SKILL.md

@@ -0,0 +1,381 @@
+---
+name: compact
+description: Compact current session memory into structured text for session recovery. Supports custom descriptions and tagging.
+argument-hint: "[--description=\"...\"] [--tags=<tag1,tag2>] [--force]"
+---
+
+# Memory Compact Command (/memory:compact)
+
+## 1. Overview
+
+The `memory:compact` command **compresses current session working memory** into structured text optimized for **session recovery**, extracts critical information, and saves it to persistent storage via MCP `core_memory` tool.
+
+**Core Philosophy**:
+- **Session Recovery First**: Capture everything needed to resume work seamlessly
+- **Minimize Re-exploration**: Include file paths, decisions, and state to avoid redundant analysis
+- **Preserve Train of Thought**: Keep notes and hypotheses for complex debugging
+- **Actionable State**: Record last action result and known issues
+
+## 2. Parameters
+
+- `--description`: Custom session description (optional)
+  - Example: "completed core-memory module"
+  - Example: "debugging JWT refresh - suspected memory leak"
+- `--tags`: Comma-separated tags for categorization (optional)
+- `--force`: Skip confirmation, save directly
+
+## 3. Structured Output Format
+
+```markdown
+## Session ID
+[WFS-ID if workflow session active, otherwise (none)]
+
+## Project Root
+[Absolute path to project root, e.g., D:\Claude_dms3]
+
+## Objective
+[High-level goal - the "North Star" of this session]
+
+## Execution Plan
+[CRITICAL: Embed the LATEST plan in its COMPLETE and DETAILED form]
+
+### Source: [workflow | todo | user-stated | inferred]
+
+<details>
+<summary>Full Execution Plan (Click to expand)</summary>
+
+[PRESERVE COMPLETE PLAN VERBATIM - DO NOT SUMMARIZE]
+- ALL phases, tasks, subtasks
+- ALL file paths (absolute)
+- ALL dependencies and prerequisites
+- ALL acceptance criteria
+- ALL status markers ([x] done, [ ] pending)
+- ALL notes and context
+
+Example:
+## Phase 1: Setup
+- [x] Initialize project structure
+  - Created D:\Claude_dms3\src\core\index.ts
+  - Added dependencies: lodash, zod
+- [ ] Configure TypeScript
+  - Update tsconfig.json for strict mode
+
+## Phase 2: Implementation
+- [ ] Implement core API
+  - Target: D:\Claude_dms3\src\api\handler.ts
+  - Dependencies: Phase 1 complete
+  - Acceptance: All tests pass
+
+</details>
+
+## Working Files (Modified)
+[Absolute paths to actively modified files]
+- D:\Claude_dms3\src\file1.ts (role: main implementation)
+- D:\Claude_dms3\tests\file1.test.ts (role: unit tests)
+
+## Reference Files (Read-Only)
+[Absolute paths to context files - NOT modified but essential for understanding]
+- D:\Claude_dms3\.claude\CLAUDE.md (role: project instructions)
+- D:\Claude_dms3\src\types\index.ts (role: type definitions)
+- D:\Claude_dms3\package.json (role: dependencies)
+
+## Last Action
+[Last significant action and its result/status]
+
+## Decisions
+- [Decision]: [Reasoning]
+- [Decision]: [Reasoning]
+
+## Constraints
+- [User-specified limitation or preference]
+
+## Dependencies
+- [Added/changed packages or environment requirements]
+
+## Known Issues
+- [Deferred bug or edge case]
+
+## Changes Made
+- [Completed modification]
+
+## Pending
+- [Next step] or (none)
+
+## Notes
+[Unstructured thoughts, hypotheses, debugging trails]
+```
+
+## 4. Field Definitions
+
+| Field | Purpose | Recovery Value |
+|-------|---------|----------------|
+| **Session ID** | Workflow session identifier (WFS-*) | Links memory to specific stateful task execution |
+| **Project Root** | Absolute path to project directory | Enables correct path resolution in new sessions |
+| **Objective** | Ultimate goal of the session | Prevents losing track of broader feature |
+| **Execution Plan** | Complete plan from any source (verbatim) | Preserves full planning context, avoids re-planning |
+| **Working Files** | Actively modified files (absolute paths) | Immediately identifies where work was happening |
+| **Reference Files** | Read-only context files (absolute paths) | Eliminates re-exploration for critical context |
+| **Last Action** | Final tool output/status | Immediate state awareness (success/failure) |
+| **Decisions** | Architectural choices + reasoning | Prevents re-litigating settled decisions |
+| **Constraints** | User-imposed limitations | Maintains personalized coding style |
+| **Dependencies** | Package/environment changes | Prevents missing dependency errors |
+| **Known Issues** | Deferred bugs/edge cases | Ensures issues aren't forgotten |
+| **Changes Made** | Completed modifications | Clear record of what was done |
+| **Pending** | Next steps | Immediate action items |
+| **Notes** | Hypotheses, debugging trails | Preserves "train of thought" |
+
+## 5. Execution Flow
+
+### Step 1: Analyze Current Session
+
+Extract the following from conversation history:
+
+```javascript
+const sessionAnalysis = {
+  sessionId: "",       // WFS-* if workflow session active, null otherwise
+  projectRoot: "",     // Absolute path: D:\Claude_dms3
+  objective: "",       // High-level goal (1-2 sentences)
+  executionPlan: {
+    source: "workflow" | "todo" | "user-stated" | "inferred",
+    content: ""        // Full plan content - ALWAYS preserve COMPLETE and DETAILED form
+  },
+  workingFiles: [],    // {absolutePath, role} - modified files
+  referenceFiles: [],  // {absolutePath, role} - read-only context files
+  lastAction: "",      // Last significant action + result
+  decisions: [],       // {decision, reasoning}
+  constraints: [],     // User-specified limitations
+  dependencies: [],    // Added/changed packages
+  knownIssues: [],     // Deferred bugs
+  changesMade: [],     // Completed modifications
+  pending: [],         // Next steps
+  notes: ""            // Unstructured thoughts
+}
+```
+
+### Step 2: Generate Structured Text
+
+```javascript
+// Helper: Generate execution plan section
+const generateExecutionPlan = (plan) => {
+  const sourceLabels = {
+    'workflow': 'workflow (IMPL_PLAN.md)',
+    'todo': 'todo (TodoWrite)',
+    'user-stated': 'user-stated',
+    'inferred': 'inferred'
+  };
+
+  // CRITICAL: Preserve complete plan content verbatim - DO NOT summarize
+  return `### Source: ${sourceLabels[plan.source] || plan.source}
+
+<details>
+<summary>Full Execution Plan (Click to expand)</summary>
+
+${plan.content}
+
+</details>`;
+};
+
+const structuredText = `## Session ID
+${sessionAnalysis.sessionId || '(none)'}
+
+## Project Root
+${sessionAnalysis.projectRoot}
+
+## Objective
+${sessionAnalysis.objective}
+
+## Execution Plan
+${generateExecutionPlan(sessionAnalysis.executionPlan)}
+
+## Working Files (Modified)
+${sessionAnalysis.workingFiles.map(f => `- ${f.absolutePath} (role: ${f.role})`).join('\n') || '(none)'}
+
+## Reference Files (Read-Only)
+${sessionAnalysis.referenceFiles.map(f => `- ${f.absolutePath} (role: ${f.role})`).join('\n') || '(none)'}
+
+## Last Action
+${sessionAnalysis.lastAction}
+
+## Decisions
+${sessionAnalysis.decisions.map(d => `- ${d.decision}: ${d.reasoning}`).join('\n') || '(none)'}
+
+## Constraints
+${sessionAnalysis.constraints.map(c => `- ${c}`).join('\n') || '(none)'}
+
+## Dependencies
+${sessionAnalysis.dependencies.map(d => `- ${d}`).join('\n') || '(none)'}
+
+## Known Issues
+${sessionAnalysis.knownIssues.map(i => `- ${i}`).join('\n') || '(none)'}
+
+## Changes Made
+${sessionAnalysis.changesMade.map(c => `- ${c}`).join('\n') || '(none)'}
+
+## Pending
+${sessionAnalysis.pending.length > 0
+  ? sessionAnalysis.pending.map(p => `- ${p}`).join('\n')
+  : '(none)'}
+
+## Notes
+${sessionAnalysis.notes || '(none)'}`
+```
+
+### Step 3: Import to Core Memory via MCP
+
+Use the MCP `core_memory` tool to save the structured text:
+
+```javascript
+mcp__ccw-tools__core_memory({
+  operation: "import",
+  text: structuredText
+})
+```
+
+Or via CLI (pipe structured text to import):
+
+```bash
+# Write structured text to temp file, then import
+echo "$structuredText" | ccw core-memory import
+
+# Or from a file
+ccw core-memory import --file /path/to/session-memory.md
+```
+
+**Response Format**:
+```json
+{
+  "operation": "import",
+  "id": "CMEM-YYYYMMDD-HHMMSS",
+  "message": "Created memory: CMEM-YYYYMMDD-HHMMSS"
+}
+```
+
+### Step 4: Report Recovery ID
+
+After successful import, **clearly display the Recovery ID** to the user:
+
+```
+╔════════════════════════════════════════════════════════════════════════════╗
+║  ✓ Session Memory Saved                                                    ║
+║                                                                            ║
+║  Recovery ID: CMEM-YYYYMMDD-HHMMSS                                         ║
+║                                                                            ║
+║  To restore: "Please import memory <ID>"                                   ║
+║  (MCP: core_memory export | CLI: ccw core-memory export --id <ID>)         ║
+╚════════════════════════════════════════════════════════════════════════════╝
+```
+
+## 6. Quality Checklist
+
+Before generating:
+- [ ] Session ID captured if workflow session active (WFS-*)
+- [ ] Project Root is absolute path (e.g., D:\Claude_dms3)
+- [ ] Objective clearly states the "North Star" goal
+- [ ] Execution Plan: COMPLETE plan preserved VERBATIM (no summarization)
+- [ ] Plan Source: Clearly identified (workflow | todo | user-stated | inferred)
+- [ ] Plan Details: ALL phases, tasks, file paths, dependencies, status markers included
+- [ ] All file paths are ABSOLUTE (not relative)
+- [ ] Working Files: 3-8 modified files with roles
+- [ ] Reference Files: Key context files (CLAUDE.md, types, configs)
+- [ ] Last Action captures final state (success/failure)
+- [ ] Decisions include reasoning, not just choices
+- [ ] Known Issues separates deferred from forgotten bugs
+- [ ] Notes preserve debugging hypotheses if any
+
+## 7. Path Resolution Rules
+
+### Project Root Detection
+1. Check current working directory from environment
+2. Look for project markers: `.git/`, `package.json`, `.claude/`
+3. Use the topmost directory containing these markers
+
+### Absolute Path Conversion
+```javascript
+// Convert relative to absolute
+const toAbsolutePath = (relativePath, projectRoot) => {
+  if (path.isAbsolute(relativePath)) return relativePath;
+  return path.join(projectRoot, relativePath);
+};
+
+// Example: "src/api/auth.ts" → "D:\Claude_dms3\src\api\auth.ts"
+```
+
+### Reference File Categories
+| Category | Examples | Priority |
+|----------|----------|----------|
+| Project Config | `.claude/CLAUDE.md`, `package.json`, `tsconfig.json` | High |
+| Type Definitions | `src/types/*.ts`, `*.d.ts` | High |
+| Related Modules | Parent/sibling modules with shared interfaces | Medium |
+| Test Files | Corresponding test files for modified code | Medium |
+| Documentation | `README.md`, `ARCHITECTURE.md` | Low |
+
+## 8. Plan Detection (Priority Order)
+
+### Priority 1: Workflow Session (IMPL_PLAN.md)
+```javascript
+// Check for active workflow session
+const manifest = await mcp__ccw-tools__session_manager({
+  operation: "list",
+  location: "active"
+});
+
+if (manifest.sessions?.length > 0) {
+  const session = manifest.sessions[0];
+  const plan = await mcp__ccw-tools__session_manager({
+    operation: "read",
+    session_id: session.id,
+    content_type: "plan"
+  });
+  sessionAnalysis.sessionId = session.id;
+  sessionAnalysis.executionPlan.source = "workflow";
+  sessionAnalysis.executionPlan.content = plan.content;
+}
+```
+
+### Priority 2: TodoWrite (Current Session Todos)
+```javascript
+// Extract from conversation - look for TodoWrite tool calls
+// Preserve COMPLETE todo list with all details
+const todos = extractTodosFromConversation();
+if (todos.length > 0) {
+  sessionAnalysis.executionPlan.source = "todo";
+  // Format todos with full context - preserve status markers
+  sessionAnalysis.executionPlan.content = todos.map(t =>
+    `- [${t.status === 'completed' ? 'x' : t.status === 'in_progress' ? '>' : ' '}] ${t.content}`
+  ).join('\n');
+}
+```
+
+### Priority 3: User-Stated Plan
+```javascript
+// Look for explicit plan statements in user messages:
+// - "Here's my plan: 1. ... 2. ... 3. ..."
+// - "I want to: first..., then..., finally..."
+// - Numbered or bulleted lists describing steps
+const userPlan = extractUserStatedPlan();
+if (userPlan) {
+  sessionAnalysis.executionPlan.source = "user-stated";
+  sessionAnalysis.executionPlan.content = userPlan;
+}
+```
+
+### Priority 4: Inferred Plan
+```javascript
+// If no explicit plan, infer from:
+// - Task description and breakdown discussion
+// - Sequence of actions taken
+// - Outstanding work mentioned
+const inferredPlan = inferPlanFromDiscussion();
+if (inferredPlan) {
+  sessionAnalysis.executionPlan.source = "inferred";
+  sessionAnalysis.executionPlan.content = inferredPlan;
+}
+```
+
+## 9. Notes
+
+- **Timing**: Execute at task completion or before context switch
+- **Frequency**: Once per independent task or milestone
+- **Recovery**: New session can immediately continue with full context
+- **Knowledge Graph**: Entity relationships auto-extracted for visualization
+- **Absolute Paths**: Critical for cross-session recovery on different machines