@ulysses-ai/create-workspace 0.16.0-beta.0 → 0.17.0-beta.0

package/template/.claude/scripts/cleanup-work-session.mjs

@@ -11,9 +11,23 @@
 // Workspace-first removal silently deletes the nested project worktrees'
 // .git files and leaves orphan worktree records in the project repos.
 // The safe order keeps both sides of the relationship in sync.
+//
+// State discovery is defensive: the session tracker (session.md) may have
+// been stripped by /complete-work Step 7 before this script runs, leaving
+// no `repos:` or `branch:` to read. When that happens we discover repos
+// from the work-sessions/{name}/workspace/repos/ directory listing and the
+// branch from `git branch --show-current` on the workspace worktree —
+// BEFORE removing anything. Without that, the per-repo loops silently
+// no-op and the script reports success while leaving orphans behind
+// (gh:119).
+//
+// `success: true` means VERIFIED: every project worktree record is gone
+// (no prunable entries left over), every local branch is deleted, and the
+// session folder is removed. The script post-verifies all of these and
+// surfaces any leftover state as an error rather than swallowing it.
 import '../lib/require-node.mjs';
 import { execSync } from 'child_process';
-import { existsSync } from 'fs';
+import { existsSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
 import {
   getWorkspaceRoot,
@@ -36,74 +50,198 @@ if (!sessionName) {
 }
 
 const root = getWorkspaceRoot(import.meta.url);
-const tracker = readSessionTracker(root, sessionName);
-const repos = normalizeRepos(tracker?.repos);
-const branch = tracker?.branch;
 const reposDir = join(root, 'repos');
 const sessionFolder = sessionFolderPath(root, sessionName);
 const wsWorktree = join(sessionFolder, 'workspace');
 
 const removed = [];
+const skipped = [];
 const errors = [];
 
-// Step 1: Remove each project worktree FIRST, from its project repo
-for (const repo of repos) {
-  const projWorktree = join(wsWorktree, 'repos', repo);
-  const repoDir = join(reposDir, repo);
-  if (existsSync(projWorktree)) {
+// === Discovery: where session.md is silent or missing, fall back to disk ===
+//
+// The tracker may have been stripped before this script runs. Read whatever
+// is still there, then fill gaps from the live worktree state.
+
+const tracker = readSessionTracker(root, sessionName);
+let repos = normalizeRepos(tracker?.repos);
+let branch = tracker?.branch || null;
+
+// If repos is empty, discover from work-sessions/{name}/workspace/repos/.
+// That directory is the workspace worktree's nested-project-worktrees dir;
+// each entry is one project repo this session checked out.
+if (repos.length === 0) {
+  const nestedReposDir = join(wsWorktree, 'repos');
+  if (existsSync(nestedReposDir)) {
     try {
-      execSync(`git worktree remove "${projWorktree}" --force`, { cwd: repoDir, stdio: 'pipe' });
-      removed.push(`project worktree ${repo}`);
+      const discovered = readdirSync(nestedReposDir).filter((entry) => {
+        try {
+          return statSync(join(nestedReposDir, entry)).isDirectory();
+        } catch {
+          return false;
+        }
+      });
+      if (discovered.length > 0) {
+        repos = discovered;
+        skipped.push({
+          step: 'discovery',
+          reason: `Tracker missing repos; discovered ${discovered.length} from ${nestedReposDir}: ${discovered.join(', ')}`,
+        });
+      }
     } catch (err) {
-      errors.push(`Failed to remove ${repo} worktree: ${err.message}`);
+      skipped.push({ step: 'discovery', reason: `Failed to list ${nestedReposDir}: ${err.message}` });
     }
   }
 }
 
-// Step 2: Remove the workspace worktree AFTER project worktrees are gone
+// If branch is missing, ask the workspace worktree itself.
+if (!branch && existsSync(wsWorktree)) {
+  try {
+    branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: wsWorktree, stdio: 'pipe', encoding: 'utf-8' }).trim();
+    if (branch) {
+      skipped.push({ step: 'discovery', reason: `Tracker missing branch; discovered from worktree: ${branch}` });
+    }
+  } catch (err) {
+    skipped.push({ step: 'discovery', reason: `Failed to read branch from ${wsWorktree}: ${err.message}` });
+  }
+}
+
+// === Step 1: Remove each project worktree FIRST, from its project repo ===
+for (const repo of repos) {
+  const projWorktree = join(wsWorktree, 'repos', repo);
+  const repoDir = join(reposDir, repo);
+  if (!existsSync(projWorktree)) {
+    skipped.push({ step: 'remove-project-worktree', repo, reason: `${projWorktree} does not exist` });
+    continue;
+  }
+  if (!existsSync(repoDir)) {
+    errors.push(`Cannot remove ${repo} worktree: source clone missing at ${repoDir}`);
+    continue;
+  }
+  try {
+    execSync(`git worktree remove "${projWorktree}" --force`, { cwd: repoDir, stdio: 'pipe' });
+    removed.push(`project worktree ${repo}`);
+  } catch (err) {
+    errors.push(`Failed to remove ${repo} worktree: ${err.message.trim()}`);
+  }
+}
+
+// === Step 2: Remove the workspace worktree AFTER project worktrees are gone ===
 if (existsSync(wsWorktree)) {
   try {
     execSync(`git worktree remove "${wsWorktree}" --force`, { cwd: root, stdio: 'pipe' });
     removed.push('workspace worktree');
   } catch (err) {
-    errors.push(`Failed to remove workspace worktree: ${err.message}`);
+    errors.push(`Failed to remove workspace worktree: ${err.message.trim()}`);
   }
+} else {
+  skipped.push({ step: 'remove-workspace-worktree', reason: `${wsWorktree} does not exist` });
 }
 
-// Step 3: Prune each project repo to mop up orphans from any prior misuses
+// === Step 3: Prune each project repo to mop up orphans ===
 for (const repo of repos) {
   const repoDir = join(reposDir, repo);
+  if (!existsSync(repoDir)) continue;
   try {
     execSync('git worktree prune', { cwd: repoDir, stdio: 'pipe' });
-  } catch {
-    // Non-fatal — prune is a safety net
+  } catch (err) {
+    // Prune is a safety net, but if it fails on a repo we touched, surface
+    // it — verification below will catch leftover orphans either way.
+    errors.push(`Prune failed in ${repo}: ${err.message.trim()}`);
   }
 }
 
-// Step 4: Delete local branches
+// === Step 4: Delete local branches ===
 if (branch) {
   for (const repo of repos) {
     const repoDir = join(reposDir, repo);
+    if (!existsSync(repoDir)) continue;
     try {
-      execSync(`git branch -D "${branch}"`, { cwd: repoDir, stdio: 'pipe' });
+      execSync(`git branch --list "${branch}"`, { cwd: repoDir, stdio: 'pipe', encoding: 'utf-8' });
     } catch {
-      // Non-fatal — branch may already be gone or refuse to delete
+      continue; // Repo broken; verification will catch downstream impact.
+    }
+    const exists = execSync(`git branch --list "${branch}"`, { cwd: repoDir, encoding: 'utf-8' }).trim();
+    if (!exists) continue; // Already gone (e.g., gh pr merge --delete-branch did it).
+    try {
+      execSync(`git branch -D "${branch}"`, { cwd: repoDir, stdio: 'pipe' });
+    } catch (err) {
+      errors.push(`Failed to delete branch ${branch} in ${repo}: ${err.message.trim()}`);
     }
   }
+  // Same for the workspace repo (root).
   try {
-    execSync(`git branch -D "${branch}"`, { cwd: root, stdio: 'pipe' });
+    const exists = execSync(`git branch --list "${branch}"`, { cwd: root, encoding: 'utf-8' }).trim();
+    if (exists) {
+      try {
+        execSync(`git branch -D "${branch}"`, { cwd: root, stdio: 'pipe' });
+      } catch (err) {
+        errors.push(`Failed to delete branch ${branch} in workspace repo: ${err.message.trim()}`);
+      }
+    }
   } catch {
-    // Non-fatal
+    // workspace root not a git repo — unusual, skip.
   }
 }
 
-// Step 5: Delete the whole work-sessions/{name}/ folder. The session.md,
-// specs, plans, and any local-only artifacts vanish. Their content was
-// archived into release notes by /complete-work before this script ran.
-deleteSessionFolder(root, sessionName);
+// === Step 5: Delete the whole work-sessions/{name}/ folder ===
+try {
+  deleteSessionFolder(root, sessionName);
+} catch (err) {
+  errors.push(`Failed to delete session folder ${sessionFolder}: ${err.message.trim()}`);
+}
+
+// === Post-verification: success means VERIFIED, not "no try/catch threw" ===
+//
+// Without these checks, an empty repos list (the gh:119 root cause) lets
+// every silent skip add up to a "success" output while leaving orphans
+// behind. The verification turns silent skips into honest errors.
+
+if (existsSync(sessionFolder)) {
+  errors.push(`Session folder still present after cleanup: ${sessionFolder}`);
+}
+
+const wsPath = wsWorktree; // canonical path the worktree had
+for (const repo of repos) {
+  const repoDir = join(reposDir, repo);
+  if (!existsSync(repoDir)) continue;
+  let wtList = '';
+  try {
+    wtList = execSync('git worktree list --porcelain', { cwd: repoDir, encoding: 'utf-8' });
+  } catch (err) {
+    errors.push(`Could not list worktrees in ${repo}: ${err.message.trim()}`);
+    continue;
+  }
+  if (wtList.includes('prunable')) {
+    errors.push(`Prunable worktree record remains in ${repo} after cleanup (gh:119 symptom)`);
+  }
+  if (wtList.includes(wsPath)) {
+    errors.push(`${repo} still has a worktree record referencing the session path`);
+  }
+  if (branch) {
+    const branchStill = execSync(`git branch --list "${branch}"`, { cwd: repoDir, encoding: 'utf-8' }).trim();
+    if (branchStill) {
+      errors.push(`Branch ${branch} still present in ${repo} after cleanup`);
+    }
+  }
+}
+
+if (branch) {
+  try {
+    const branchStill = execSync(`git branch --list "${branch}"`, { cwd: root, encoding: 'utf-8' }).trim();
+    if (branchStill) {
+      errors.push(`Branch ${branch} still present in workspace repo after cleanup`);
+    }
+  } catch {
+    // not a git repo — already noted
+  }
+}
 
 console.log(JSON.stringify({
   success: errors.length === 0,
   removed,
+  skipped: skipped.length > 0 ? skipped : undefined,
   errors: errors.length > 0 ? errors : undefined,
 }));
+
+if (errors.length > 0) process.exit(1);

package/template/.claude/scripts/forges/github.mjs

@@ -0,0 +1,210 @@
+// GitHub forge adapter. Wraps the `gh` CLI via an injectable spawnFn so
+// tests can mock without spawning a real subprocess (mirrors the pattern
+// in trackers/github-issues.mjs).
+//
+// All operations target a single default `repo` resolved at construction
+// time from `config.repo` (e.g. `"owner/name"`) or from the local git
+// origin remote when `config.repo` is unset or `"auto"`. Per-call `repo`
+// overrides allow targeting a different repo when needed.
+
+import '../../lib/require-node.mjs';
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import {
+  PrNotFound,
+  ReleaseNotFound,
+  WorkflowNotFound,
+  MergeRejected,
+} from './interface.mjs';
+
+const PR_VIEW_FIELDS = 'number,url,state,title,mergeable,mergeStateStatus,reviewDecision,headRefName,baseRefName,isDraft,mergedAt';
+
+export function createGithubAdapter(config, { spawnFn = nodeSpawnSync } = {}) {
+  const defaultRepo = resolveRepo(config, spawnFn);
+
+  function gh(args, { input } = {}) {
+    const result = spawnFn('gh', args, {
+      input,
+      encoding: 'utf-8',
+      stdio: input !== undefined ? ['pipe', 'pipe', 'pipe'] : ['inherit', 'pipe', 'pipe'],
+    });
+    return result;
+  }
+
+  function ghOrThrow(args, opts) {
+    const result = gh(args, opts);
+    if (result.status !== 0) {
+      throw new Error(`gh ${args.join(' ')} failed: ${(result.stderr || '').trim()}`);
+    }
+    return result.stdout || '';
+  }
+
+  function repoFor(override) {
+    return override || defaultRepo;
+  }
+
+  async function prCreate({ title, body = '', draft = false, base, head, repo }) {
+    if (!title) throw new Error('prCreate: title is required');
+    const args = ['pr', 'create', '--repo', repoFor(repo), '--title', title, '--body-file', '-'];
+    if (draft) args.push('--draft');
+    if (base) args.push('--base', base);
+    if (head) args.push('--head', head);
+    const stdout = ghOrThrow(args, { input: body }).trim();
+    // gh pr create prints the PR URL on success; sometimes preceded by warnings.
+    const url = stdout.split('\n').filter(Boolean).pop();
+    const m = url.match(/\/pull\/(\d+)/);
+    if (!m) throw new Error(`Could not parse PR number from gh output: ${stdout}`);
+    const number = parseInt(m[1], 10);
+    return { id: `${repoFor(repo)}#${number}`, url, number };
+  }
+
+  async function prMerge({ id, strategy = 'merge', deleteBranch = false, repo }) {
+    if (!id) throw new Error('prMerge: id is required');
+    const { number, repo: parsedRepo } = parsePrId(id, repoFor(repo));
+    const args = ['pr', 'merge', String(number), '--repo', parsedRepo];
+    switch (strategy) {
+      case 'merge': args.push('--merge'); break;
+      case 'squash': args.push('--squash'); break;
+      case 'rebase': args.push('--rebase'); break;
+      default: throw new Error(`prMerge: unknown strategy: ${strategy}`);
+    }
+    if (deleteBranch) args.push('--delete-branch');
+    const result = gh(args);
+    if (result.status !== 0) {
+      const stderr = (result.stderr || '').trim();
+      // Distinguish "not found" from "rejected" so callers can react.
+      if (/not\s+found|could\s+not\s+resolve/i.test(stderr)) {
+        throw new PrNotFound(id);
+      }
+      throw new MergeRejected(id, stderr || 'gh pr merge exited non-zero');
+    }
+    return { merged: true, url: `https://github.com/${parsedRepo}/pull/${number}` };
+  }
+
+  async function prView({ id, repo, json }) {
+    if (!id) throw new Error('prView: id is required');
+    const { number, repo: parsedRepo } = parsePrId(id, repoFor(repo));
+    const fields = json || PR_VIEW_FIELDS;
+    const result = gh(['pr', 'view', String(number), '--repo', parsedRepo, '--json', fields]);
+    if (result.status !== 0) {
+      const stderr = (result.stderr || '').trim();
+      if (/not\s+found|could\s+not\s+resolve/i.test(stderr)) {
+        throw new PrNotFound(id);
+      }
+      throw new Error(`gh pr view failed: ${stderr}`);
+    }
+    const raw = JSON.parse(result.stdout);
+    return {
+      id,
+      number: raw.number,
+      url: raw.url,
+      state: raw.state,
+      title: raw.title,
+      mergeable: raw.mergeable,
+      mergeStateStatus: raw.mergeStateStatus,
+      reviewDecision: raw.reviewDecision,
+      headRefName: raw.headRefName,
+      baseRefName: raw.baseRefName,
+      isDraft: raw.isDraft,
+      mergedAt: raw.mergedAt,
+      _raw: raw,
+    };
+  }
+
+  async function releaseView({ tag, repo }) {
+    if (!tag) throw new Error('releaseView: tag is required');
+    const target = repoFor(repo);
+    const result = gh(['release', 'view', tag, '--repo', target, '--json', 'name,tagName,url,publishedAt,isDraft,isPrerelease']);
+    if (result.status !== 0) {
+      const stderr = (result.stderr || '').trim();
+      if (/release\s+not\s+found|not\s+found/i.test(stderr)) {
+        throw new ReleaseNotFound(tag);
+      }
+      throw new Error(`gh release view failed: ${stderr}`);
+    }
+    const raw = JSON.parse(result.stdout);
+    return {
+      tag: raw.tagName,
+      name: raw.name,
+      url: raw.url,
+      publishedAt: raw.publishedAt,
+      isDraft: raw.isDraft,
+      isPrerelease: raw.isPrerelease,
+    };
+  }
+
+  async function workflowRunFind({ workflow, branch, repo, limit = 1 }) {
+    if (!workflow) throw new Error('workflowRunFind: workflow is required');
+    const target = repoFor(repo);
+    const args = [
+      'run', 'list',
+      '--repo', target,
+      '--workflow', workflow,
+      '--limit', String(limit),
+      '--json', 'databaseId,status,conclusion,url,headBranch,createdAt',
+    ];
+    if (branch) args.push('--branch', branch);
+    const result = gh(args);
+    if (result.status !== 0) {
+      throw new Error(`gh run list failed: ${(result.stderr || '').trim()}`);
+    }
+    const runs = JSON.parse(result.stdout);
+    if (runs.length === 0) return null;
+    const first = runs[0];
+    return {
+      runId: String(first.databaseId),
+      status: first.status,
+      conclusion: first.conclusion,
+      url: first.url,
+      branch: first.headBranch,
+      createdAt: first.createdAt,
+    };
+  }
+
+  async function workflowRunWatch({ runId, repo, exitStatus = false }) {
+    if (!runId) throw new Error('workflowRunWatch: runId is required');
+    const target = repoFor(repo);
+    const args = ['run', 'watch', String(runId), '--repo', target];
+    if (exitStatus) args.push('--exit-status');
+    const result = gh(args);
+    if (result.status === 0) return { exitCode: 0 };
+    // Distinguish "couldn't find" from "ran but failed".
+    const stderr = (result.stderr || '').trim();
+    if (/not\s+found|could\s+not\s+find/i.test(stderr)) {
+      throw new WorkflowNotFound({ runId });
+    }
+    // `--exit-status` makes gh exit non-zero on workflow failure; surface
+    // that without throwing so callers can record the failure URL.
+    return { exitCode: result.status, stderr };
+  }
+
+  return {
+    prCreate,
+    prMerge,
+    prView,
+    releaseView,
+    workflowRunFind,
+    workflowRunWatch,
+    get identity() { return `github:${defaultRepo}`; },
+  };
+}
+
+// "owner/name#NUMBER" or just NUMBER (defaulting to the adapter's repo).
+function parsePrId(id, fallbackRepo) {
+  if (typeof id === 'number') return { number: id, repo: fallbackRepo };
+  const m1 = String(id).match(/^(?<repo>[^#\s]+\/[^#\s]+)#(?<number>\d+)$/);
+  if (m1) return { number: parseInt(m1.groups.number, 10), repo: m1.groups.repo };
+  const m2 = String(id).match(/^#?(\d+)$/);
+  if (m2) return { number: parseInt(m2[1], 10), repo: fallbackRepo };
+  throw new Error(`Unparseable PR id: ${id}`);
+}
+
+function resolveRepo(config, spawnFn) {
+  if (config?.repo && config.repo !== 'auto') return config.repo;
+  const result = spawnFn('git', ['remote', 'get-url', 'origin'], { encoding: 'utf-8' });
+  if (result.status !== 0) {
+    throw new Error(`git remote get-url failed: ${(result.stderr || '').trim()}`);
+  }
+  const m = result.stdout.trim().match(/github\.com[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/);
+  if (!m) throw new Error(`Cannot parse GitHub remote: ${result.stdout.trim()}`);
+  return `${m[1]}/${m[2]}`;
+}

package/template/.claude/scripts/forges/gitlab.mjs

@@ -0,0 +1,19 @@
+// GitLab forge adapter — stub. Reserved as the next sibling of github.mjs
+// so the discovery pattern stays uniform: workspaces opting into GitLab
+// set `workspace.forge.type: gitlab` in workspace.json and get a clear
+// "not implemented" error pointing at the gap, rather than silently
+// routing through GitHub.
+//
+// When implemented, this adapter wraps the `glab` CLI the same way
+// github.mjs wraps `gh`: same method surface (prCreate, prMerge, prView,
+// releaseView, workflowRunFind, workflowRunWatch), same spawnFn-injectable
+// shape for testability, same error types from interface.mjs.
+
+import { ForgeError } from './interface.mjs';
+
+export function createGitlabAdapter(config /* , options */) {
+  throw new ForgeError(
+    'GitLab forge adapter is not implemented yet. Set workspace.forge.type to "github", or contribute a glab-based adapter at .claude/scripts/forges/gitlab.mjs following the shape of github.mjs.',
+    'NOT_IMPLEMENTED',
+  );
+}

package/template/.claude/scripts/forges/interface.mjs

@@ -0,0 +1,113 @@
+// Forge adapter interface. Skills import only from this module.
+//
+// Where `trackers/` covers issue lifecycle (issues, comments, labels,
+// milestones), `forges/` covers cross-cutting repo-host operations:
+// pull requests, releases, and workflow runs. The two abstractions are
+// intentionally separate — a workspace could in principle mix
+// (e.g. `github-issues` tracker + `gitlab` forge), though the common
+// case is forge = same host as tracker.
+//
+// Method contracts:
+//
+//   prCreate({ title, body, draft = false, base, head, repo? })
+//     → { id, url, number }
+//   prMerge({ id, strategy = 'merge', deleteBranch = false, repo? })
+//     → { merged: true, url }
+//     strategy: 'merge' | 'squash' | 'rebase'
+//   prView({ id, repo?, json? })
+//     → { id, url, state, mergeable, mergeStateStatus, reviewDecision, title }
+//     json may name additional fields to pass through
+//   releaseView({ tag, repo? })
+//     → { tag, url, name, publishedAt }
+//     throws ReleaseNotFound if the tag has no release
+//   workflowRunFind({ workflow, branch, repo?, limit = 1 })
+//     → { runId, status, conclusion, url } | null
+//   workflowRunWatch({ runId, repo?, exitStatus = false })
+//     → { exitCode }
+//     exitStatus: when true, the underlying command exits non-zero on
+//     workflow failure; the adapter still returns the exit code rather
+//     than throwing — callers decide how to handle a failed run.
+//
+// `repo` defaults: each adapter resolves a default repo at construction
+// time (e.g. from `workspace.forge.repo` or the local git origin remote);
+// callers pass `repo` only when targeting a different one.
+//
+// All methods are async and may throw `ForgeError` subclasses on
+// adapter-detectable failures. Raw spawn failures throw `Error`.
+
+import '../../lib/require-node.mjs';
+import { createGithubAdapter } from './github.mjs';
+import { createGitlabAdapter } from './gitlab.mjs';
+
+export class ForgeError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = 'ForgeError';
+    this.code = code;
+  }
+}
+
+export class PrNotFound extends ForgeError {
+  constructor(id) {
+    super(`Pull request not found: ${id}`, 'PR_NOT_FOUND');
+    this.name = 'PrNotFound';
+    this.id = id;
+  }
+}
+
+export class ReleaseNotFound extends ForgeError {
+  constructor(tag) {
+    super(`Release not found for tag: ${tag}`, 'RELEASE_NOT_FOUND');
+    this.name = 'ReleaseNotFound';
+    this.tag = tag;
+  }
+}
+
+export class WorkflowNotFound extends ForgeError {
+  constructor(query) {
+    super(`Workflow run not found: ${JSON.stringify(query)}`, 'WORKFLOW_NOT_FOUND');
+    this.name = 'WorkflowNotFound';
+    this.query = query;
+  }
+}
+
+export class MergeRejected extends ForgeError {
+  constructor(id, reason) {
+    super(`Merge rejected for ${id}: ${reason}`, 'MERGE_REJECTED');
+    this.name = 'MergeRejected';
+    this.id = id;
+    this.reason = reason;
+  }
+}
+
+// createForge takes the `workspace.forge` config block. If the block is
+// absent (`undefined`/`null`), default to GitHub — this matches the
+// migration story documented in `.claude/rules/forge-operations.md`:
+// existing workspaces predate the field, so an unset value means
+// "behave as you always have." A workspace that wants to opt out of
+// forge operations entirely should set `workspace.forge: false`;
+// callers passing `false` will get a no-op throw on every method.
+export function createForge(config, options = {}) {
+  if (config === false) {
+    throw new ForgeError(
+      'Forge operations disabled — set workspace.forge in workspace.json to enable.',
+      'FORGE_DISABLED',
+    );
+  }
+  const resolved = config ?? { type: 'github' };
+  if (typeof resolved !== 'object') {
+    throw new ForgeError(
+      `Invalid workspace.forge config: expected object, got ${typeof resolved}`,
+      'INVALID_CONFIG',
+    );
+  }
+  const type = resolved.type ?? 'github';
+  switch (type) {
+    case 'github':
+      return createGithubAdapter(resolved, options);
+    case 'gitlab':
+      return createGitlabAdapter(resolved, options);
+    default:
+      throw new ForgeError(`Unknown forge type: ${type}`, 'UNKNOWN_TYPE');
+  }
+}

package/template/.claude/settings.json

@@ -92,25 +92,17 @@
           }
         ]
       }
-    ],
-    "WorktreeCreate": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$(if command -v cygpath >/dev/null 2>&1; then cygpath -u \"${CLAUDE_PROJECT_DIR:-$PWD}\"; else echo \"${CLAUDE_PROJECT_DIR:-$PWD}\"; fi)\"/.claude/hooks/worktree-create.mjs",
-            "timeout": 5000,
-            "statusMessage": "Checking for stale worktrees..."
-          }
-        ]
-      }
     ]
   },
+  "worktree": {
+    "baseRef": "head"
+  },
   "permissions": {
     "allow": [
       "Bash(git:*)",
       "Bash(ls:*)"
-    ]
+    ],
+    "deny": []
   },
   "enabledPlugins": {
     "playwright@claude-plugins-official": false