maestro-flow 0.3.15 → 0.3.17

package/workflows/verify.md

@@ -17,45 +17,15 @@ Dual verification: Goal-Backward structural verification + Nyquist test coverage
 ```
 Input: [phase] argument OR --dir <path>
 
-# Worktree scope check
-IF file_exists(".workflow/worktree-scope.json"):
-  scope = read(".workflow/worktree-scope.json")
-  IF <phase> is a number AND <phase> NOT IN scope.owned_phases:
-    ERROR "Phase {phase} not owned by this worktree. Owned: {scope.owned_phases}"
-    EXIT
-
-IF --dir <path> is provided:
-  // Single plan verification
-  PLAN_DIRS = [<path>]
-  VERIFY_MODE = "single"
-  VERIFY_OUTPUT_DIR = <path>  // verification.json written into plan dir
-
-ELSE IF no arguments:
-  // Milestone-level verification
-  Read state.json.artifacts
-  PLAN_DIRS = artifacts.filter(a =>
-    a.milestone == current_milestone &&
-    a.type == "execute" &&
-    a.status == "completed"
-  ).map(a => a.path)
-  IF PLAN_DIRS is empty: ERROR E001
-  VERIFY_MODE = "milestone"
-  milestone_slug = slugify(current_milestone name)
-  VERIFY_OUTPUT_DIR = .workflow/scratch/verify-{milestone_slug}-{date}/
-  mkdir -p VERIFY_OUTPUT_DIR
-
-ELSE IF argument is a number:
-  // Phase-level verification
-  Read state.json.artifacts
-  PLAN_DIRS = artifacts.filter(a =>
-    a.milestone == current_milestone &&
-    a.type == "execute" &&
-    a.phase == arg &&
-    a.status == "completed"
-  ).map(a => a.path)
-  IF PLAN_DIRS is empty: ERROR E001
-  VERIFY_MODE = "phase"
-  VERIFY_OUTPUT_DIR = first plan dir  // single plan → write there
+Worktree scope check: if .workflow/worktree-scope.json exists, reject phases not in scope.owned_phases.
+
+Resolve PLAN_DIRS and VERIFY_MODE by input type:
+  --dir <path>    → single mode, PLAN_DIRS=[path], output into plan dir
+  no arguments    → milestone mode, collect completed execute artifacts for current milestone from state.json
+  numeric arg     → phase mode, collect completed execute artifacts for that phase from state.json
+
+If no matching artifacts found: ERROR E001.
+Milestone mode creates output dir: .workflow/scratch/verify-{milestone_slug}-{date}/
 ```
 
 ---
@@ -88,118 +58,44 @@ Pass specs_content to verifier agent as quality standards context.
 ### Step 1: Extract Constraints from Specs
 
 ```
-constraints = {
-  allowed_libs: [],
-  disallowed_imports: [],
-  required_patterns: []
-}
+Extract from specs_content into constraints object:
+  allowed_libs[]        ← "tech_stack" / "technology" sections
+  disallowed_imports[]  ← "constraints" / "disallowed" / "forbidden" sections
+  required_patterns[]   ← "required_patterns" / "conventions" sections
 
-Parse specs_content for constraint definitions:
-  - "tech_stack" / "technology" sections -> extract allowed libraries/frameworks
-  - "constraints" / "disallowed" / "forbidden" sections -> extract disallowed imports
-  - "required_patterns" / "conventions" sections -> extract required patterns
-
-IF constraints.allowed_libs is empty AND constraints.disallowed_imports is empty:
-  Print: "V0.5: No tech stack constraints found in specs, skipping."
-  constraint_violations = []
-  SKIP to V1
+If no allowed_libs and no disallowed_imports found: skip to V1.
 ```
 
 ### Step 2: Collect Modified Files
 
 ```
-modified_files = []
-
-# Method 1: Extract from task summaries
-FOR each summary IN ${PHASE_DIR}/.summaries/TASK-*-summary.md:
-  Parse "Files Modified" section
-  Extract file paths -> add to modified_files[]
-
-# Method 2: Fallback to git diff if no summaries or empty list
-IF modified_files is empty:
-  modified_files = git diff --name-only HEAD~{tasks_completed} -- "*.ts" "*.tsx" "*.js" "*.jsx" "*.py" "*.java" "*.go"
-
-# Deduplicate and filter to source files only
-modified_files = unique(modified_files).filter(f => !f.includes("node_modules") && !f.includes(".test.") && !f.includes(".spec."))
+Collect modified_files from task summaries ("Files Modified" sections).
+Fallback: git diff --name-only HEAD~{tasks_completed} -- "*.ts" "*.tsx" "*.js" "*.jsx" "*.py" "*.java" "*.go"
+Deduplicate, exclude node_modules and test/spec files.
 ```
 
 ### Step 3: Scan Imports Against Constraints
 
 ```
-constraint_violations = []
-
-FOR each file IN modified_files:
-  IF file does not exist: SKIP
-
-  # Extract import statements based on file type
-  IF file ends with .ts/.tsx/.js/.jsx:
-    imports = grep -n "^import .* from ['\"]" {file}
-    imports += grep -n "require(['\"]" {file}
-  ELSE IF file ends with .py:
-    imports = grep -n "^import \|^from .* import" {file}
-  ELSE IF file ends with .go:
-    imports = grep -n "\".*\"" {file}  # inside import block
-  ELSE IF file ends with .java:
-    imports = grep -n "^import " {file}
-
-  FOR each import_line IN imports:
-    # Check against disallowed imports
-    FOR each disallowed IN constraints.disallowed_imports:
-      IF import_line contains disallowed:
-        constraint_violations.push({
-          id: "CV-{NNN}",
-          type: "disallowed_import",
-          severity: "high",
-          file: file,
-          line: import_line.line_number,
-          import: import_line.text,
-          constraint: "Disallowed: " + disallowed,
-          fix_direction: "Replace " + disallowed + " with an allowed alternative"
-        })
-
-    # Check against allowed_libs (if allowlist is defined)
-    IF constraints.allowed_libs is not empty:
-      package_name = extract package/module name from import_line
-      IF package_name is external AND package_name NOT IN constraints.allowed_libs:
-        constraint_violations.push({
-          id: "CV-{NNN}",
-          type: "unlisted_dependency",
-          severity: "medium",
-          file: file,
-          line: import_line.line_number,
-          import: import_line.text,
-          constraint: "Not in allowed tech stack",
-          fix_direction: "Verify if " + package_name + " is approved, add to tech stack or replace"
-        })
+For each modified file, extract import statements (language-aware: TS/JS, Python, Go, Java).
+
+Check each import against constraints:
+  disallowed_imports match → violation {id: "CV-{NNN}", type: "disallowed_import", severity: "high", file, line, import, constraint, fix_direction}
+  allowed_libs allowlist defined + external package not listed → violation {id: "CV-{NNN}", type: "unlisted_dependency", severity: "medium", file, line, import, constraint, fix_direction}
 ```
 
 ### Step 4: Check Required Patterns
 
 ```
-FOR each pattern IN constraints.required_patterns:
-  FOR each file IN modified_files matching pattern.file_glob:
-    IF file does not contain pattern.regex:
-      constraint_violations.push({
-        id: "CV-{NNN}",
-        type: "missing_required_pattern",
-        severity: pattern.severity || "medium",
-        file: file,
-        line: null,
-        import: null,
-        constraint: "Required pattern missing: " + pattern.description,
-        fix_direction: pattern.fix_hint || "Add required pattern to file"
-      })
+For each required_pattern, scan matching files (by file_glob) for pattern.regex.
+Missing match → violation {id: "CV-{NNN}", type: "missing_required_pattern", severity: pattern.severity || "medium", file, constraint, fix_direction}
 ```
 
 ### Step 5: Report
 
 ```
-IF constraint_violations.length > 0:
-  Print: "V0.5: {constraint_violations.length} constraint violation(s) found"
-  FOR each violation IN constraint_violations:
-    Print: "  [{violation.severity}] {violation.file}:{violation.line} - {violation.constraint}"
-ELSE:
-  Print: "V0.5: All modified files comply with tech stack constraints"
+Report constraint_violations count and details: [{severity}] {file}:{line} - {constraint}
+If none: "V0.5: All modified files comply with tech stack constraints"
 ```
 
 The `constraint_violations[]` array is included in the final `verification.json` output in V3 aggregation.
@@ -225,17 +121,8 @@ Build a verification context object mapping:
 
 **Load UAT human findings** (if available):
 ```
-uat_gaps = []
-IF file exists "${PHASE_DIR}/uat.md":
-  Parse uat.md "Gaps" section.
-  FOR each gap in uat.md:
-    uat_gaps.push({
-      id: "GAP-UAT-{NNN}",
-      type: "human_verified_failure",
-      severity: gap.severity,
-      description: "From UAT: " + gap.reason,
-      fix_direction: "Address user-reported issue: " + gap.truth
-    })
+If ${PHASE_DIR}/uat.md exists, parse "Gaps" section into uat_gaps[]:
+  {id: "GAP-UAT-{NNN}", type: "human_verified_failure", severity, description, fix_direction}
 ```
 These `uat_gaps` are merged into the final `gaps[]` in V3 aggregation.
 
@@ -323,65 +210,22 @@ must_haves = {
 ### Identify gaps
 
 ```
-gaps = []
-For each failed truth:
-  gaps.push({
-    id: "GAP-{NNN}",
-    type: "missing_feature" | "incomplete_implementation" | "broken_integration",
-    severity: "critical" | "high" | "medium" | "low",
-    description: "What is missing or broken",
-    fix_direction: "Suggested approach to fix"
-  })
-
-For each missing/non-substantive artifact:
-  gaps.push({ ... })
-
-For each broken link:
-  gaps.push({ ... })
+Collect gaps from failed truths, missing/stub artifacts, and broken links.
+Each gap: {id: "GAP-{NNN}", type: "missing_feature"|"incomplete_implementation"|"broken_integration",
+           severity: "critical"|"high"|"medium"|"low", description, fix_direction}
 ```
 
 ### Auto-create Issues from Gaps
 
 ```
-IF gaps.length > 0:
-  mkdir -p ".workflow/issues"
-  existing_ids = []
-  IF file exists ".workflow/issues/issues.jsonl":
-    Read .workflow/issues/issues.jsonl
-    Extract all id fields matching today's date prefix ISS-YYYYMMDD-*
-    existing_ids = collected IDs
-
-  today = format(now(), "YYYYMMDD")
-  counter = max sequence number from existing_ids for today + 1 (start at 1 if none)
-
-  FOR each gap IN gaps[]:
-    issue_id = "ISS-{today}-{counter padded to 3 digits}"
-    issue = {
-      id: issue_id,
-      title: gap.description (truncated to 100 chars),
-      status: "registered",
-      priority: severity_to_priority(gap.severity),
-      severity: gap.severity,
-      source: "verification",
-      phase_ref: PHASE_NUM,
-      gap_ref: gap.id,
-      description: gap.description,
-      fix_direction: gap.fix_direction,
-      context: { location: "", suggested_fix: gap.fix_direction, notes: "" },
-      tags: [],
-      affected_components: [],
-      feedback: [],
-      issue_history: [],
-      created_at: now(),
-      updated_at: now(),
-      resolved_at: null,
-      resolution: null
-    }
-    Append JSON line to .workflow/issues/issues.jsonl
-    gap.issue_id = issue_id   // back-reference on gap object
-    counter++
-
-  Print: "Created {gaps.length} issues from verification gaps"
+For each gap, create an issue in .workflow/issues/issues.jsonl:
+  id: "ISS-{YYYYMMDD}-{NNN}" (auto-incrementing from existing today's IDs)
+  Fields: title (gap.description truncated 100 chars), status: "registered",
+    priority: severity_to_priority(gap.severity), severity, source: "verification",
+    phase_ref: PHASE_NUM, gap_ref: gap.id, description, fix_direction,
+    context: {location, suggested_fix, notes}, tags[], affected_components[],
+    feedback[], issue_history[], created_at, updated_at, resolved_at: null, resolution: null
+  Back-reference: gap.issue_id = issue_id
 ```
 
 ### Write verification.json
@@ -422,47 +266,13 @@ Write anti-patterns into verification.json `antipatterns[]` array.
 ### Auto-create Issues from Blocker Anti-Patterns
 
 ```
-blocker_patterns = antipatterns.filter(ap => ap.severity == "Blocker")
-
-IF blocker_patterns.length > 0:
-  mkdir -p ".workflow/issues"
-  existing_ids = []
-  IF file exists ".workflow/issues/issues.jsonl":
-    Read .workflow/issues/issues.jsonl
-    Extract all id fields matching today's date prefix ISS-YYYYMMDD-*
-    existing_ids = collected IDs
-
-  today = format(now(), "YYYYMMDD")
-  counter = max sequence number from existing_ids for today + 1 (start at 1 if none)
-
-  FOR each pattern IN blocker_patterns:
-    issue_id = "ISS-{today}-{counter padded to 3 digits}"
-    issue = {
-      id: issue_id,
-      title: "Anti-pattern: " + pattern.pattern_name (truncated to 100 chars),
-      status: "registered",
-      priority: 1,
-      severity: "critical",
-      source: "antipattern",
-      phase_ref: PHASE_NUM,
-      gap_ref: null,
-      description: "Blocker anti-pattern detected: " + pattern.pattern_name + " at " + pattern.file_line,
-      fix_direction: "Remove " + pattern.pattern_name + " from " + pattern.file_line,
-      context: { location: pattern.file_line, suggested_fix: "", notes: "" },
-      tags: ["antipattern"],
-      affected_components: [],
-      feedback: [],
-      issue_history: [],
-      created_at: now(),
-      updated_at: now(),
-      resolved_at: null,
-      resolution: null
-    }
-    Append JSON line to .workflow/issues/issues.jsonl
-    pattern.issue_id = issue_id   // back-reference on anti-pattern object
-    counter++
-
-  Print: "Created {blocker_patterns.length} issues from blocker anti-patterns"
+For each Blocker anti-pattern, create an issue in .workflow/issues/issues.jsonl:
+  id: "ISS-{YYYYMMDD}-{NNN}" (auto-incrementing from existing today's IDs)
+  Fields: title: "Anti-pattern: {pattern_name}", status: "registered",
+    priority: 1, severity: "critical", source: "antipattern",
+    phase_ref: PHASE_NUM, description, fix_direction,
+    context: {location: pattern.file_line}, tags: ["antipattern"]
+  Back-reference: pattern.issue_id = issue_id
 ```
 
 ---
@@ -538,14 +348,7 @@ If gaps exist from any verification layer:
 
 3. **Order by dependency**: Fix missing -> fix stubs -> fix wiring -> verify.
 
-Enrich fix plan entries with issue references:
-```
-FOR each fix_plan IN fix_plans[]:
-  fix_plan.issue_ids = []
-  FOR each gap IN fix_plan.related_gaps:
-    IF gap.issue_id exists:
-      fix_plan.issue_ids.push(gap.issue_id)
-```
+Enrich each fix_plan with issue_ids[] collected from its related_gaps' issue references.
 
 Write fix plans into verification.json `fix_plans[]` array.
 
@@ -566,19 +369,8 @@ Combine goal-backward, constraint validation, anti-pattern scan, and Nyquist res
 
 **Archive previous verification artifacts** before writing:
 ```
-ARCHIVE_TARGETS = ["verification.json", "validation.json"]
-has_existing = false
-FOR artifact IN ARCHIVE_TARGETS:
-  IF file exists "${PHASE_DIR}/${artifact}":
-    has_existing = true
-    break
-
-IF has_existing:
-  mkdir -p "${PHASE_DIR}/.history"
-  TIMESTAMP = current timestamp formatted as "YYYY-MM-DDTHH-mm-ss"
-  FOR artifact IN ARCHIVE_TARGETS:
-    IF file exists "${PHASE_DIR}/${artifact}":
-      mv "${PHASE_DIR}/${artifact}" "${PHASE_DIR}/.history/${name}-${TIMESTAMP}.${ext}"
+If any of ["verification.json", "validation.json"] exist in ${PHASE_DIR}:
+  Move each to ${PHASE_DIR}/.history/{name}-{YYYY-MM-DDTHH-mm-ss}.{ext}
 ```
 
 Write verification.json:
@@ -593,22 +385,9 @@ Write verification.json:
 ### Update index.json
 
 ```
-index.json.status = "verifying"
-index.json.updated_at = now()
-
-index.json.verification = {
-  status: verification.json.status,
-  verified_at: verification.json.verified_at,
-  must_haves: summary of must_haves,
-  gaps: verification.json.gaps
-}
-
-If validation.json exists:
-  index.json.validation = {
-    status: validation.json.status,
-    test_coverage: validation.json.coverage,
-    gaps: validation.json.gaps
-  }
+Set index.json.status = "verifying", updated_at = now()
+Set index.json.verification = {status, verified_at, must_haves summary, gaps} from verification.json
+If validation.json exists: set index.json.validation = {status, test_coverage, gaps} from validation.json
 ```
 
 ### Report Format

package/workflows/wiki-connect.md

@@ -28,7 +28,7 @@ Knowledge graph link discovery and health improvement. Analyzes the unified wiki
 
 | Flag | Effect |
 |------|--------|
-| `--scope <type>` | Limit to wiki type: spec, memory, note, lesson, issue. Default: all |
+| `--scope <type>` | Limit to wiki type: spec, knowhow, note, lesson, issue. Default: all |
 | `--min-similarity N` | Minimum similarity score 0.0-1.0 (default: 0.3) |
 | `--fix` | Auto-apply top suggestions via `maestro wiki update` |
 | `--max N` | Maximum suggestions to generate (default: 20) |
@@ -37,20 +37,9 @@ Knowledge graph link discovery and health improvement. Analyzes the unified wiki
 
 ## Stage 1: Load Wiki State
 
-Run these `maestro wiki` commands in parallel to gather baseline:
+Gather baseline in parallel via `maestro wiki list --json`, `health`, `orphans`, `hubs --top 10`.
 
-```bash
-maestro wiki list --json           # all entries with metadata
-maestro wiki health                # composite health score
-maestro wiki orphans               # entries with 0 in/out links
-maestro wiki hubs --top 10         # most-referenced entries
-```
-
-Parse into working state:
-- Entry count and type distribution (spec, memory, note, lesson, issue)
-- Baseline health score (numeric, from health command)
-- Orphan list with entry IDs and titles
-- Hub list with in-degree counts
+Working state: entry count by type, baseline health score, orphan IDs, hub in-degree counts.
 
 Apply `--scope` filter if provided — restrict all subsequent analysis to matching type.
 
@@ -87,23 +76,15 @@ Detect entries of different types referencing the same concept:
 
 ## Stage 3: Score Candidates
 
-For each candidate connection (source → target):
+Score each candidate connection (source → target):
 
 ```
-score = 0.4 × tag_overlap_ratio
-      + 0.3 × title_bm25_similarity
-      + 0.2 × same_category_bonus
-      + 0.1 × type_bridge_bonus
+score = 0.4 × tag_overlap_ratio + 0.3 × title_bm25_similarity + 0.2 × same_category_bonus + 0.1 × type_bridge_bonus
 ```
 
-- `tag_overlap_ratio`: shared_tags / max(source_tags, target_tags)
-- `title_bm25_similarity`: normalized BM25 score from `maestro wiki search`
-- `same_category_bonus`: 1.0 if same category, else 0.0
-- `type_bridge_bonus`: 1.0 if different types, else 0.0
+Ratios: tag_overlap = shared/max(source,target) tags, BM25 = normalized wiki search, category/type bonuses = 1.0 if match/bridge.
 
-Filter: score >= `--min-similarity`
-Sort: descending by score
-Limit: top `--max` entries
+Filter: score >= `--min-similarity`, sort descending, limit to `--max`.
 
 ---
 
@@ -131,16 +112,9 @@ If `--fix`: proceed to Stage 5.
 
 ## Stage 5: Apply Connections (--fix only)
 
-For each accepted suggestion:
-1. `maestro wiki get <source-id> --json` — get current entry
-2. Extract existing `related` list from frontmatter
-3. Append target-id to `related` if not already present
-4. `maestro wiki update <source-id> --frontmatter '{"related": ["existing...", "new-target"]}'`
-5. Log success/failure per entry
+For each accepted suggestion: fetch entry, append target-id to `related` list (dedup), update via `maestro wiki update <source-id> --frontmatter`.
 
-After all updates:
-- Re-run `maestro wiki health` → compute delta
-- Report applied count, skipped count, and health improvement
+After all updates: re-run `maestro wiki health`, report applied/skipped counts and health delta.
 
 ---
 
@@ -175,14 +149,3 @@ Report:       .workflow/learning/wiki-connections-{date}.md
 | View full graph | `maestro wiki graph` |
 | Run harvest for new content | `/manage-harvest --recent 7` |
 
----
-
-## Error Codes
-
-| Code | Severity | Condition | Recovery |
-|------|----------|-----------|----------|
-| E001 | error | No wiki entries found (empty index) | Run `/maestro-init` or create wiki content |
-| E002 | error | `maestro wiki` CLI not available | Check maestro installation |
-| W001 | warning | No candidates above threshold | Lower `--min-similarity` or verify graph connectivity |
-| W002 | warning | Some wiki updates failed during `--fix` | Retry failed entries manually |
-| W003 | warning | Health score unchanged after fix | Connections may not affect specific health metrics |

package/workflows/wiki-digest.md

@@ -32,7 +32,7 @@ Unlike `maestro wiki list` which shows raw entries, this workflow synthesizes an
 |------|--------|
 | `<topic>` | Search wiki for matching entries via BM25 |
 | `--recent N` | Entries updated within last N days |
-| `--type <type>` | Filter by wiki type: spec, memory, note, lesson, issue |
+| `--type <type>` | Filter by wiki type: spec, knowhow, note, lesson, issue |
 | `--format brief\|full` | `brief` = compact (default), `full` = detailed per-entry |
 | `--create-issues` | Auto-create knowledge-gap issues in `issues.jsonl` |
 
@@ -59,18 +59,9 @@ Run `maestro wiki health` for baseline health metrics.
 
 ## Stage 2: Theme Clustering
 
-Group entries into 3-5 semantic themes using:
+Group entries into 3-5 semantic themes by: tag co-occurrence (2+ shared tags), title BM25 similarity, relationship proximity (`related` links), and type sub-clustering.
 
-1. **Tag co-occurrence**: entries sharing 2+ tags → same cluster
-2. **Title BM25 similarity**: entries whose titles match each other's keywords
-3. **Relationship proximity**: entries connected by `related` links → same cluster
-4. **Type sub-clustering**: if all same type, sub-cluster by content/category
-
-Per theme, record:
-- Theme name: dominant tag or keyword
-- Entry count and IDs
-- Type distribution within theme
-- Status distribution (draft/active/completed/archived)
+Per theme: name (dominant tag), entry count/IDs, type distribution, status distribution.
 
 ---
 
@@ -100,10 +91,7 @@ Per-theme health adapted from wiki health formula (entries, connectivity, comple
 
 ## Stage 4: Cross-Reference with Lessons
 
-1. Read `.workflow/learning/lessons.jsonl`
-2. For each theme, search lessons by keyword match
-3. Identify **unlinked insights**: lessons that match a theme's keywords but are not referenced by any wiki entry in that theme
-4. Flag as "knowledge not yet connected to the graph"
+Search `.workflow/learning/lessons.jsonl` for keyword matches against each theme. Flag **unlinked insights** -- lessons matching a theme but not referenced by any wiki entry in that theme.
 
 If `lessons.jsonl` not found, skip with W002 warning.
 
@@ -166,35 +154,15 @@ Produce `.workflow/learning/digest-{slug}-{YYYY-MM-DD}.md`:
 
 ## Stage 7: Gap → Issue Routing (if --create-issues)
 
-For each knowledge gap from Stage 5:
-1. Dedup: check `.workflow/issues/issues.jsonl` for existing gap with same theme + type
-2. If new, append to `issues.jsonl` using canonical schema (see `~/.maestro/workflows/issue.md` Step 4):
-   - `type`: "knowledge-gap"
-   - `status`: "open"
-   - `severity`: "low"
-   - `source`: "wiki-digest"
-   - `tags`: ["knowledge-gap", "{theme-slug}"]
-3. Report created issue count
+For each knowledge gap from Stage 5: dedup against `.workflow/issues/issues.jsonl` (same theme + type). If new, append with `type: "knowledge-gap"`, `status: "open"`, `severity: "low"`, `source: "wiki-digest"`, `tags: ["knowledge-gap", "{theme-slug}"]`. Report created count.
 
 ---
 
 ## Stage 8: Persist
 
 1. Write digest file to `.workflow/learning/`
-2. Append meta-insights to `.workflow/learning/lessons.jsonl`:
-   - `source: "wiki-digest"`, `category: "technique"`
-   - e.g., "Auth knowledge concentrated in specs, lacks lessons"
-3. Display summary:
-
-```
-== Wiki Digest Complete ==
-Scope:     {topic or "all"}
-Entries:   {count}
-Themes:    {theme_count}
-Gaps:      {gap_count} identified
-Issues:    {created_count} created (if --create-issues)
-Report:    .workflow/learning/digest-{slug}-{date}.md
-```
+2. Append meta-insights to `.workflow/learning/lessons.jsonl` (`source: "wiki-digest"`, `category: "technique"`)
+3. Display summary: scope, entry count, theme count, gap count, created issues (if applicable), report path.
 
 ---
 
@@ -208,14 +176,3 @@ Report:    .workflow/learning/digest-{slug}-{date}.md
 | Create missing entries | `maestro wiki create --type <type> --slug <slug>` |
 | Triage gap issues | `/manage-issue list --source wiki-digest` |
 
----
-
-## Error Codes
-
-| Code | Severity | Condition | Recovery |
-|------|----------|-----------|----------|
-| E001 | error | No wiki entries found (empty index) | Initialize wiki content |
-| E002 | error | Topic search returned 0 results | Broaden topic or check wiki |
-| W001 | warning | Too few entries (<5) for meaningful clustering | Themes may be trivial |
-| W002 | warning | `lessons.jsonl` not found | Skip cross-reference |
-| W003 | warning | Some entry bodies failed to load | Partial summaries |