@warpgogol/forge 2.21.8 → 3.0.0

package/profiles/typescript-turborepo.yaml

@@ -144,6 +144,321 @@ workspace:
     - path: .gitattributes
       content: |
         # No LFS patterns for this stack
+    - path: hooks/pre-commit
+      content: |
+        #!/bin/sh
+        # Platform-scope pre-commit guard
+        # Runs forge validation before commits
+        echo "Pre-commit: running platform checks..."
+        pnpm exec forge run forge.validate || exit 1
+    - path: scripts/git-guard.sh
+      content: |
+        #!/bin/bash
+        # git-guard.sh — shell function that intercepts destructive git commands.
+        # Sourced by ~/.zshenv (via setup-git-guards.sh).
+        # Guards (only active in repos containing scripts/git-guard.sh):
+        #   git stash, git reset --hard, git checkout --, git checkout -f,
+        #   git switch -f, git clean -f, git restore
+        # Override: ALLOW_DESTRUCTIVE_GIT=1 git stash
+
+        export FORGE_GIT_GUARD=1
+
+        _git_guard_find_root() {
+          local _repo_root _dir
+          _repo_root="$(command git rev-parse --show-toplevel 2>/dev/null || echo "")"
+          if [ -z "$_repo_root" ]; then echo ""; return; fi
+          if [ -f "$_repo_root/scripts/git-guard.sh" ]; then echo "$_repo_root"; return; fi
+          _dir="$(dirname "$_repo_root")"
+          while [ -n "$_dir" ] && [ "$_dir" != "/" ]; do
+            if [ -f "$_dir/scripts/git-guard.sh" ]; then echo "$_dir"; return; fi
+            _dir="$(dirname "$_dir")"
+          done
+          echo ""
+        }
+
+        git() {
+          local _guard_root
+          _guard_root="$(_git_guard_find_root)"
+          if [ -z "$_guard_root" ] || [ -n "${ALLOW_DESTRUCTIVE_GIT:-}" ]; then
+            command git "$@"; return $?
+          fi
+          local _all_args=("$@") _i=0 _cmd="" _cmd_index=0
+          while [ "$_i" -lt "${#_all_args[@]}" ]; do
+            local _arg="${_all_args[$_i]}"
+            case "$_arg" in
+              -C|-c|--git-dir|--work-tree|--namespace) _i=$((_i + 2)); continue ;;
+              -*) _i=$((_i + 1)); continue ;;
+            esac
+            _cmd="$_arg"; _cmd_index="$_i"; break
+          done
+          local _sub_args=() _j=$((_cmd_index + 1))
+          while [ "$_j" -lt "${#_all_args[@]}" ]; do
+            _sub_args+=("${_all_args[$_j]}"); _j=$((_j + 1))
+          done
+          case "$_cmd" in
+            stash)
+              echo "BLOCKED: git stash is disabled in agent sessions." >&2
+              echo "Set ALLOW_DESTRUCTIVE_GIT=1 to override." >&2; return 1 ;;
+            reset)
+              for _arg in "${_sub_args[@]}"; do
+                if [ "$_arg" = "--hard" ] || [[ "$_arg" == --hard=* ]]; then
+                  echo "BLOCKED: git reset --hard is disabled." >&2; return 1
+                fi
+              done; command git "$@"; return $? ;;
+            checkout)
+              for _arg in "${_sub_args[@]}"; do
+                if [ "$_arg" = "--" ]; then
+                  echo "BLOCKED: git checkout -- is disabled." >&2; return 1
+                fi
+                case "$_arg" in -f*|--force*)
+                  echo "BLOCKED: git checkout -f is disabled." >&2; return 1 ;;
+                esac
+              done; command git "$@"; return $? ;;
+            switch)
+              for _arg in "${_sub_args[@]}"; do
+                case "$_arg" in -f*|--force*)
+                  echo "BLOCKED: git switch -f is disabled." >&2; return 1 ;;
+                esac
+              done; command git "$@"; return $? ;;
+            restore)
+              echo "BLOCKED: git restore is disabled." >&2; return 1 ;;
+            clean)
+              for _arg in "${_sub_args[@]}"; do
+                case "$_arg" in -f*|--force*)
+                  echo "BLOCKED: git clean -f is disabled." >&2; return 1 ;;
+                esac
+              done; command git "$@"; return $? ;;
+            *) command git "$@"; return $? ;;
+          esac
+        }
+    - path: scripts/setup-git-guards.sh
+      content: |
+        #!/bin/bash
+        # setup-git-guards.sh — install shell function guards for destructive git ops.
+        # Auto-detects shell: zsh → ~/.zshenv, bash → ~/.bashrc (Git Bash on Windows).
+        set -euo pipefail
+        repo_root="$(git rev-parse --show-toplevel 2>/dev/null || echo "")"
+        if [ -z "$repo_root" ]; then echo "ERROR: not inside a git repository" >&2; exit 1; fi
+        guard_script="$repo_root/scripts/git-guard.sh"
+        marker="# forge-git-guard"
+        # Auto-detect target profile file based on current shell
+        case "${SHELL:-}" in
+          *zsh*) profile_file="${HOME}/.zshenv" ;;
+          *bash*) profile_file="${HOME}/.bashrc" ;;
+          *) profile_file="${HOME}/.bashrc" ;;
+        esac
+        mode="${1:-install}"
+        case "$mode" in
+          install)
+            if [ ! -f "$guard_script" ]; then echo "ERROR: $guard_script not found" >&2; exit 1; fi
+            chmod +x "$guard_script" 2>/dev/null || true
+            if [ -f "$profile_file" ]; then
+              tmp="$(mktemp)"
+              awk -v marker="$marker" '$0 == marker { skip=2; next } skip > 0 { skip--; next } { print }' "$profile_file" > "$tmp" || true
+              mv "$tmp" "$profile_file" 2>/dev/null || true
+            fi
+            echo "" >> "$profile_file"
+            echo "$marker" >> "$profile_file"
+            echo "[ -f \"$guard_script\" ] && source \"$guard_script\"" >> "$profile_file"
+            echo "Git guards installed into $profile_file. Restart your shell or run: source $guard_script" ;;
+          --verify)
+            if [ -z "${FORGE_GIT_GUARD:-}" ]; then echo "MISSING: git guard not loaded" >&2; exit 1; fi
+            if ! grep -qF "$marker" "$profile_file" 2>/dev/null; then echo "MISSING: guard not in $profile_file" >&2; exit 1; fi
+            echo "OK: git guards installed and loaded" ;;
+          --remove)
+            if [ -f "$profile_file" ]; then
+              tmp="$(mktemp)"
+              awk -v marker="$marker" '$0 == marker { skip=2; next } skip > 0 { skip--; next } { print }' "$profile_file" > "$tmp" || true
+              mv "$tmp" "$profile_file" 2>/dev/null || true
+            fi
+            echo "Git guards removed from $profile_file" ;;
+          *) echo "Usage: bash scripts/setup-git-guards.sh [install|--verify|--remove]" >&2; exit 1 ;;
+        esac
+    - path: scripts/clean-stale-stashes.sh
+      content: |
+        #!/bin/bash
+        # clean-stale-stashes.sh — detect and optionally drop stale git stash entries.
+        # Usage: bash scripts/clean-stale-stashes.sh [--drop|--drop-all]
+        set -euo pipefail
+        repo_root="$(git rev-parse --show-toplevel 2>/dev/null || echo "")"
+        if [ -z "$repo_root" ]; then echo "ERROR: not inside a git repository" >&2; exit 1; fi
+        mode="report"
+        if [ "${1:-}" = "--drop" ]; then mode="drop"; elif [ "${1:-}" = "--drop-all" ]; then mode="drop-all"; fi
+        stash_count="$(git -C "$repo_root" stash list 2>/dev/null | wc -l)"
+        if [ "$stash_count" -eq 0 ]; then exit 0; fi
+        stale_indices=() total="$stash_count"
+        for ((i = 0; i < total; i++)); do
+          ref="stash@{$i}"
+          if [ "$mode" = "drop-all" ]; then stale_indices+=("$i"); continue; fi
+          tracked_changes="$(git -C "$repo_root" stash show "$ref" --stat 2>/dev/null || true)"
+          untracked_files="$(git -C "$repo_root" stash show --include-untracked "$ref" --stat 2>/dev/null || true)"
+          if [ -z "$tracked_changes" ] && [ -z "$untracked_files" ]; then stale_indices+=("$i"); continue; fi
+          if [ -z "$tracked_changes" ] && [ -n "$untracked_files" ]; then
+            all_committed=true
+            while IFS= read -r filepath; do
+              [ -z "$filepath" ] && continue
+              if ! git -C "$repo_root" cat-file -e "HEAD:$filepath" 2>/dev/null; then all_committed=false; break; fi
+            done < <(git -C "$repo_root" stash show --include-untracked "$ref" --name-only 2>/dev/null || true)
+            if [ "$all_committed" = true ]; then stale_indices+=("$i"); fi
+          fi
+        done
+        if [ ${#stale_indices[@]} -eq 0 ]; then exit 0; fi
+        if [ "$mode" = "report" ]; then
+          echo "STALE STASH ENTRIES DETECTED (${#stale_indices[@]} of $stash_count):"
+          for idx in "${stale_indices[@]}"; do
+            echo "  stash@{$idx}: $(git -C "$repo_root" stash list | sed -n "$((idx + 1))p")"
+          done
+          echo "Clean with: bash scripts/clean-stale-stashes.sh --drop"; exit 1
+        fi
+        if [ "$mode" = "drop-all" ]; then git -C "$repo_root" stash clear; echo "Dropped all $stash_count entries."; exit 0; fi
+        for ((i = ${#stale_indices[@]} - 1; i >= 0; i--)); do
+          idx="${stale_indices[$i]}"
+          git -C "$repo_root" stash drop "stash@{$idx}" 2>/dev/null || true
+        done
+        echo "Dropped ${#stale_indices[@]} stale entry/entries."; exit 0
+    - path: scripts/check-clean-trees.sh
+      content: |
+        #!/bin/bash
+        # check-clean-trees.sh — verify all git trees are clean.
+        # Checks repo root + all nested .git directories up to 3 levels deep.
+        set -euo pipefail
+        repo_root="$(git rev-parse --show-toplevel 2>/dev/null || echo "")"
+        if [ -z "$repo_root" ]; then echo "ERROR: not inside a git repository" >&2; exit 1; fi
+        dirty=0 output=""
+        main_status="$(git -C "$repo_root" status --short 2>/dev/null || true)"
+        if [ -n "$main_status" ]; then
+          output+="DIRTY: $repo_root\n$(printf '%s\n' "$main_status" | sed 's/^/  /')\n"
+          dirty=1
+        fi
+        while IFS= read -r gitdir; do
+          nested_root="$(dirname "$gitdir")"
+          [ "$nested_root" = "$repo_root" ] && continue
+          nested_status="$(git -C "$nested_root" status --short 2>/dev/null || true)"
+          if [ -n "$nested_status" ]; then
+            output+="DIRTY: $nested_root\n$(printf '%s\n' "$nested_status" | sed 's/^/  /')\n"
+            dirty=1
+          fi
+        done < <(find "$repo_root" -maxdepth 3 -name ".git" -type d 2>/dev/null | head -20)
+        if [ "$dirty" -eq 1 ]; then
+          echo -e "$output" | head -40
+          echo "---"
+          echo "Uncommitted changes detected. Commit before session end."
+          exit 1
+        fi
+        exit 0
+    - path: hooks/pre-user-prompt.sh
+      content: |
+        #!/bin/bash
+        # Pre-user-prompt hook: session-end protocol + stale-stash + git-guard checks.
+        # Requires jq for JSON payload parsing.
+        set -euo pipefail
+        payload="$(cat)"
+        user_prompt="$(printf '%s' "$payload" | jq -r '.tool_info.user_prompt // empty' 2>/dev/null || true)"
+        if [ -z "$user_prompt" ]; then exit 0; fi
+        repo_root="$(git rev-parse --show-toplevel 2>/dev/null || echo "")"
+        if [ -n "$repo_root" ] && [ -x "$repo_root/scripts/clean-stale-stashes.sh" ]; then
+          stash_output="$("$repo_root/scripts/clean-stale-stashes.sh" 2>&1 || true)"
+          if [ -n "$stash_output" ]; then
+            echo "⚠️  STALE GIT STASH DETECTED" >&2
+            echo "$stash_output" >&2
+            echo "Clean with: bash scripts/clean-stale-stashes.sh --drop" >&2
+            echo "" >&2
+          fi
+        fi
+        if [ -n "$repo_root" ] && [ -f "$repo_root/scripts/git-guard.sh" ]; then
+          if [ -z "${FORGE_GIT_GUARD:-}" ]; then
+            echo "⚠️  GIT GUARD NOT LOADED — destructive git operations are NOT blocked." >&2
+            echo "Run: source $repo_root/scripts/git-guard.sh" >&2
+            echo "" >&2
+          fi
+        fi
+        session_end_phrases=("Завершаем эту сессию" "Завершаем сессию" "Заканчиваем сессию" "Завершить сессию" "End session" "Wrap up" "Session end" "/session-end")
+        matched=""
+        for phrase in "${session_end_phrases[@]}"; do
+          if printf '%s' "$user_prompt" | grep -qiF "$phrase"; then matched="$phrase"; break; fi
+        done
+        if [ -z "$matched" ]; then exit 0; fi
+        cat >&2 <<EOF
+        SESSION-END PROTOCOL TRIGGERED (matched: "$matched")
+        The user's original message was:
+          > $user_prompt
+        You MUST invoke the fo-session-retro skill via the skill tool BEFORE producing
+        any other output. This is a NON-NEGOTIABLE BLOCKED GATE per PREFERENCES.md.
+        DO NOT produce a closing summary or ad-hoc output. The closing block must come
+        from fo-session-retro's report.
+        Protocol steps:
+        1. Verify clean working trees — run: bash scripts/check-clean-trees.sh
+        2. Invoke fo-session-retro via the skill tool
+        3. The retro skill's report IS the session-end output
+        EOF
+        if [ -n "$repo_root" ] && [ -x "$repo_root/scripts/check-clean-trees.sh" ]; then
+          tree_output="$("$repo_root/scripts/check-clean-trees.sh" 2>&1 || true)"
+          if [ -n "$tree_output" ]; then echo "" >&2; echo "$tree_output" >&2; fi
+        fi
+        exit 2
+    - path: hooks/pre-user-prompt-wrapper.mjs
+      content: |
+        #!/usr/bin/env node
+        // pre-user-prompt-wrapper.mjs — cross-platform wrapper for pre-user-prompt.sh.
+        // Detects bash availability, prints one-time warning if bash not found,
+        // then delegates to bash hooks/pre-user-prompt.sh with stdin piped.
+        import { execFileSync, spawn } from "node:child_process";
+        import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+        import { dirname, join } from "node:path";
+        import { fileURLToPath } from "node:url";
+
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const scriptPath = join(__dirname, "pre-user-prompt.sh");
+        const cacheDir = join(__dirname, "..", ".cache");
+        const warningFlag = join(cacheDir, "git-guard-warning-sent");
+
+        // If pre-user-prompt.sh doesn't exist, silently exit
+        if (!existsSync(scriptPath)) {
+          process.exit(0);
+        }
+
+        // Check if bash is available
+        let bashAvailable = false;
+        try {
+          execFileSync("bash", ["--version"], { stdio: "ignore" });
+          bashAvailable = true;
+        } catch {
+          bashAvailable = false;
+        }
+
+        if (!bashAvailable) {
+          // Print one-time warning if not already sent
+          if (!existsSync(warningFlag)) {
+            console.error("⚠️  bash not found — pre-user-prompt hook is disabled.");
+            console.error("Install Git Bash (Git for Windows) or WSL to enable agent-safety hooks.");
+            console.error("");
+            try {
+              mkdirSync(cacheDir, { recursive: true });
+              writeFileSync(warningFlag, new Date().toISOString(), "utf8");
+            } catch {
+              // Best-effort — don't crash if cache dir is not writable
+            }
+          }
+          process.exit(0);
+        }
+
+        // Delegate to bash script with stdin piped
+        const child = spawn("bash", [scriptPath], { stdio: ["inherit", "inherit", "inherit"] });
+        child.on("exit", (code) => {
+          process.exit(code ?? 0);
+        });
+    - path: .windsurf/hooks.json
+      content: |
+        {
+          "hooks": {
+            "pre_user_prompt": [
+              {
+                "command": "node $ROOT_WORKSPACE_PATH/hooks/pre-user-prompt-wrapper.mjs",
+                "show_output": true
+              }
+            ]
+          }
+        }
     - path: tools/kernel.config.ts
       content: |
         import { defineKernelConfig } from "@warpgogol/werkstatt-engine/kernel/types";
@@ -183,6 +498,14 @@ workspace:
             mode: protect
           - path: tsconfig.base.json
             mode: protect
+          - path: scripts/git-guard.sh
+            mode: protect
+          - path: scripts/setup-git-guards.sh
+            mode: protect
+          - path: hooks/pre-user-prompt.sh
+            mode: protect
+          - path: hooks/pre-user-prompt-wrapper.mjs
+            mode: protect
     - path: README.md
       content: |
         # __PROJECT_NAME__
@@ -193,6 +516,8 @@ workspace:
 
         - Node.js 24+
         - pnpm 10+
+        - jq (for pre-user-prompt hook)
+        - On Windows: Git Bash or WSL (for shell scripts)
 
         ## Setup
 
@@ -206,7 +531,19 @@ workspace:
         pnpm install
         ```
 
-        ### 3. Verify the workshop
+        ### 3. Install git guards (recommended)
+
+        Git guards prevent AI agents from running destructive git commands (`git stash`, `git reset --hard`, `git checkout --`, `git restore`, `git clean -f`):
+
+        ```sh
+        bash scripts/setup-git-guards.sh
+        ```
+
+        This installs a shell function into your shell profile (`~/.zshenv` for zsh, `~/.bashrc` for bash/Git Bash). Restart your shell or run `source scripts/git-guard.sh`.
+
+        > **Windows**: Git guards require Git Bash (included with Git for Windows). Run `bash scripts/setup-git-guards.sh` from Git Bash. If bash is not in PATH, the pre-user-prompt hook wrapper prints a one-time warning. Install `jq` via `winget install jqlang.jq` or `choco install jq`.
+
+        ### 4. Verify the workshop
 
         ```sh
         pnpm exec forge run forge.doctor

package/src/onboarding/init.ts

@@ -21,6 +21,7 @@
   <item>RFC-0643: accept optional profileId and write it to forge.yaml as the `profile` field.</item>
   <item>RFC-0663: added syncSharedKnowledge step to sync shared knowledge layer to .agents/skills/shared-knowledge/.</item>
   <item>RFC-0941: create forge.plugin.yaml manifests for skill packs that lack them before calling discoverPackSkills.</item>
+  <item>RFC-1019: extend PREFERENCES.md with formOfAddress, session-end protocol, skill invocation tracking, plan confirmation vs implementation, commit granularity rules.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -186,14 +187,63 @@ export function runInit(
     }
   }
 
-  // 2. Create PREFERENCES.md if missing
+  // 2. Create PREFERENCES.md if missing (RFC-1019: extended with formOfAddress and operational rules)
   const prefsPath = path.join(workspaceRoot, "PREFERENCES.md");
   const register = domainFields?.register ?? "business";
+  const formOfAddress = "formal";
   if (fs.existsSync(prefsPath)) {
     skipped.push("PREFERENCES.md (already exists)");
   } else {
-    const prefsContent = `---\naiLanguage: ${aiLang}\ndocumentationLanguage: ${docLang}\nregister: ${register}\n---\n\n# Operator Preferences\n\n- \`aiLanguage\`: ${aiLang} — AI uses this language for all communication with the operator.\n- \`documentationLanguage\`: ${docLang} — generated documentation uses this language.\n- \`register\`: ${register} — communication register (business or creative).\n`;
-    fs.writeFileSync(prefsPath, prefsContent, "utf8");
+    const prefsContent = [
+      "---",
+      `aiLanguage: ${aiLang}`,
+      `documentationLanguage: ${docLang}`,
+      `register: ${register}`,
+      `formOfAddress: ${formOfAddress}`,
+      "---",
+      "",
+      "# Operator Preferences",
+      "",
+      "This file stores operator-level preferences that AI agents read at the start of a session.",
+      "",
+      "## Current preferences",
+      "",
+      `- \`aiLanguage\` — ${aiLang} — AI uses this language for all communication with the operator.`,
+      `- \`documentationLanguage\` — ${docLang} — generated documentation uses this language.`,
+      `- \`register\` — ${register} — communication register (business or creative).`,
+      `- \`formOfAddress\` — ${formOfAddress} — form of address (formal or informal).`,
+      "",
+      "## Plan confirmation vs implementation command (NON-NEGOTIABLE)",
+      "",
+      "Confirming a plan or design during grilling/discussion means the operator agrees with the approach — it is NOT a command to start implementation. The agent MUST wait for an explicit implementation command (\"implement\", \"go ahead\", \"реализуй\", \"начинай\") before writing any code beyond the RFC/ADR document itself.",
+      "",
+      "- **RFC creation** → agent creates the RFC file in `draft` status. No code changes.",
+      "- **Plan confirmation** → agent stops. No status change, no implementation, no todo list items moved to `in_progress`.",
+      "- **Implementation command** → only now does the agent begin coding, register commands, write tests, etc.",
+      "",
+      "If the agent is unsure whether the operator's message is a confirmation or a command to implement, the agent MUST ask for clarification before proceeding.",
+      "",
+      "## Skill invocation tracking",
+      "",
+      "When a skill is invoked (e.g. `fo-idea-i-just-want-to-see-the-result`), the agent MUST complete the full skill pipeline. Stopping halfway (e.g. after `fo-idea-create-rfc` when the operator asked for the full result) is a protocol violation. If a step fails, the agent reports the failure and asks for guidance — it does not silently skip remaining steps.",
+      "",
+      "## Commit granularity",
+      "",
+      "One logical fix = one commit, regardless of how many iterations were needed to produce it. Do not split a single logical change into multiple commits just because multiple edit rounds were needed. Conversely, do not combine unrelated changes into a single commit.",
+      "",
+      "## Session-end protocol",
+      "",
+      "When the operator signals session end (phrases like \"End session\", \"Wrap up\", \"Завершаем сессию\", \"/session-end\"), the agent MUST:",
+      "",
+      "1. Verify clean working trees — run: `bash scripts/check-clean-trees.sh`",
+      "2. Commit any uncommitted changes before proceeding",
+      "3. Invoke the `fo-session-retro` skill via the skill tool",
+      "4. The retro skill's report IS the session-end output — do not produce a separate closing summary",
+      "",
+      "This protocol is enforced by the `hooks/pre-user-prompt.sh` hook as a blocked gate.",
+      "",
+    ].join("\n");
+    fs.writeFileSync(prefsPath, prefsContent + "\n", "utf8");
     created.push("PREFERENCES.md");
   }
 

package/src/tests/create.test.ts

@@ -5,6 +5,7 @@
 <CHANGE_SUMMARY>
   <item>RFC-0544: initial forge.create tests.</item>
   <item>RFC-0877: rewrite tests for --in-place mode, add strict empty-directory check and name-derivation tests.</item>
+  <item>RFC-1019: add tests for pre-user-prompt-wrapper.mjs, shell auto-detection, hooks.json wrapper, pinned.yaml.</item>
 </CHANGE_SUMMARY>
 */
 
@@ -62,6 +63,7 @@ test("forge create --in-place scaffolds in cwd with forge.yaml and docs dirs", a
   expect(existsSync(join(tempDir, "PREFERENCES.md"))).toBe(true);
   expect(existsSync(join(tempDir, "package.json"))).toBe(true);
   expect(existsSync(join(tempDir, "scripts", "clean.mjs"))).toBe(true);
+  expect(existsSync(join(tempDir, "hooks", "pre-user-prompt-wrapper.mjs"))).toBe(true);
 }, 30000);
 
 test("forge create --in-place refuses when forge artifacts already exist", async () => {
@@ -305,6 +307,45 @@ test("forge create --profile godot-csharp writes compass.fileExtensions into for
   expect(forgeYaml).toContain(".gd");
 }, 30000);
 
+test("forge create --in-place setup-git-guards.sh contains shell auto-detection (RFC-1019)", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+
+  const { readFile: readFileAsync } = await import("node:fs/promises");
+  const setupScript = await readFileAsync(join(tempDir, "scripts", "setup-git-guards.sh"), "utf8");
+  expect(setupScript).toContain(".zshenv");
+  expect(setupScript).toContain(".bashrc");
+  expect(setupScript).toContain("profile_file");
+}, 30000);
+
+test("forge create --in-place .windsurf/hooks.json calls wrapper not bash directly (RFC-1019)", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+
+  const { readFile: readFileAsync } = await import("node:fs/promises");
+  const hooksJson = await readFileAsync(join(tempDir, ".windsurf", "hooks.json"), "utf8");
+  expect(hooksJson).toContain("pre-user-prompt-wrapper.mjs");
+  expect(hooksJson).not.toContain("2>/dev/null || true");
+}, 30000);
+
+test("forge create --in-place pins pre-user-prompt-wrapper.mjs in pinned.yaml (RFC-1019)", async () => {
+  const result = await runCreate(
+    { argv: [], flags: { "in-place": true, profile: "forge-shell", name: "my-project" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(0);
+
+  const { readFile: readFileAsync } = await import("node:fs/promises");
+  const pinnedYaml = await readFileAsync(join(tempDir, ".forge", "pinned.yaml"), "utf8");
+  expect(pinnedYaml).toContain("pre-user-prompt-wrapper.mjs");
+}, 30000);
+
 test("forge create --profile phaser-turborepo writes compass.fileExtensions into forge.yaml", async () => {
   const result = await runCreate(
     { argv: [], flags: { "in-place": true, profile: "phaser-turborepo", name: "my-phaser-game" } },