knowzcode 0.1.0

package/knowzcode/prompts/[LOOP_2B]__Verify_Implementation.md

@@ -0,0 +1,72 @@
+# KnowzCode: [LOOP 2B] Verify Implementation Completeness
+
+**WorkGroupID for Audit:**
+[Orchestrator: Re-state the `WorkGroupID` that has completed Loop 2A and requires an implementation audit.]
+
+> **Automation Path:** Trigger `/kc-step phase=2B workgroup_id=<ID>` or `/kc-audit audit=implementation workgroup_id=<ID>` to run the `reviewer` subagent in read-only mode. It utilizes `spec-quality-check`, `tracker-scan`, and `log-entry-builder` skills to compute the completion percentage.
+
+**Remember:**
+- Flag any spec discrepancies you uncover and update the relevant files in `knowzcode/specs/`.
+- Add follow-up todos to `knowzcode/workgroups/<WorkGroupID>.md` (each entry prefixed `KnowzCode:`) so unresolved work is obvious.
+
+**WorkGroupID:** `[wip-timestamp-to-audit]`
+
+---
+
+## Your Mission
+This is a **READ-ONLY** quality gate to audit the completeness of the implementation for the given `WorkGroupID`. You will compare the work done against the approved specifications and report an objective completion percentage.
+
+**CRITICAL RULE: You MUST NOT modify any files. This is a verification step, not a correction step.**
+
+**Reference:** Your actions are governed by `knowzcode_loop.md`, executing the audit defined in **Step 6B**.
+
+---
+
+### Execution Protocol
+
+#### Phase 0: Reconnaissance (READ-ONLY)
+1.  **Identify Audit Scope:** Get all `NodeID`s associated with the `WorkGroupID` from `knowzcode_tracker.md`.
+2.  **List Artifacts:** List all source code files that were created or modified for this `WorkGroupID`.
+3.  **Map Built Features:** Briefly map what was built (e.g., components, functions, features, tests).
+
+#### Phase 1: Specification-to-Code Audit
+1.  **Load Specs:** For each `NodeID` in your scope, load its approved specification from `specs/`.
+2.  **Verify Spec-to-Code:** For each spec, systematically verify that every requirement, function, and error handling case listed in the spec has been implemented in the code.
+3.  **Verify Code-to-Spec:** Check for any "orphan" code—features or functions that were implemented but are not described in any specification.
+4.  **Calculate Completion:** Based on your findings, calculate an objective, quantitative **completion percentage**. (e.g., "8 of 10 requirements implemented = 80% complete").
+
+#### Phase 2: Synthesize Findings & Report
+*   Compile a single, comprehensive audit report.
+
+### Audit Report Structure
+
+Your report **must** include the following sections:
+> **WorkGroupID:** `[ID]`
+> **Overall Implementation Completion:** [Calculated Percentage]%
+>
+> **1. Fully Implemented Requirements:**
+> *   [List of spec requirements that are 100% complete]
+>
+> **2. Partially Implemented Requirements:**
+> *   [Requirement X]: Implemented basic case, but missing error handling for [condition].
+> *   [Requirement Y]: Feature exists, but is missing [specific part].
+>
+> **3. Not Implemented Requirements:**
+> *   [List of spec requirements that were not implemented at all]
+>
+> **4. Orphan Code (Not in Specs):**
+> *   [Function `calculate_extra_value()` in `file.py` has no corresponding spec requirement.]
+>
+> **5. Risk Assessment:**
+> *   [Brief assessment of the risk of proceeding with the current implementation state. e.g., "Low risk, missing features are non-critical." or "High risk, core security function is incomplete."]
+>
+> **Awaiting Orchestrator decision.**
+
+### Orchestrator Decision Points
+Based on your report, the Orchestrator will choose one of the following paths:
+*   **(A) Complete Gaps:** Return to implementation (Step 5) to address the identified gaps.
+*   **(B) Accept & Proceed:** Accept the current implementation as-is and proceed to Loop 3 for finalization.
+*   **(C) Modify Specs:** Update the specifications to match the "as-built" code, formally accepting the deviations.
+*   **(D) Cancel:** Cancel the WorkGroupID and potentially revert the changes.
+
+---

package/knowzcode/prompts/[LOOP_3]__Finalize_And_Commit.md

@@ -0,0 +1,67 @@
+# KnowzCode: [LOOP 3] Finalize & Commit Change Set
+
+**WorkGroupID for Finalization:**
+[Orchestrator: Re-state the `WorkGroupID` that has passed implementation and verification, authorizing its finalization and commit.]
+
+> **Automation Path:** Execute `/kc-step phase=3 workgroup_id=<ID>` to hand off to the `closer` subagent. It chains `tracker-update`, `log-entry-builder`, and `architecture-diff` skills to wrap up the loop.
+
+**Remember:**
+- Finalize every spec in `knowzcode/specs/` to reflect the as-built system.
+- Close or add remaining todos in `knowzcode/workgroups/<WorkGroupID>.md`, ensuring all entries keep the `KnowzCode:` prefix.
+
+**WorkGroupID:** `[wip-timestamp-to-finalize]`
+
+---
+
+## Your Mission
+The implementation and verification for the specified `WorkGroupID` is complete. You are now authorized to execute the final phase of the KnowzCode loop: documentation, logging, and committing.
+
+**CRITICAL RULE: The implementation phase is complete. Your work in this phase is strictly limited to updating KnowzCode's own project and specification files (`.md` files) to reflect the finished work. You MUST NOT write or modify any more application source code (e.g., `.js`, `.py`, `.html` files).**
+
+**Reference:** Your actions are governed by `knowzcode_loop.md`, executing the sequence from **Step 7 through Step 10**.
+
+---
+
+### Execution Protocol
+
+1.  **Finalize Specifications (Step 7):**
+    *   For **each** `NodeID` in the `WorkGroupID`, update its spec file in `specs/` to the "as-built" state, ensuring it perfectly reflects the verified code.
+
+2.  **Check Architecture (Step 8):**
+    *   Conduct the Flowchart Consistency Check. If you find a simple discrepancy, fix `knowzcode_architecture.md` directly. If it's complex, document it in the log.
+
+3.  **Log Operation (Step 9):**
+    *   Create the single, comprehensive `ARC-Completion` log entry in `knowzcode_log.md`. Ensure it includes the flowchart check outcome, any unforeseen ripple effects, and project overview updates. Use an environment-sourced timestamp.
+
+4.  **Update Tracker, Schedule Debt, & Check Project Overview (Step 10):**
+    *   **Update Tracker:** In `knowzcode_tracker.md`, mark all nodes in the `WorkGroupID` as `[VERIFIED]` and clear their `WorkGroupID`.
+    *   **Schedule Debt:** Perform the "Technical Debt Scheduling" step. For any nodes with documented debt, create new `REFACTOR_` tasks in the tracker.
+    *   **Update Project Overview:** Check if this Change Set impacts `knowzcode_project.md`:
+        - New major features → Update "Key Features" section
+        - New libraries/tools → Update "Technology Stack" table
+        - Architecture changes → Update "Architecture Decisions"
+        - Scope expansion → Update "Scope & Key Features"
+    *   **Final Commit:** Stage ALL changes using `git add -A` (this includes source code from implementation AND knowzcode/ files), then commit with a descriptive `feat:` message.
+
+### Final Report
+
+*   Once all steps above are complete, provide a final confirmation report.
+
+**Example Response Format:**
+> "Finalization for `WorkGroupID: [ID]` is complete.
+>
+> *   All specifications have been updated to the 'as-built' state.
+> *   The architecture flowchart has been checked and updated.
+> *   A complete `ARC-Completion` entry has been logged.
+> *   The tracker is updated, and all nodes are now `[VERIFIED]`.
+> *   **Project Overview Updates:** [None | Updated sections: Technology Stack, Key Features]
+> *   The final `feat:` commit has been made to version control.
+> *   **New Refactor Tasks Created:** [List any REFACTOR_ nodes created, or 'None'].
+>
+> This Change Set is now fully complete and documented. Awaiting next `PrimaryGoal` via a new Work Session."
+
+### Final State
+
+*   Upon successful completion, the KnowzCode loop for this `WorkGroupID` is **finished**. You will return to an idle state.
+
+---

package/knowzcode/specs/Readme.md

@@ -0,0 +1,10 @@
+\# Component Specifications
+
+
+
+This directory will contain specification files for each component (NodeID) in your project.
+
+
+
+Files will be named like: `API\_UserAuth.md`, `UI\_Dashboard.md`, etc.
+

package/knowzcode/telemetry_config.md

@@ -0,0 +1,89 @@
+# Telemetry Configuration
+
+> **This file configures telemetry sources for `/kc:telemetry` investigations.**
+>
+> Run `/kc:telemetry-setup` to auto-discover and configure sources.
+
+---
+
+## Sentry
+
+| Field | Value |
+|-------|-------|
+| Enabled | false |
+| Method | |
+| Organization | |
+
+### Environment Mapping
+
+| Environment | Project |
+|-------------|---------|
+| production | |
+| staging | |
+| dev | |
+
+---
+
+## Azure Application Insights
+
+| Field | Value |
+|-------|-------|
+| Enabled | false |
+| Subscription | |
+| Resource Group | |
+
+### Environment Mapping
+
+| Environment | App Name | App ID |
+|-------------|----------|--------|
+| production | | |
+| staging | | |
+| dev | | |
+
+---
+
+## Configuration Notes
+
+- **Sentry Method**: How to connect to Sentry (`cli` for Sentry CLI, `mcp` for MCP tools)
+- **Sentry Organization**: Your Sentry organization slug (e.g., `my-company`)
+- **Sentry Project**: Format is `org-slug/project-slug` (e.g., `my-company/backend-api`)
+- **App Insights App ID**: The Application ID from Azure portal (GUID format)
+- **Subscription**: Your Azure subscription ID (optional, uses default if not set)
+
+### Auto-Discovery
+
+Run `/kc:telemetry-setup` to:
+1. Detect installed telemetry tools (sentry-cli, az CLI)
+2. Verify authentication status
+3. Auto-discover available resources
+4. Interactively configure environment mappings
+5. Update this file with discovered values
+
+### Manual Configuration
+
+Edit the tables above directly to configure telemetry sources:
+
+```markdown
+## Sentry
+
+| Field | Value |
+|-------|-------|
+| Enabled | true |
+| Method | cli |
+| Organization | my-company |
+
+### Environment Mapping
+
+| Environment | Project |
+|-------------|---------|
+| production | my-company/backend-prod |
+| staging | my-company/backend-staging |
+| dev | my-company/backend-dev |
+```
+
+---
+
+## Last Updated
+
+- **Date**: (not configured)
+- **By**: (not configured)

package/knowzcode/user_preferences.md

@@ -0,0 +1,120 @@
+# User Development Preferences
+
+---
+
+**Purpose:** This document captures your personal development preferences and coding standards. These preferences integrate with KnowzCode's workflow while respecting your style and approach.
+
+**Last Updated:** [ISO timestamp - to be filled during init]
+**Source:** User-provided during initialization
+
+---
+
+## Core Principles
+
+[User-provided principles, or "Not configured"]
+
+*Examples:*
+- Test-Driven Development (TDD mandatory)
+- Immutable data structures preferred
+- Functional programming patterns
+- Domain-Driven Design (DDD)
+- SOLID principles
+
+---
+
+## Testing Approach
+
+[User-provided testing preferences, or "Follows KnowzCode TDD requirements"]
+
+*Examples:*
+- **Framework:** XUnit / Jest / PyTest / Playwright
+- **Style:** Behavior-driven / Unit-first / Integration-focused
+- **Coverage:** Minimum 80% / All public APIs / Critical paths only
+- **Patterns:** AAA (Arrange-Act-Assert) / Given-When-Then
+- **Mocking:** Moq / Jest mocks / unittest.mock
+
+---
+
+## Code Style
+
+[User-provided style preferences, or "Standard for language/framework"]
+
+*Examples:*
+- **Naming:** PascalCase for methods, camelCase for variables
+- **Structure:** Small functions (max 20 lines), single responsibility
+- **Comments:** Self-documenting code, minimal comments
+- **Formatting:** Prettier / Black / Standard formatter
+- **Linting:** ESLint / Flake8 / Custom rules
+
+---
+
+## Language-Specific Patterns
+
+[User-provided language-specific preferences, or "N/A"]
+
+*Examples (C#):*
+- Nullable reference types always enabled
+- Records for immutable DTOs
+- No null-suppression operators
+- FluentValidation for schema validation
+
+*Examples (JavaScript/TypeScript):*
+- Strict TypeScript mode
+- Functional components with hooks (React)
+- Async/await over promises
+- ESM imports
+
+*Examples (Python):*
+- Type hints for all public functions
+- Dataclasses for structured data
+- f-strings for formatting
+- PEP 8 compliance
+
+---
+
+## Quality Priorities
+
+[User-provided quality focus areas, or "Standard KnowzCode priorities"]
+
+*Rank your top priorities (1-5):*
+1. [e.g., Reliability / Security / Performance / Maintainability / Testability]
+2. [...]
+3. [...]
+4. [...]
+5. [...]
+
+---
+
+## Project-Specific Conventions
+
+[Any project-specific rules or patterns, or "See project CLAUDE.md"]
+
+*Examples:*
+- Database migrations must be reviewed before merge
+- All API endpoints require OpenAPI documentation
+- Error handling uses Result types (no exceptions)
+- Logging format: structured JSON with correlation IDs
+
+---
+
+## Integration with KnowzCode
+
+**Non-Negotiable (KnowzCode Framework):**
+- Test-Driven Development (TDD) is mandatory
+- Quality gates must pass at each phase
+- Living documentation must be maintained
+- Incremental verified progress required
+
+**Flexible (Your Preferences):**
+- Testing framework choice (as long as TDD followed)
+- Code style and naming conventions
+- Language-specific patterns
+- Quality priority ranking
+- Project-specific conventions
+
+**Conflict Resolution:**
+When your preferences conflict with KnowzCode requirements, the framework takes precedence for workflow aspects (TDD, quality gates), but your preferences apply for implementation style (naming, patterns, tools).
+
+---
+
+*This document should be reviewed and updated as project conventions evolve.*

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "knowzcode",
+  "version": "0.1.0",
+  "description": "Platform-agnostic AI development methodology with TDD, quality gates, and structured workflows",
+  "type": "module",
+  "bin": {
+    "knowzcode": "./bin/knowzcode.mjs"
+  },
+  "files": [
+    "bin/",
+    "knowzcode/",
+    "agents/",
+    "commands/",
+    "skills/",
+    ".claude-plugin/"
+  ],
+  "scripts": {
+    "prepublishOnly": "node bin/knowzcode.mjs --version"
+  },
+  "keywords": [
+    "ai",
+    "tdd",
+    "workflow",
+    "methodology",
+    "quality-gates",
+    "platform-agnostic",
+    "claude",
+    "codex",
+    "gemini",
+    "cursor",
+    "copilot",
+    "windsurf",
+    "development"
+  ],
+  "author": {
+    "name": "Alex Headscarf"
+  },
+  "homepage": "https://github.com/knowz-io/knowzcode",
+  "bugs": {
+    "url": "https://github.com/knowz-io/knowzcode/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/knowz-io/knowzcode.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/skills/alias-resolver.json

@@ -0,0 +1,15 @@
+{
+  "name": "alias-resolver",
+  "version": "1.0.0",
+  "description": "Resolves friendly natural-language aliases to KnowzCode canonical values (phase, audit, plan, workgroup_type).",
+  "parameters": [
+    {"name": "domain", "type": "string", "required": true},
+    {"name": "text", "type": "string", "required": false}
+  ],
+  "actions": [
+    {
+      "type": "python",
+      "code": "domain = (inputs.get('domain') or '').strip().lower()\ntext = (inputs.get('text') or '').strip().lower()\nresult = {'value': None}\nphase_map = {\n    '1a': {'agent': 'analyst', 'prompt': 'knowzcode/prompts/[LOOP_1A]__Propose_Change_Set.md'},\n    '1b': {'agent': 'architect', 'prompt': 'knowzcode/prompts/[LOOP_1B]__Draft_Specs.md'},\n    '2a': {'agent': 'builder', 'prompt': 'knowzcode/prompts/[LOOP_2A]__Implement_Change_Set.md'},\n    '2b': {'agent': 'reviewer', 'prompt': 'knowzcode/prompts/[LOOP_2B]__Verify_Implementation.md'},\n    '3': {'agent': 'closer', 'prompt': 'knowzcode/prompts/[LOOP_3]__Finalize_And_Commit.md'}\n}\nphase_synonyms = {\n    '1a': ['1a','loop 1a','analyze','analysis','impact','scope','change set','proposal'],\n    '1b': ['1b','loop 1b','spec','specs','draft','design','blueprint'],\n    '2a': ['2a','loop 2a','implement','implementation','build','code','develop'],\n    '2b': ['2b','loop 2b','verify','verification','audit','test','qa','review'],\n    '3': ['3','loop 3','final','finalize','finalization','commit','wrap up','close']\n}\naudit_map = {\n    'spec': 'knowzcode/prompts/Spec_Verification_Checkpoint.md',\n    'implementation': 'knowzcode/prompts/[LOOP_2B]__Verify_Implementation.md',\n    'architecture': None,\n    'security': None,\n    'integration': None\n}\naudit_synonyms = {\n    'spec': ['spec','specs','specification','checkpoint'],\n    'implementation': ['implementation','code','verify implementation','loop 2b'],\n    'architecture': ['architecture','arch','diagram','flowchart','structure'],\n    'security': ['security','sec','owasp','vulnerability'],\n    'integration': ['integration','holistic','system','end to end','e2e']\n}\nworkgroup_map = {'feat': 'feat','feature': 'feat','fix': 'fix','bug': 'fix','bugfix': 'fix','refactor': 'refactor','cleanup': 'refactor','issue': 'issue','incident': 'issue'}\nif domain == 'phase':\n    if not text:\n        key = '1a'\n    else:\n        key = None\n        for canonical, synonyms in phase_synonyms.items():\n            if text == canonical or text in synonyms or any(s in text for s in synonyms):\n                key = canonical\n                break\n        if key is None:\n            for canonical in phase_map.keys():\n                if text.replace(' ','') == canonical:\n                    key = canonical\n                    break\n        if key is None:\n            key = '1a'\n    data = phase_map[key]\n    result['value'] = key.upper()\n    result['prompt'] = data['prompt']\n    result['agent'] = data['agent']\n    result['requires_workgroup'] = data['agent'] != 'analyst'\nelif domain == 'audit':\n    if not text:\n        key = 'spec'\n    else:\n        key = None\n        for canonical, synonyms in audit_synonyms.items():\n            if text == canonical or text in synonyms or any(s in text for s in synonyms):\n                key = canonical\n                break\n        if key is None:\n            key = 'spec'\n    result['value'] = key\n    result['prompt'] = audit_map.get(key)\n    result['agent'] = 'reviewer'\nelif domain == 'plan':\n    result['value'] = text or ''\n    result['prompt'] = None\nelif domain == 'workgroup_type':\n    if not text:\n        value = 'feat'\n    else:\n        value = None\n        for key, mapped in workgroup_map.items():\n            if text == key or key in text:\n                value = mapped\n                break\n        if value is None:\n            value = workgroup_map.get(text, 'feat')\n    result['value'] = value\nelse:\n    result['value'] = text or ''\noutputs.update(result)\n"
+    }
+  ]
+}

package/skills/architecture-diff.json

@@ -0,0 +1,12 @@
+{
+  "name": "architecture-diff",
+  "version": "0.1.0",
+  "description": "Highlights differences between specs and the Mermaid flowchart in knowzcode_architecture.md.",
+  "parameters": [],
+  "actions": [
+    {
+      "type": "python",
+      "code": "from pathlib import Path\nimport re\narch = Path('knowzcode/knowzcode_architecture.md').read_text()\nspec_paths = list(Path('knowzcode/specs').glob('*.md'))\nnode_ids = {p.stem for p in spec_paths}\nmermaid_nodes = set(re.findall(r'([A-Z]{2,}_[A-Za-z0-9]+)', arch))\nmissing_in_arch = sorted(node_ids - mermaid_nodes)\nmissing_in_specs = sorted(mermaid_nodes - node_ids)\noutputs['missing_in_architecture'] = missing_in_arch\noutputs['missing_specs'] = missing_in_specs\n"
+    }
+  ]
+}

package/skills/check-installation-status.json

@@ -0,0 +1,14 @@
+{
+  "name": "check-installation-status",
+  "version": "2.0.0",
+  "description": "Checks if KnowzCode is initialized in the current project and reports current status",
+
+  "parameters": [],
+
+  "actions": [
+    {
+      "type": "python",
+      "code": "from pathlib import Path\n\nknowzcode_dir = Path('knowzcode')\n\nif not knowzcode_dir.exists():\n    outputs['initialized'] = False\n    outputs['commands_count'] = 0\n    outputs['skills_count'] = 0\n    outputs['agents_count'] = 0\n    outputs['has_required_files'] = False\n    exit()\n\n# Check required files exist\nrequired_files = [\n    'knowzcode_loop.md',\n    'knowzcode_tracker.md',\n    'knowzcode_project.md',\n    'knowzcode_architecture.md'\n]\n\nmissing_files = [f for f in required_files if not (knowzcode_dir / f).exists()]\nhas_required_files = len(missing_files) == 0\n\n# Count components from various possible locations\n\n# Check .claude directory\nclaude_dir = Path('.claude')\ncommands_count = 0\nskills_count = 0\nagents_count = 0\n\nif claude_dir.exists():\n    if (claude_dir / 'commands').exists():\n        commands_count = len(list((claude_dir / 'commands').glob('*.md')))\n    if (claude_dir / 'skills').exists():\n        skills_count = len(list((claude_dir / 'skills').glob('*.json')))\n    if (claude_dir / 'agents').exists():\n        agents_count = len(list((claude_dir / 'agents').glob('*.md')))\n    if (claude_dir / 'subagents').exists():\n        agents_count += len(list((claude_dir / 'subagents').glob('*.yaml')))\n\n# Also check top-level directories (plugin installation)\nif Path('commands').exists():\n    commands_count = max(commands_count, len(list(Path('commands').glob('*.md'))))\nif Path('skills').exists():\n    skills_count = max(skills_count, len(list(Path('skills').glob('*.json'))))\nif Path('agents').exists():\n    agents_count = max(agents_count, len(list(Path('agents').glob('*.md'))))\n\noutputs['initialized'] = has_required_files\noutputs['commands_count'] = commands_count\noutputs['skills_count'] = skills_count\noutputs['agents_count'] = agents_count\noutputs['has_required_files'] = has_required_files\noutputs['missing_files'] = missing_files if missing_files else None"
+    }
+  ]
+}

package/skills/continue.md

@@ -0,0 +1,105 @@
+---
+name: continue
+description: Detect continuation intent and resume active WorkGroup workflow
+trigger: User says "continue", "keep going", "resume", or similar continuation intent
+---
+
+# Continue Skill
+
+**Purpose**: Detect when user wants to continue work and resume the active WorkGroup with proper context restoration.
+
+## Trigger Patterns
+
+Activate when user message matches ANY of these patterns:
+- "continue"
+- "keep going"
+- "resume"
+- "carry on"
+- "next"
+- "continue with this"
+- "let's continue"
+- "keep working"
+
+**Context Requirements**:
+- Must be in a KnowzCode-initialized project (knowzcode/ directory exists)
+- Should NOT trigger if user is clearly giving new instructions
+- Should NOT trigger during explicit command execution
+
+## When NOT to Trigger
+
+- User is giving specific new instructions
+- User is asking a question
+- Already executing a /kc:* command
+- knowzcode/ directory doesn't exist
+
+## Skill Behavior
+
+When triggered:
+
+### Step 1: Find Active WorkGroup
+
+Search `knowzcode/knowzcode_tracker.md` for `[WIP]` entries.
+
+- **One active WorkGroup**: Use it automatically
+- **Multiple active**: Present options to user
+- **None active**: Inform user and suggest `/kc:work`
+
+### Step 2: Load WorkGroup Context
+
+Read `knowzcode/workgroups/{WorkGroupID}.md` to determine:
+- Current phase
+- Primary goal
+- Change Set
+- Outstanding todos
+
+### Step 3: Resume at Current Phase
+
+Read `knowzcode/knowzcode_loop.md` and resume the workflow at the detected phase.
+
+Create tasks only for the **remaining** phases (not completed ones):
+
+| Detected Phase | Remaining Work |
+|----------------|----------------|
+| 1A | All phases (1A → 1B → 2A → 2B → 3) |
+| 1B | Specs + implementation + audit + finalization |
+| 2A | Implementation + audit + finalization |
+| 2B | Audit + finalization |
+| 3 | Finalization only |
+
+**Detect execution mode** — check if you have Agent Teams capabilities (spawn/create teammate tools, requires `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`):
+
+- **If Agent Teams is available**: Read `knowzcode/claude_code_execution.md` for team conventions. Activate delegate mode — you coordinate only, never write code directly. For each remaining phase, spawn one teammate with the spawn prompt defined in the corresponding phase section of `/kc:work`, create a task, wait for completion, present quality gate, shut down teammate before the next phase. Shut down all teammates when done or on cancel.
+- **If Agent Teams is NOT available**: Use `Task()` calls to delegate each remaining phase to the named agent (subagent fallback).
+
+Follow the same phase delegation patterns (spawn prompts, quality gates, gap loop) as `/kc:work`.
+
+### Step 4: Present Status
+
+```markdown
+## Resuming WorkGroup: {wgid}
+
+**Goal**: {primary goal}
+**Phase**: {current phase}
+**NodeIDs**: {list}
+
+**Outstanding Todos**:
+{list from WorkGroup file}
+
+Continuing from where we left off...
+```
+
+Then proceed with the appropriate phase using the same agents as `/kc:work`.
+
+## Logging
+
+```markdown
+---
+**Type:** SkillActivation
+**Timestamp:** [timestamp]
+**Skill:** continue
+**Trigger:** User said "{user_message}"
+**WorkGroup:** {wgid}
+**Phase:** {current phase}
+**Logged By:** AI-Agent
+---
+```

package/skills/environment-guard.json

@@ -0,0 +1,12 @@
+{
+  "name": "environment-guard",
+  "version": "0.1.0",
+  "description": "Verifies that knowzcode/environment_context.md no longer contains placeholder brackets.",
+  "parameters": [],
+  "actions": [
+    {
+      "type": "python",
+      "code": "from pathlib import Path\ntext = Path('knowzcode/environment_context.md').read_text()\nplaceholders = [line.strip() for line in text.splitlines() if '[' in line and ']' in line]\nif placeholders:\n    raise ValueError('environment_context.md still contains placeholders: ' + ', '.join(placeholders[:5]))\n"
+    }
+  ]
+}

package/skills/generate-workgroup-id.json

@@ -0,0 +1,25 @@
+{
+  "name": "generate-workgroup-id",
+  "version": "0.2.0",
+  "description": "Generates a WorkGroupID following the KnowzCode convention [type]-[slug]-YYYYMMDD-HHMMSS. The slug is a 2-4 word descriptor extracted from the goal.",
+  "parameters": [
+    {
+      "name": "type",
+      "type": "string",
+      "required": true,
+      "description": "One of feat, fix, refactor, issue"
+    },
+    {
+      "name": "slug",
+      "type": "string",
+      "required": false,
+      "description": "A 2-4 word kebab-case descriptor (e.g., 'auth-jwt', 'dark-mode'). If not provided, generates ID without slug."
+    }
+  ],
+  "actions": [
+    {
+      "type": "python",
+      "code": "import datetime\nimport re\nallowed = {'feat', 'fix', 'refactor', 'issue'}\nwg_type = inputs['type']\nif wg_type not in allowed:\n    raise ValueError(f'Invalid type {wg_type!r}, expected one of {sorted(allowed)}')\ntimestamp = datetime.datetime.utcnow().strftime('%Y%m%d-%H%M%S')\nslug = inputs.get('slug', '')\nif slug:\n    # Sanitize slug: lowercase, replace spaces with hyphens, remove non-alphanumeric\n    slug = re.sub(r'[^a-z0-9-]', '', slug.lower().replace(' ', '-'))\n    slug = re.sub(r'-+', '-', slug).strip('-')[:25]  # Max 25 chars\n    outputs['workgroup_id'] = f'{wg_type}-{slug}-{timestamp}'\nelse:\n    outputs['workgroup_id'] = f'{wg_type}-{timestamp}'"
+    }
+  ]
+}

package/skills/install-knowzcode.json

@@ -0,0 +1,21 @@
+{
+  "name": "install-knowzcode",
+  "version": "2.0.0",
+  "description": "Initializes KnowzCode directory structure and required files in the current project",
+
+  "parameters": [
+    {
+      "name": "force",
+      "type": "boolean",
+      "required": false,
+      "description": "Force reinstall even if knowzcode/ exists"
+    }
+  ],
+
+  "actions": [
+    {
+      "type": "python",
+      "code": "import os\nimport json\nfrom pathlib import Path\nfrom datetime import datetime\n\n# Configuration\ntarget_dir = Path('knowzcode')\nforce = inputs.get('force', False)\n\n# Check if target exists\nif target_dir.exists() and not force:\n    outputs['success'] = False\n    outputs['error'] = 'knowzcode/ already exists. Use force=true to reinitialize'\n    outputs['already_installed'] = True\n    exit()\n\n# Create directory structure\ntarget_dir.mkdir(exist_ok=True)\n(target_dir / 'specs').mkdir(exist_ok=True)\n(target_dir / 'workgroups').mkdir(exist_ok=True)\n(target_dir / 'prompts').mkdir(exist_ok=True)\n(target_dir / 'planning').mkdir(exist_ok=True)\n\n# Create .gitignore if it doesn't exist\ngitignore_path = target_dir / '.gitignore'\nif not gitignore_path.exists():\n    gitignore_content = '''# KnowzCode gitignore - protects environment-specific files\n\n# Environment-specific (contains local paths, commands)\nenvironment_context.md\n\n# Session-specific work (can be regenerated)\nworkgroups/\n\n# Personal notes and scratch files\n*.local.md\n.scratch/\n'''\n    with open(gitignore_path, 'w') as f:\n        f.write(gitignore_content)\n\n# Note: The actual template files (knowzcode_loop.md, etc.) should be copied\n# from the plugin template directory or created by the /kc:init command.\n# This skill creates the structure; the command copies the content.\n\noutputs['success'] = True\noutputs['target_dir'] = str(target_dir)\noutputs['directories_created'] = ['specs', 'workgroups', 'prompts', 'planning']\noutputs['gitignore_created'] = not gitignore_path.exists()\noutputs['message'] = f'KnowzCode directory structure created at {target_dir}/'"
+    }
+  ]
+}

package/skills/load-core-context.json

@@ -0,0 +1,18 @@
+{
+  "name": "load-core-context",
+  "version": "0.1.0",
+  "description": "Loads the KnowzCode project overview, architecture, tracker, log header, and automation manifest for downstream steps.",
+  "parameters": [],
+  "actions": [
+    {
+      "type": "read_file",
+      "paths": [
+        "knowzcode/knowzcode_project.md",
+        "knowzcode/knowzcode_architecture.md",
+        "knowzcode/knowzcode_tracker.md",
+        "knowzcode/knowzcode_log.md",
+        "knowzcode/automation_manifest.md"
+      ]
+    }
+  ]
+}