knowzcode 0.1.0

package/knowzcode/platform_adapters.md

@@ -0,0 +1,388 @@
+# KnowzCode Platform Adapters
+
+This file contains adapter templates for integrating KnowzCode with different AI coding platforms. Each adapter teaches the platform's AI how to follow the KnowzCode methodology with full phase walkthroughs, quality gates, and TDD enforcement.
+
+Generated by `/kc:init`. Adapters should be placed in the project root (or platform-specific location).
+
+---
+
+## Claude Code (CLAUDE.md section)
+
+Append to or create `CLAUDE.md` in project root:
+
+```markdown
+# KnowzCode Integration
+
+This project uses KnowzCode for structured TDD development with multi-agent orchestration.
+
+## Required Reading
+- `knowzcode/knowzcode_loop.md` — Development methodology (TDD, quality gates, phases)
+- `knowzcode/knowzcode_project.md` — Project context and tech stack
+- `knowzcode/knowzcode_tracker.md` — Current WorkGroup status
+- `knowzcode/knowzcode_architecture.md` — Architecture documentation
+
+## Workflow Phases
+Follow the phases in `knowzcode_loop.md` for all feature work:
+1. **Phase 1A: Impact Analysis** — Identify affected components, propose Change Set. PAUSE for user approval.
+2. **Phase 1B: Specification** — Draft specs for all NodeIDs. PAUSE for user approval. Commit specs.
+3. **Phase 2A: Implementation** — Strict TDD (Red-Green-Refactor). No production code without a failing test.
+4. **Phase 2B: Completeness Audit** — Independent READ-ONLY audit. PAUSE for user decision on gaps.
+5. **Phase 3: Finalization** — Update specs to as-built, update tracker, log entry, final commit.
+
+## Quality Gates
+Never skip phases. PAUSE for user approval at each gate:
+- After Change Set proposal (1A)
+- After spec drafts (1B)
+- After implementation (2A — awaiting audit)
+- After audit results (2B — user decides on gaps)
+
+## TDD Enforcement
+TDD is mandatory — no production code without a failing test first.
+Red-Green-Refactor cycle for every feature/criterion in the spec.
+
+## Agents
+Specialized agents handle each phase when using Agent Teams or subagent execution:
+- `analyst` (1A), `architect` (1B), `builder` (2A), `reviewer` (2B), `closer` (3)
+- Agent Teams is the preferred execution model when enabled (experimental, requires `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` env var)
+- Subagent fallback for environments without Agent Teams
+
+## Commands
+- `/kc:work "goal"` — Start feature workflow
+- `/kc:plan "topic"` — Research before implementing
+- `/kc:audit [type]` — Run quality audits (spec, architecture, security, integration)
+- `/kc:fix "target" "summary"` — Quick targeted fix
+- `/kc:learn "insight"` — Capture learning to vault
+- `/kc:status` — Check MCP connection and vault status
+
+## MCP Integration (Optional)
+If configured, agents use `search_knowledge`, `ask_question`, and `create_knowledge` for enhanced context.
+All commands work without MCP — it enhances but never blocks.
+
+## WorkGroup Files
+- Created in `knowzcode/workgroups/` (gitignored)
+- Every todo must start with `KnowzCode:` prefix
+- Track phase history, Change Set, and outstanding work
+```
+
+---
+
+## OpenAI Codex (AGENTS.md)
+
+Create `AGENTS.md` in project root. Notes: `AGENTS.override.md` can be used for user-local overrides. 32KB file size limit. Plain text format (no YAML frontmatter).
+
+```markdown
+# KnowzCode Development Methodology
+
+This project uses KnowzCode for structured TDD development.
+Read `knowzcode/knowzcode_loop.md` before starting any feature work.
+
+## Phase Walkthrough
+
+### Before Starting
+1. Read `knowzcode/knowzcode_tracker.md` — check for active WorkGroups
+2. Read `knowzcode/knowzcode_project.md` — understand project context
+3. Read `knowzcode/knowzcode_architecture.md` — understand current architecture
+
+### Phase 1A: Impact Analysis
+- Analyze what needs to change for the given goal
+- Create NodeIDs for NEW capabilities only (not per-file)
+- Check `knowzcode/specs/` for existing specs in the same domain
+- Propose a Change Set with NodeIDs, affected files, and risk assessment
+- **STOP**: Present Change Set for user approval before continuing
+
+### Phase 1B: Specification
+- Draft specs for each NodeID using the 4-section format:
+  - Rules & Decisions, Interfaces, Verification Criteria, Debt & Gaps
+- Minimum: 1+ Rules, 1+ Interface, 2+ VERIFY statements per spec
+- Save to `knowzcode/specs/{NodeID}.md`
+- **STOP**: Present specs for user approval
+- After approval: `git commit` the specs as a checkpoint
+
+### Phase 2A: Implementation (TDD MANDATORY)
+- For EACH feature/criterion in the spec:
+  1. RED: Write a failing test first
+  2. GREEN: Write minimal code to make the test pass
+  3. REFACTOR: Clean up while keeping tests green
+- Run full test suite + static analysis + build after all features
+- Maximum 10 verification iterations before pausing
+- **STOP**: Report implementation results
+
+### Phase 2B: Completeness Audit
+- READ-ONLY audit — do NOT modify source files
+- Compare implementation against all VERIFY statements in specs
+- Calculate completion percentage
+- Report gaps, security concerns, integration issues
+- **STOP**: Present audit results for user decision
+
+### Phase 3: Finalization
+- Update specs to "As-Built" status
+- Check architecture doc for drift
+- Prepend log entry to `knowzcode/knowzcode_log.md`
+- Update tracker statuses to `[VERIFIED]`
+- Create final commit with all changes
+
+## Key Rules
+- Always propose a Change Set before implementing
+- Get user approval at every quality gate (STOP points above)
+- TDD is mandatory — no production code without failing tests
+- Log all completions in `knowzcode/knowzcode_log.md`
+- Track work in `knowzcode/knowzcode_tracker.md`
+- Every WorkGroup todo must start with `KnowzCode:` prefix
+- Target <20 specs per project — consolidate when domains overlap
+
+## Quick Fix (Micro-Fix)
+For single-file, <50 line, no-ripple-effect changes:
+1. Implement the fix
+2. Run targeted tests
+3. Log a MicroFix entry
+4. Commit with `fix:` prefix
+
+## Key Files
+- `knowzcode/knowzcode_loop.md` — Complete methodology
+- `knowzcode/knowzcode_project.md` — Project context
+- `knowzcode/knowzcode_architecture.md` — Architecture docs
+- `knowzcode/knowzcode_tracker.md` — WorkGroup tracking
+- `knowzcode/specs/` — Component specifications
+- `knowzcode/workgroups/` — Active session data (gitignored)
+```
+
+---
+
+## Google Gemini CLI (GEMINI.md)
+
+Create `GEMINI.md` in project root. Notes: Gemini CLI supports `@file.md` imports for pulling in methodology files (e.g., `@knowzcode/knowzcode_loop.md`). User-global preferences can be placed in `~/.gemini/GEMINI.md`.
+
+```markdown
+# KnowzCode Development Methodology
+
+This project uses KnowzCode for structured TDD development.
+
+## Required Reading
+Read these files before starting any feature work (use @import syntax for direct inclusion):
+- `knowzcode/knowzcode_loop.md` — Complete workflow methodology
+- `knowzcode/knowzcode_project.md` — Project context and tech stack
+- `knowzcode/knowzcode_architecture.md` — Architecture documentation
+- `knowzcode/knowzcode_tracker.md` — Active WorkGroups
+
+## Phase Walkthrough
+
+### Phase 1A: Impact Analysis
+- Identify components affected by the goal
+- Create NodeIDs for new capabilities (PascalCase domain concepts)
+- Check existing specs for domain overlap before creating new ones
+- Present Change Set for user approval — STOP until approved
+
+### Phase 1B: Specification
+- Draft specs using 4-section format (Rules, Interfaces, Verification Criteria, Debt)
+- Each spec needs 2+ VERIFY statements
+- Present for approval — STOP until approved
+- Commit specs as a pre-implementation checkpoint
+
+### Phase 2A: Implementation (TDD Required)
+- Follow Red-Green-Refactor for every feature
+- Write failing test FIRST, then minimal code to pass, then refactor
+- Run full test suite + linter + build when all features done
+- STOP and report results
+
+### Phase 2B: Completeness Audit
+- READ-ONLY comparison of implementation vs specs
+- Calculate completion percentage
+- Report gaps and security concerns
+- STOP for user decision
+
+### Phase 3: Finalization
+- Update specs to As-Built, update tracker, write log entry
+- Check architecture doc for drift
+- Final commit
+
+## Rules
+- Follow quality gates strictly — STOP at each gate for user approval
+- TDD is mandatory for all feature work
+- Propose Change Sets before implementing
+- Update specs and tracker after implementation
+- Log completions in `knowzcode/knowzcode_log.md`
+- Target <20 specs — consolidate when domains overlap >50%
+
+## Micro-Fix (for small changes)
+Single file, <50 lines, no ripple effects:
+1. Implement fix → 2. Run tests → 3. Log MicroFix → 4. Commit with `fix:`
+```
+
+---
+
+## Cursor (`.cursor/rules/knowzcode.mdc`)
+
+Create `.cursor/rules/knowzcode.mdc` with YAML frontmatter. Notes: Modern Cursor uses `.cursor/rules/*.mdc` files instead of the deprecated `.cursorrules`. Scoped rules can target specific file patterns using the `globs` frontmatter field.
+
+```markdown
+---
+description: KnowzCode TDD development methodology
+alwaysApply: true
+---
+
+# KnowzCode Rules
+
+This project uses KnowzCode for structured TDD development.
+
+## Required Reading
+Before any feature work, read:
+- `knowzcode/knowzcode_loop.md` — Complete methodology
+- `knowzcode/knowzcode_project.md` — Project context
+- `knowzcode/knowzcode_tracker.md` — Active WorkGroups
+- `knowzcode/knowzcode_architecture.md` — Architecture docs
+
+## Phase Rules
+
+### Phase 1A: Impact Analysis
+- Identify affected components and propose a Change Set
+- NodeIDs are domain concepts (PascalCase), not tasks
+- Check `knowzcode/specs/` before creating new specs
+- PAUSE for user approval before proceeding
+
+### Phase 1B: Specification
+- Use 4-section format: Rules & Decisions, Interfaces, Verification Criteria, Debt & Gaps
+- Minimum: 2+ VERIFY statements per spec
+- PAUSE for user approval, then commit specs
+
+### Phase 2A: Implementation
+- TDD is mandatory: write failing test FIRST, then minimal code, then refactor
+- Use Composer for multi-file edits when implementing across components
+- Run full test suite before reporting complete
+- PAUSE after implementation
+
+### Phase 2B: Audit
+- READ-ONLY — do not modify source files
+- Compare implementation vs spec VERIFY statements
+- Report completion percentage and gaps
+- PAUSE for user decision
+
+### Phase 3: Finalization
+- Update specs to As-Built status
+- Update tracker and log
+- Check architecture for drift
+- Final commit
+
+## Enforcement
+- Never skip phases or quality gates
+- TDD is mandatory — no production code without a failing test
+- Every WorkGroup todo starts with `KnowzCode:` prefix
+- Consolidate specs when domains overlap >50%
+- Target <20 specs per project
+- Read `knowzcode/knowzcode_tracker.md` for active work
+- Log completions in `knowzcode/knowzcode_log.md`
+```
+
+---
+
+## GitHub Copilot (.github/copilot-instructions.md)
+
+Create `.github/copilot-instructions.md` for repository-level instructions. Notes: GitHub Copilot also supports scoped instructions via `*.instructions.md` files with `applyTo` YAML frontmatter (e.g., `knowzcode.instructions.md` with `applyTo: "knowzcode/**"` to scope KnowzCode methodology to the framework directory).
+
+```markdown
+# KnowzCode Development Methodology
+
+This repository uses KnowzCode for structured TDD development.
+
+## Key Constraint: TDD is Mandatory
+- Write failing tests BEFORE implementation code
+- Follow Red-Green-Refactor cycle for every feature
+- No production code without corresponding test coverage
+
+## Workflow
+Reference `knowzcode/knowzcode_loop.md` for the complete development workflow.
+Follow these phases for all feature work:
+
+1. **Impact Analysis** — Propose a Change Set, get user approval
+2. **Specification** — Draft specs with VERIFY statements, get user approval
+3. **Implementation** — Strict TDD, verification loop
+4. **Audit** — READ-ONLY comparison against specs
+5. **Finalization** — Update docs, tracker, log, commit
+
+## Quality Gates
+STOP and get user approval:
+- After Change Set proposal
+- After spec drafts
+- After implementation (awaiting audit)
+- After audit results (user decides on gaps)
+
+## Key Files
+- `knowzcode/knowzcode_loop.md` — Methodology (read first)
+- `knowzcode/knowzcode_project.md` — Project context
+- `knowzcode/knowzcode_architecture.md` — Architecture docs
+- `knowzcode/knowzcode_tracker.md` — WorkGroup tracking
+- `knowzcode/specs/` — Component specifications
+
+## Rules
+- NodeIDs are domain concepts (PascalCase), not tasks
+- Consolidate specs when domains overlap >50%
+- Every WorkGroup todo starts with `KnowzCode:` prefix
+- Log completions in `knowzcode/knowzcode_log.md`
+```
+
+---
+
+## Windsurf (`.windsurf/rules/knowzcode.md`)
+
+Create `.windsurf/rules/knowzcode.md`. Notes: Modern Windsurf uses the `.windsurf/rules/` directory instead of the deprecated `.windsurfrules` file. Cascade multi-file editing works well with KnowzCode's cross-component implementation phases.
+
+```markdown
+# KnowzCode Development Methodology
+
+This project uses KnowzCode for structured TDD development.
+Follow `knowzcode/knowzcode_loop.md` for all feature development.
+
+## Required Reading
+- `knowzcode/knowzcode_loop.md` — Complete methodology
+- `knowzcode/knowzcode_project.md` — Project context
+- `knowzcode/knowzcode_tracker.md` — Active WorkGroups
+- `knowzcode/knowzcode_architecture.md` — Architecture docs
+
+## Phase Walkthrough
+
+### Phase 1A: Impact Analysis
+- Identify affected components, propose Change Set with NodeIDs
+- Check existing specs before creating new ones
+- PAUSE for user approval
+
+### Phase 1B: Specification
+- Draft specs with 4-section format and 2+ VERIFY statements
+- PAUSE for approval, then commit specs
+
+### Phase 2A: Implementation (TDD Mandatory)
+- Write failing test FIRST, then minimal code, then refactor
+- Use Cascade for multi-file edits across components
+- Run full verification loop (tests + linter + build)
+- PAUSE after implementation
+
+### Phase 2B: Audit
+- READ-ONLY audit against spec VERIFY statements
+- Report completion %, gaps, security concerns
+- PAUSE for user decision
+
+### Phase 3: Finalization
+- Update specs to As-Built, tracker, log, architecture
+- Final commit
+
+## Enforcement Rules
+- TDD is mandatory — write failing tests before implementation code
+- Respect quality gates between phases — PAUSE at each gate
+- Update `knowzcode/knowzcode_tracker.md` when completing work
+- Log completions in `knowzcode/knowzcode_log.md`
+- Consolidate specs when domains overlap >50%
+- Target <20 specs per project
+- Every WorkGroup todo starts with `KnowzCode:` prefix
+
+## Micro-Fix (for small changes)
+Single file, <50 lines, no ripple effects:
+Implement → Test → Log MicroFix → Commit with `fix:` prefix
+```
+
+---
+
+## OpenAI Codex Agents SDK (Python)
+
+For teams building custom orchestration with the OpenAI Agents SDK,
+map KnowzCode's 5 phase agents to SDK Agent definitions. The AGENTS.md
+file above provides all instructions each agent needs. See the
+[Agents SDK documentation](https://openai.github.io/openai-agents-python/)
+for implementation details.

package/knowzcode/prompts/Execute_Micro_Fix.md

@@ -0,0 +1,57 @@
+# KnowzCode: Execute Micro-Fix
+
+**Target:** [NodeID or specific file path]
+**Issue:** [Brief, one-line description of the small change needed]
+
+Remember to log follow-up tasks in `knowzcode/workgroups/<WorkGroupID>.md` with the `KnowzCode:` prefix.
+
+> **Automation Path:** Prefer invoking `/kc-microfix target=<NodeID> summary="..."` to delegate to the `microfix-specialist` subagent while keeping scope under the 50-line threshold.
+
+---
+
+## Your Mission
+You have been instructed to perform a "Micro-Fix." This protocol is for small, localized changes that do not alter system architecture or component interfaces.
+
+**CRITICAL RULE: Before proceeding, confirm this task qualifies as a Micro-Fix.** It must be a small change (e.g., < 50 lines), have no ripple effects, and require no spec updates. If it does not qualify, **STOP** and inform the Orchestrator that the full KnowzCode loop is required.
+
+**Reference:** Your actions are governed by the "Micro-Fix Protocol" in `knowzcode_loop.md`.
+
+---
+
+### Execution Protocol
+
+1.  **Implement Fix:**
+    *   Make the small, targeted change precisely as requested.
+
+2.  **Quick Verification:**
+    *   Perform a focused check to confirm the fix resolves the described issue and introduces no regressions in the immediate vicinity of the change.
+
+3.  **Log Operation (Ref: `knowzcode_loop.md` - Step 4.3):**
+    *   Prepend a `MicroFix` entry to `knowzcode_log.md`. The entry **MUST** use the following format and an environment-sourced timestamp:
+        ```markdown
+        ---
+        **Type:** MicroFix
+        **Timestamp:** [Generated Timestamp]
+        **NodeID(s)/File:** [TargetNodeID or file_path]
+        **Logged By:** AI-Agent
+        **Details:**
+        - **User Request:** [Orchestrator's brief issue description].
+        - **Action Taken:** [Brief description of change made].
+        - **Verification:** [Brief verification method/outcome].
+        ---
+        ```
+
+4.  **Commit Fix (Ref: `knowzcode_loop.md` - Step 4.4):**
+    *   Commit the change to version control with a descriptive `fix:` message (e.g., `fix: correct label on login button`). Use the `git` command specified in your `environment_context.md`.
+
+### Final Report
+
+*   Once all steps are complete, provide a concise confirmation report.
+
+**Example Response:**
+> "✓ Micro-Fix completed for `[Target]`.
+> *   **Change:** Corrected the CSS padding on the main header.
+> *   **Verification:** Visually confirmed the alignment is now correct.
+> *   **Documentation:** Log entry added and a `fix:` commit has been made.
+> 
+> Awaiting next `PrimaryGoal`."

package/knowzcode/prompts/Investigate_Codebase.md

@@ -0,0 +1,227 @@
+# KnowzCode: Investigate Codebase
+
+> **Automation Path:** On Claude Code, run `/kc:plan "your question"` to orchestrate this automatically.
+
+## Your Mission
+
+You are performing a focused investigation of the codebase to answer a specific question. You will conduct 1-3 research passes (based on question relevance) to gather evidence, then synthesize findings into actionable recommendations.
+
+**Investigation Question**: $ARGUMENTS
+
+---
+
+## Phase 1: Context Loading (Do Once)
+
+Read these files ONCE at the start:
+- `knowzcode/knowzcode_project.md` - project context
+- `knowzcode/knowzcode_architecture.md` - architecture overview
+- `knowzcode/knowzcode_tracker.md` - existing NodeIDs
+
+---
+
+## Phase 2: Selective Investigation Passes
+
+Conduct ONLY investigation passes that are relevant to the question.
+
+### Step 1: Determine Which Passes Are Needed
+
+Analyze the question and select investigation passes based on relevance:
+
+| Pass | When to Include | Skip When |
+|------|-----------------|-----------|
+| **Code Exploration** | ALWAYS (provides code evidence) | Never skip - always needed |
+| **Architecture & Patterns** | Question involves patterns, design, structure, consistency, layers | Simple lookup questions, bug hunts, "where is X?" |
+| **Security & Performance** | Question involves auth, security, performance, data handling, risk | Code organization questions, refactoring questions |
+
+**Question Type -> Pass Selection Guide:**
+
+| Question Type | Example | Passes |
+|---------------|---------|--------|
+| Code location | "Where is user auth handled?" | Code Exploration only |
+| Implementation check | "How is error handling done?" | Code Exploration + Architecture |
+| Security concern | "Is the API properly secured?" | Code Exploration + Security |
+| Full assessment | "Is the auth system well designed and secure?" | All 3 passes |
+| Pattern consistency | "Are we consistent in how we handle dates?" | Code Exploration + Architecture |
+
+### Step 2: Execute Investigation Passes
+
+On platforms with agent orchestration, run these in parallel. Otherwise, execute sequentially.
+
+**Pass 1: Code Exploration (ALWAYS INCLUDE)**
+- Find code evidence to answer the question
+- Constraints: Max 10 tool calls. Focus on 5 most relevant files
+- Output: Code evidence with file paths and line numbers
+
+**Pass 2: Architecture & Pattern Analysis (IF RELEVANT)**
+- Evaluate patterns and design for this question
+- Constraints: Max 8 tool calls. Focus on pattern consistency
+- Output: Pattern observations with examples
+
+**Pass 3: Security & Performance (IF RELEVANT)**
+- Check security/performance aspects for this question
+- Constraints: Max 8 tool calls. Only check relevant OWASP categories
+- Output: Risk observations with severity levels
+
+---
+
+## Phase 3: Synthesize Findings
+
+**When ALL spawned agents return:**
+
+1. Merge results into unified investigation report
+2. Cross-reference findings from agents consulted
+3. Identify agreements and conflicts (if multiple agents)
+4. Formulate direct answer to the original question
+5. Generate actionable recommendations
+
+### Save Investigation Report
+
+Save findings to `knowzcode/planning/investigation-{timestamp}.md`:
+
+```markdown
+# Investigation: {question summary}
+
+**Question**: {$ARGUMENTS}
+**Timestamp**: {timestamp}
+**Agents Consulted**: {list agents actually spawned}
+
+## Executive Summary
+
+{Direct 2-3 sentence answer to the question}
+
+## Detailed Findings
+
+### Code Exploration (analyst)
+{findings}
+
+### Pattern Analysis (architect)
+{findings}
+
+### Security/Performance Assessment (reviewer)
+{findings}
+
+## Synthesis
+
+**Key Findings**:
+{consolidated bullet points}
+
+**Cross-Agent Agreements**:
+{where agents agree}
+
+**Areas of Concern**:
+{issues identified}
+
+## Recommendations
+
+| # | Action | Priority | Effort |
+|---|--------|----------|--------|
+| 1 | {action} | HIGH/MED/LOW | S/M/L |
+| 2 | {action} | HIGH/MED/LOW | S/M/L |
+| 3 | {action} | HIGH/MED/LOW | S/M/L |
+```
+
+---
+
+## Phase 4: Present Findings
+
+Present investigation results to user:
+
+```markdown
+## KnowzCode Investigation Complete
+
+**Question**: {$ARGUMENTS}
+**Agents Consulted**: {N} (in parallel)
+
+### Summary
+
+{Direct answer to the question}
+
+### Key Findings
+
+{3-5 bullet points summarizing discoveries}
+
+### Recommendations
+
+{numbered list of actionable improvements}
+
+---
+
+**Implementation Options:**
+
+1. {First recommendation action}
+2. {Second recommendation action}
+3. {Third recommendation action}
+
+Say "implement", "do it", or select an option (e.g., "option 1") to proceed with implementation.
+Or say "that's all" if you just needed the information.
+```
+
+---
+
+## Phase 5: Action Listening Mode
+
+**After presenting findings, enter Action Listening Mode.**
+
+Monitor subsequent user messages for implementation triggers:
+
+### Implementation Triggers (Transition to Phase 1A)
+
+Detect these patterns in user's next message:
+
+| Pattern | Example | Action |
+|---------|---------|--------|
+| Imperative verbs | "implement", "fix", "build", "add", "create" | Extract goal, proceed to Phase 1A |
+| Confirmation words | "do it", "go ahead", "proceed", "yes", "let's do it" | Use top recommendation |
+| Option selection | "option 1", "the first one", "#2", "do number 2" | Use selected recommendation |
+| "Fix it" / "Make it work" | "fix it", "make it work", "just do it" | Use top recommendation |
+
+### When Trigger Detected:
+
+1. Extract implementation goal from:
+   - User's specific request (if provided)
+   - Selected option (if option number given)
+   - Top recommendation (if generic "do it")
+
+2. Log investigation context for handoff:
+   ```
+   Investigation findings available at: knowzcode/planning/investigation-{timestamp}.md
+   ```
+
+3. Transition to Phase 1A:
+   ```markdown
+   **Transitioning to implementation...**
+
+   Goal extracted: "{extracted goal}"
+   Investigation context: Pre-loaded from investigation findings
+
+   Proceeding to Phase 1A (Impact Analysis)...
+   ```
+
+4. Pass investigation findings to Phase 1A:
+   - NodeIDs already identified -> pre-populate Change Set
+   - Security concerns -> carry forward as annotations
+   - Architecture observations -> carry forward as annotations
+   - Skip redundant discovery -> focus Phase 1A on validation
+
+### Non-Trigger Responses
+
+If user message does NOT contain implementation trigger:
+- "ok thanks" -> End gracefully: "Investigation complete. Start Phase 1A when ready to implement."
+- "tell me more about X" -> Provide additional detail from findings
+- "what about Y?" -> Follow-up investigation (run additional passes)
+
+---
+
+## Logging
+
+After investigation, log to `knowzcode/knowzcode_log.md`:
+
+```markdown
+---
+**Type:** Investigation
+**Timestamp:** {timestamp}
+**Question:** {$ARGUMENTS}
+**Finding:** {one-line summary}
+**Status:** {Complete | Handoff to Phase 1A}
+---
+```