codeforge-dev 1.12.0 → 1.14.1

package/.devcontainer/plugins/devs-marketplace/plugins/{code-directive → spec-workflow}/skills/spec-refine/SKILL.md

@@ -1,13 +1,16 @@
 ---
 name: spec-refine
 description: >-
-  This skill should be used when the user asks to "refine a spec",
-  "review spec assumptions", "validate spec decisions", "question the
-  spec", "iterate on the spec", "check spec for assumptions", "approve
-  the spec", "walk me through the spec", or needs iterative
-  user-driven refinement of a specification through structured
-  questioning rounds.
-version: 0.1.0
+  Guides iterative user-driven spec refinement through structured
+  questioning rounds that validate assumptions, tech decisions, and scope
+  boundaries. USE WHEN the user asks to "refine the spec", "review spec
+  assumptions", "validate spec decisions", "approve the spec", "walk me
+  through the spec", "check spec for assumptions", "iterate on the spec",
+  or works with [assumed] requirements needing user-approved upgrade.
+  DO NOT USE for creating new specs (use spec-new) or for post-
+  implementation updates (use spec-update).
+version: 0.2.0
+argument-hint: "[spec-path]"
 ---
 
 # Iterative Spec Refinement

package/.devcontainer/plugins/devs-marketplace/plugins/{code-directive → spec-workflow}/skills/spec-review/SKILL.md

@@ -1,12 +1,16 @@
 ---
 name: spec-review
 description: >-
-  This skill should be used when the user asks to "review the spec",
-  "check spec adherence", "verify implementation", "spec-review",
-  "does code match spec", "audit implementation", or needs a standalone
-  deep implementation review that reads the code and confirms full
-  adherence to a specification.
-version: 0.1.0
+  Performs a standalone deep implementation review by reading code and
+  verifying full adherence to a specification's requirements and acceptance
+  criteria. USE WHEN the user asks to "review the spec", "verify
+  implementation", "does code match spec", "audit implementation",
+  "check spec adherence", "run spec-review", "regression check", or
+  works with post-implementation verification and pre-release audits.
+  DO NOT USE for batch metadata audits across all specs (use spec-check)
+  or for updating spec status after review (use spec-update).
+version: 0.2.0
+argument-hint: "[spec-path]"
 ---
 
 # Spec Implementation Review

package/.devcontainer/plugins/devs-marketplace/plugins/{code-directive → spec-workflow}/skills/spec-update/SKILL.md

@@ -1,11 +1,16 @@
 ---
 name: spec-update
 description: >-
-  This skill should be used when the user asks to "update the spec",
-  "mark spec as implemented", "as-built update", "spec maintenance",
-  "update spec status", "finish the spec", or after implementing a
-  feature when the spec needs to reflect what was actually built.
-version: 0.1.0
+  Performs the as-built spec update after implementation, closing the loop
+  between what was planned and what was built by setting status, checking
+  off acceptance criteria, and adding implementation notes. USE WHEN the
+  user asks to "update the spec", "mark spec as implemented", "as-built
+  update", "finish the spec", "close the spec", "update spec status",
+  "sync spec with code", or works with post-implementation documentation.
+  DO NOT USE for verifying code against a spec (use spec-review first)
+  or for creating new specs (use spec-new).
+version: 0.2.0
+argument-hint: "[spec-path]"
 ---
 
 # As-Built Spec Update

package/.devcontainer/plugins/devs-marketplace/plugins/{code-directive → spec-workflow}/skills/specification-writing/SKILL.md

@@ -1,15 +1,15 @@
 ---
 name: specification-writing
 description: >-
-  This skill should be used when the user asks to "write a specification",
-  "create requirements", "define acceptance criteria", "write user stories",
-  "create a feature spec", "document requirements", "use EARS format",
-  "write Given/When/Then scenarios", "define edge cases for a feature",
-  "structure a product requirement document",
-  or discusses requirement formats, EARS templates, Gherkin syntax,
-  acceptance criteria patterns, specification structure,
-  or completeness checklists for feature definitions.
-version: 0.1.0
+  Teaches EARS requirement formats, Given/When/Then acceptance criteria,
+  and structured specification patterns for feature definitions. USE WHEN
+  the user asks to "write requirements", "use EARS format", "define
+  acceptance criteria", "write Given/When/Then scenarios", "create a
+  feature spec", "structure requirements", "write user stories", or works
+  with Gherkin syntax, FR/NFR numbering, and completeness checklists.
+  DO NOT USE for managing the spec lifecycle (create, refine, build,
+  review, update) — use the dedicated spec-* skills instead.
+version: 0.2.0
 ---
 
 # Specification Writing

package/.devcontainer/plugins/devs-marketplace/plugins/ticket-workflow/.claude-plugin/plugin.json

@@ -3,6 +3,5 @@
   "description": "EARS-based ticket workflow: create issues, plan implementation, review commits, create PRs",
   "author": {
     "name": "AnExiledDev"
-  },
-  "keywords": ["tickets", "github", "workflow", "ears", "issues", "pr"]
+  }
 }

package/.devcontainer/plugins/devs-marketplace/plugins/ticket-workflow/README.md

@@ -74,6 +74,34 @@ Each ticket created by `/ticket:new` includes:
 
 The plugin injects a system prompt that defines the assistant persona, coding standards (SOLID, DRY, KISS, YAGNI), testing standards, and the ticket workflow rules. This ensures consistent behavior across all four commands.
 
+## Installation
+
+### CodeForge DevContainer
+
+Pre-installed and activated automatically — no setup needed.
+
+### From GitHub
+
+Use this plugin in any Claude Code setup:
+
+1. Clone the [CodeForge](https://github.com/AnExiledDev/CodeForge) repository:
+
+   ```bash
+   git clone https://github.com/AnExiledDev/CodeForge.git
+   ```
+
+2. Enable the plugin in your `.claude/settings.json`:
+
+   ```json
+   {
+     "enabledPlugins": {
+       "ticket-workflow@<clone-path>/.devcontainer/plugins/devs-marketplace": true
+     }
+   }
+   ```
+
+   Replace `<clone-path>` with the absolute path to your CodeForge clone.
+
 ## Plugin Structure
 
 ```

package/.devcontainer/plugins/devs-marketplace/plugins/ticket-workflow/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+	"description": "Auto-link GitHub tickets on user prompt submission",
+	"hooks": {
+		"UserPromptSubmit": [
+			{
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/ticket-linker.py",
+						"timeout": 12
+					}
+				]
+			}
+		]
+	}
+}

package/.devcontainer/plugins/devs-marketplace/plugins/{code-directive → ticket-workflow}/scripts/ticket-linker.py

@@ -129,7 +129,15 @@ def main():
     if len(output) > TOTAL_OUTPUT_CAP:
         output = output[:TOTAL_OUTPUT_CAP] + "\n...(truncated)"
 
-    json.dump({"additionalContext": output}, sys.stdout)
+    json.dump(
+        {
+            "hookSpecificOutput": {
+                "hookEventName": "UserPromptSubmit",
+                "additionalContext": output,
+            }
+        },
+        sys.stdout,
+    )
     sys.exit(0)
 
 

package/.devcontainer/plugins/devs-marketplace/plugins/workspace-scope-guard/README.md

@@ -1,33 +1,49 @@
 # workspace-scope-guard
 
-Claude Code plugin that enforces working directory scope for all file operations. Blocks writes outside the current project directory and warns on reads outside it. Prevents accidental cross-project modifications in multi-project workspaces.
+Nuclear workspace scope enforcement for Claude Code. Blocks ALL operations (read, write, bash) outside the current working directory. Permanently blacklists `/workspaces/.devcontainer/` — no exceptions, no bypass, even from workspace root.
 
 ## What It Does
 
-Intercepts file operations (Read, Write, Edit, NotebookEdit, Glob, Grep) and checks whether the target path is within the current working directory:
+Intercepts all file and bash operations and enforces strict scope boundaries:
 
 | Operation | Out-of-scope behavior |
 |-----------|-----------------------|
-| Write, Edit, NotebookEdit | **Blocked** (exit 2) with error message |
-| Read, Glob, Grep | **Warned** (exit 0) with advisory context |
+| Write, Edit, NotebookEdit | **Blocked** (exit 2) |
+| Read, Glob, Grep | **Blocked** (exit 2) |
+| Bash | **Blocked** (exit 2) — two-layer detection |
+| Unknown tools | **Blocked** (exit 2) |
 
-When the current working directory is `/workspaces` (the workspace root), all operations are unrestricted.
+### Blacklisted Paths
 
-### Allowed Prefixes
+`/workspaces/.devcontainer/` is permanently blocked for ALL operations — reads, writes, and bash commands. This blacklist:
+
+- Runs BEFORE all other checks (scope, allowlist, cwd bypass)
+- Cannot be overridden, even when cwd is `/workspaces`
+- Prevents the most common scope escape: writing to the workspace-root devcontainer instead of the project's
+
+### Allowlisted Paths
 
 These paths are always permitted regardless of working directory:
 
 | Path | Reason |
 |------|--------|
-| `/workspaces/.claude/` | Claude Code configuration |
-| `/workspaces/.tmp/` | Temporary files |
-| `/workspaces/.devcontainer/` | Container configuration |
+| `/workspaces/.claude/` | Claude config, plans, rules |
 | `/tmp/` | System temp directory |
-| `/home/vscode/` | User home directory |
+
+### CWD Context Injection
+
+The plugin injects working directory awareness on four hook events:
+
+| Hook Event | Purpose |
+|-----------|---------|
+| SessionStart | Set scope context at session begin |
+| UserPromptSubmit | Remind scope on every prompt |
+| PreToolUse | Context alongside scope enforcement |
+| SubagentStart | Ensure subagents know their scope |
 
 ## How It Works
 
-### Hook Lifecycle
+### Hook Lifecycle (File Tools)
 
 ```
 Claude calls Read, Write, Edit, NotebookEdit, Glob, or Grep
@@ -36,24 +52,43 @@ Claude calls Read, Write, Edit, NotebookEdit, Glob, or Grep
        │
        └─→ guard-workspace-scope.py
             │
-            ├─→ cwd is /workspaces? → allow (unrestricted)
-            ├─→ No target path? → allow (tool defaults to cwd)
-            ├─→ Resolve path via os.path.realpath() (handles symlinks/worktrees)
-            ├─→ Path is within cwd? → allow
-            ├─→ Path matches allowed prefix? → allow
-            ├─→ Write tool + out of scope → exit 2 (block)
-            └─→ Read tool + out of scope → exit 0 (warn via additionalContext)
+            ├─→ Extract target path from tool input
+            ├─→ Resolve via os.path.realpath() (handles symlinks)
+            ├─→ BLACKLIST check (first!) → exit 2 if blacklisted
+            ├─→ cwd is /workspaces? → allow (bypass, blacklist already checked)
+            ├─→ Path within cwd? → allow
+            ├─→ Path on allowlist? → allow
+            └─→ Out of scope → exit 2 (block)
 ```
 
-### Symlink and Worktree Handling
+### Hook Lifecycle (Bash)
+
+```
+Claude calls Bash
+  │
+  └─→ PreToolUse hook fires
+       │
+       └─→ guard-workspace-scope.py
+            │
+            ├─→ Extract write targets (Layer 1) + workspace paths (Layer 2)
+            ├─→ BLACKLIST check on ALL extracted paths → exit 2 if any blacklisted
+            ├─→ cwd is /workspaces? → allow (bypass, blacklist already checked)
+            ├─→ Layer 1: Check write targets against scope
+            │    ├─→ System command exemption (only if ALL targets are system paths)
+            │    └─→ exit 2 if any write target out of scope
+            └─→ Layer 2: Scan ALL /workspaces/ paths in command (ALWAYS runs)
+                 └─→ exit 2 if any workspace path out of scope
+```
 
-Target paths are resolved with `os.path.realpath()` before scope checking. This correctly handles:
-- Symbolic links that point outside the working directory
-- Git worktree paths (`.git` file containing `gitdir:`)
+### Bash Two-Layer Detection
 
-### Path Field Mapping
+**Layer 1 — Write target extraction:** 20+ regex patterns extract file paths from write operations (redirects, cp, mv, touch, mkdir, rm, ln, rsync, chmod, chown, dd, wget, curl, tar, unzip, gcc, sqlite3, etc.). Each target is resolved and scope-checked.
 
-The script extracts the target path from different tool input fields:
+System commands (git, pip, npm, etc.) get a Layer 1 exemption ONLY when ALL write targets resolve to system paths (`/usr/`, `/bin/`, `/sbin/`, `/lib/`, `/opt/`, `/proc/`, `/sys/`, `/dev/`, `/var/`, `/etc/`). Any `/workspaces/` write target outside cwd cancels the exemption.
+
+**Layer 2 — Workspace path scan (ALWAYS runs):** Regex scans the entire command for any `/workspaces/` path string. Catches paths in inline scripts (`python3 -c`), variable assignments, quoted strings, and anything Layer 1 misses. No exemptions, no bypass.
+
+### Path Field Mapping
 
 | Tool | Input Field |
 |------|-------------|
@@ -63,29 +98,66 @@ The script extracts the target path from different tool input fields:
 | NotebookEdit | `notebook_path` |
 | Glob | `path` |
 | Grep | `path` |
+| Bash | `command` (multi-path extraction) |
 
 ### Error Handling
 
 | Scenario | Behavior |
 |----------|----------|
-| JSON parse failure | Fails open (exit 0) |
-| Other exceptions | Fails open (exit 0) — logs error to stderr |
+| JSON parse failure | **Blocked** (exit 2) — fail closed |
+| Any exception | **Blocked** (exit 2) — fail closed |
+| Hook timeout | Fails open (Claude Code runtime limitation) — mitigated by 10s timeout and pure computation (no I/O) |
+
+## Known Limitations
+
+| Limitation | Why It's Accepted |
+|-----------|-------------------|
+| Pre-set env vars (`$OUTDIR/file` from prior command) | Layer 2 only catches literal `/workspaces/` strings. Variable set in same command IS caught. |
+| Base64-encoded paths | Not an accidental misuse pattern |
+| Bash brace expansion | Not an accidental directory construction pattern |
+| Variable concatenation across statements | No single literal path exists to match |
+| Hook timeout fails open | Mitigated: 10s timeout, pure computation, no I/O |
+
+## Installation
+
+### CodeForge DevContainer
+
+Pre-installed and activated automatically — no setup needed.
+
+### From GitHub
+
+Use this plugin in any Claude Code setup:
+
+1. Clone the [CodeForge](https://github.com/AnExiledDev/CodeForge) repository:
+
+   ```bash
+   git clone https://github.com/AnExiledDev/CodeForge.git
+   ```
+
+2. Enable the plugin in your `.claude/settings.json`:
 
-### Timeout
+   ```json
+   {
+     "enabledPlugins": {
+       "workspace-scope-guard@<clone-path>/.devcontainer/plugins/devs-marketplace": true
+     }
+   }
+   ```
 
-The hook has a 5-second timeout.
+   Replace `<clone-path>` with the absolute path to your CodeForge clone.
 
 ## Plugin Structure
 
 ```
 workspace-scope-guard/
 ├── .claude-plugin/
-│   └── plugin.json                # Plugin metadata
+│   └── plugin.json                  # Plugin metadata
 ├── hooks/
-│   └── hooks.json                 # PreToolUse hook registration
+│   └── hooks.json                   # Hook registrations (6 events)
 ├── scripts/
-│   └── guard-workspace-scope.py   # Scope enforcement (PreToolUse)
-└── README.md                      # This file
+│   ├── guard-workspace-scope.py     # Scope enforcement (PreToolUse)
+│   └── inject-workspace-cwd.py      # CWD context injection (4 events)
+└── README.md                        # This file
 ```
 
 ## Requirements

package/.devcontainer/plugins/devs-marketplace/plugins/workspace-scope-guard/hooks/hooks.json

@@ -1,14 +1,60 @@
 {
-	"description": "Enforce workspace scope for file operations",
+	"description": "Nuclear workspace scope enforcement — blocks all operations outside cwd, permanently blacklists /workspaces/.devcontainer/",
 	"hooks": {
 		"PreToolUse": [
 			{
-				"matcher": "Read|Write|Edit|NotebookEdit|Glob|Grep",
+				"matcher": "Read|Write|Edit|NotebookEdit|Glob|Grep|Bash",
 				"hooks": [
 					{
 						"type": "command",
 						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/guard-workspace-scope.py",
-						"timeout": 5
+						"timeout": 10
+					}
+				]
+			},
+			{
+				"matcher": "",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/inject-workspace-cwd.py",
+						"timeout": 3
+					}
+				]
+			}
+		],
+		"SessionStart": [
+			{
+				"matcher": "",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/inject-workspace-cwd.py",
+						"timeout": 3
+					}
+				]
+			}
+		],
+		"UserPromptSubmit": [
+			{
+				"matcher": "",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/inject-workspace-cwd.py",
+						"timeout": 3
+					}
+				]
+			}
+		],
+		"SubagentStart": [
+			{
+				"matcher": "",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${CLAUDE_PLUGIN_ROOT}/scripts/inject-workspace-cwd.py",
+						"timeout": 3
 					}
 				]
 			}