gsdd-cli 0.26.0 → 0.27.0

package/README.md

@@ -15,7 +15,7 @@ The public product name is Workspine. The retained technical contracts remain `g
 npx -y gsdd-cli init
 ```
 
-Use `npx -y gsdd-cli init` for repo-local setup. Use `npx -y gsdd-cli install --global` to install reusable Workspine skills and native runtime surfaces into your agent homes so they are available across repos.
+Use `npx -y gsdd-cli init` for repo-local setup. Use `npx -y gsdd-cli install --global --auto` to install reusable Workspine skills and native runtime surfaces into detected agent homes so they are available across repos.
 
 </div>
 
@@ -81,10 +81,11 @@ If `gsdd-cli` is installed globally, install reusable Workspine surfaces into yo
 
 ```bash
 npx -y gsdd-cli install --global
+npx -y gsdd-cli install --global --auto
 npx -y gsdd-cli install --global --tools claude,opencode,codex,copilot
 ```
 
-When run in a TTY without `--tools`, `install --global` lets you select which agents to install. It does not create `.planning/` in the current repo. It writes Workspine-managed skills, native agent surfaces, and per-runtime manifests under the selected agent homes:
+Use `--auto` for non-interactive install into detected local agent homes. Use `--tools <targets>` when you want to override detection explicitly. When run in a TTY without `--tools` or `--auto`, `install --global` lets you select which agents to install. It does not create `.planning/` in the current repo. It writes Workspine-managed skills, native agent surfaces, and per-runtime manifests under the selected agent homes:
 
 | Target | Global surfaces |
 |--------|-----------------|
@@ -127,7 +128,7 @@ npx -y gsdd-cli models profile budget    # minimize cost
 
 ## Troubleshooting
 
-Inside a repo-local `.planning/` workspace, start with `npx -y gsdd-cli health`. It checks local generated runtime surfaces against current render output and reports whether `npx -y gsdd-cli update` can repair drift. To repair or refresh a personal global install, rerun `npx -y gsdd-cli install --global --tools <targets>`. For details, see the [User Guide](docs/USER-GUIDE.md).
+Inside a repo-local `.planning/` workspace, start with `npx -y gsdd-cli health`. It checks local generated runtime surfaces against current render output and reports whether `npx -y gsdd-cli update` can repair drift. To repair or refresh a personal global install, rerun `npx -y gsdd-cli install --global --auto` or explicitly scope it with `npx -y gsdd-cli install --global --tools <targets>`. For details, see the [User Guide](docs/USER-GUIDE.md).
 
 ---
 

package/bin/lib/global-install.mjs

@@ -102,14 +102,22 @@ function validateGlobalTools(tools) {
   return `ERROR: unsupported global install target(s): ${invalid.join(', ')}. Use --tools claude,opencode,codex,copilot or --tools all.`;
 }
 
+function detectGlobalInstallTargets(roots) {
+  return GLOBAL_AGENT_IDS.filter((target) => existsSync(roots[target]));
+}
+
 function displayPath(filePath) {
   return filePath.replace(/\\/g, '/');
 }
 
-async function resolveGlobalInstallTargets({ args, promptApi, output }) {
+async function resolveGlobalInstallTargets({ args, promptApi, output, roots }) {
   const parsedTools = normalizeGlobalTools(parseGlobalToolsFlag(args));
   if (parsedTools.length > 0) return parsedTools;
 
+  if (args.includes('--auto')) {
+    return detectGlobalInstallTargets(roots);
+  }
+
   if (!process.stdin.isTTY) {
     return [];
   }
@@ -530,6 +538,7 @@ export function createCmdInstall(ctx) {
   return async function cmdInstall(...installArgs) {
     const globalFlag = installArgs.includes('--global') || installArgs.includes('-g');
     const localFlag = installArgs.includes('--local');
+    const autoFlag = installArgs.includes('--auto');
     const dryRun = installArgs.includes('--dry');
     const verifyRuntime = installArgs.includes('--verify-runtime');
     const liveRuntime = installArgs.includes('--live-runtime');
@@ -559,14 +568,19 @@ export function createCmdInstall(ctx) {
       return;
     }
 
+    const roots = resolveGlobalInstallRoots();
     const targets = await resolveGlobalInstallTargets({
       args: installArgs,
       promptApi: ctx.globalInstallPromptApi,
       output: process.stdout,
+      roots,
     });
 
     if (targets.length === 0) {
-      console.error('ERROR: no global install targets selected. Use --tools claude,opencode,codex,copilot or run interactively.');
+      const autoHint = autoFlag
+        ? 'No supported agent homes were detected for --auto. Create an agent config home first or use --tools claude,opencode,codex,copilot explicitly.'
+        : 'Use --tools claude,opencode,codex,copilot or run interactively.';
+      console.error(`ERROR: no global install targets selected. ${autoHint}`);
       process.exitCode = 1;
       return;
     }
@@ -578,7 +592,6 @@ export function createCmdInstall(ctx) {
       return;
     }
 
-    const roots = resolveGlobalInstallRoots();
     console.log(`Workspine global install - installing runtime surfaces${dryRun ? ' (dry run)' : ''}\n`);
 
     const reports = targets.map((target) => installTarget({

package/bin/lib/init-runtime.mjs

@@ -172,8 +172,9 @@ Commands:
                               Launch guided install wizard in TTYs, or use --tools for manual/headless setup
                               --auto: non-interactive mode with smart defaults (requires --tools)
                               --brief <file>: copy project brief to .planning/PROJECT_BRIEF.md
-  install --global [--tools <platform>] [--dry]
+  install --global [--auto] [--tools <platform>] [--dry]
                               Install reusable Workspine skills and native runtime surfaces into agent home directories
+                              --auto: non-interactive mode that installs detected local agent targets
                               In TTYs, omitting --tools opens an agent picker
   update [--tools <platform>] [--templates] [--dry]
                               Regenerate adapters from latest framework sources
@@ -223,11 +224,12 @@ Global install targets:
   all       Install all global targets above
 
 Notes:
-  - use \`npx -y gsdd-cli init\` for repo-local setup; use \`npx -y gsdd-cli install --global\` when you want reusable skills in agent homes
+  - use \`npx -y gsdd-cli init\` for repo-local setup; use \`npx -y gsdd-cli install --global --auto\` when you want reusable skills in detected agent homes
   - init always generates open-standard skills at .agents/skills/gsdd-*; this is the shared workflow entry surface
   - init also generates a local .planning/bin/gsdd* helper surface for workflow-embedded lifecycle helpers; it is internal/advanced, not the normal first-run user entrypoint
   - install --global never creates .planning/ in the current repo; it writes only selected agent-home surfaces and per-runtime Workspine manifests
-  - repair or refresh a global install by rerunning \`npx -y gsdd-cli install --global --tools <targets>\`; runtime probes stay in test harnesses
+  - use \`npx -y gsdd-cli install --global --auto\` for non-interactive global install into detected agent homes; use \`--tools <targets>\` to override detection explicitly
+  - repair or refresh a global install by rerunning \`npx -y gsdd-cli install --global --auto\` or \`npx -y gsdd-cli install --global --tools <targets>\`; runtime probes stay in test harnesses
   - Workspine is the public product name; the retained package, command, workflow, and workspace contracts stay gsdd-cli, gsdd, gsdd-*, and .planning/
   - running \`npx -y gsdd-cli init\` in a terminal opens the guided runtime-selection wizard; bare \`gsdd init\` is equivalent only when globally installed
   - the wizard lets you pick runtimes first, then separately decide whether repo-wide AGENTS.md governance is worth installing
@@ -256,6 +258,7 @@ Examples:
   npx -y gsdd-cli init --tools agents
   npx -y gsdd-cli init --tools all
   npx -y gsdd-cli install --global
+  npx -y gsdd-cli install --global --auto
   npx -y gsdd-cli install --global --tools claude,opencode,codex,copilot
   npx -y gsdd-cli update
   npx -y gsdd-cli next --json

package/bin/lib/lifecycle-preflight.mjs

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join, resolve } from 'path';
 import { output } from './cli-utils.mjs';
 import { buildControlMap } from './control-map.mjs';
@@ -76,6 +76,7 @@ const RELEASE_CONTRADICTION_CHECKS = Object.freeze([
 
 const RELEASE_CONTRADICTION_STATUSES = Object.freeze(['passed', 'failed', 'not_applicable']);
 const PREFLIGHT_CONTROL_MAP_SKIP_CODES = Object.freeze(['planning_state_drift']);
+const WORK_PHASE_LINE_RE = /^\s*[-*]\s*\[([ x-])\]\s*\*\*Phase\s+(\d+(?:\.\d+)*[A-Za-z]?):\s*(.+?)\*\*/i;
 
 export function evaluateLifecyclePreflight({
   planningDir,
@@ -95,7 +96,12 @@ export function evaluateLifecyclePreflight({
 
   const lifecycle = evaluateLifecycleState({ planningDir });
   const normalizedPhase = phaseNumber ? normalizePhaseToken(phaseNumber) : null;
+  const workMilestone = normalizedPhase ? evaluateWorkMilestoneState({ planningDir, phaseToken: normalizedPhase }) : null;
   const checkpointPath = join(planningDir, '.continue-here.md');
+  const resumeWorkCheckpoint = surface === 'resume'
+    ? evaluateResumeWorkCheckpoint({ planningDir, checkpointPath })
+    : null;
+  const usesWorkAuthority = Boolean(workMilestone?.phaseEntry || resumeWorkCheckpoint);
   const specPath = join(planningDir, 'SPEC.md');
   const milestonesPath = join(planningDir, 'MILESTONES.md');
   const blockers = [];
@@ -119,7 +125,11 @@ export function evaluateLifecyclePreflight({
   }
 
   if (normalizedPhase) {
-    blockers.push(...buildPhaseBlockers({ lifecycle, phaseToken: normalizedPhase, surface }));
+    blockers.push(
+      ...(usesWorkAuthority
+        ? buildWorkPhaseBlockers({ workMilestone, phaseToken: normalizedPhase, surface })
+        : buildPhaseBlockers({ lifecycle, phaseToken: normalizedPhase, surface }))
+    );
   }
 
   if (surface === 'audit-milestone') {
@@ -176,12 +186,17 @@ export function evaluateLifecyclePreflight({
         details: drift.details,
         files: drift.files,
       };
-      if (policy.classification === 'owned_write') {
+      if (policy.classification === 'owned_write' && !usesWorkAuthority) {
         blockers.push(driftNotice);
       } else {
+        const workWarningContext = resumeWorkCheckpoint
+          ? 'because the checkpoint points at .work/milestone continuity'
+          : `by .work/milestone for Phase ${normalizedPhase}`;
         warnings.push({
           ...driftNotice,
-          message: `Planning state has drifted since the last recorded session: ${drift.details.join('; ')}`,
+          message: usesWorkAuthority
+            ? `Planning state has drifted since the last recorded session, but ${surface} is using work_milestone authority ${workWarningContext}: ${drift.details.join('; ')}`
+            : `Planning state has drifted since the last recorded session: ${drift.details.join('; ')}`,
         });
       }
     }
@@ -198,7 +213,7 @@ export function evaluateLifecyclePreflight({
     else warnings.push(notice);
   }
 
-  if (lifecycle.phaseStatusAlignment.mismatches.length > 0) {
+  if (!usesWorkAuthority && lifecycle.phaseStatusAlignment.mismatches.length > 0) {
     warnings.push({
       code: 'roadmap_phase_status_mismatch',
       message: `ROADMAP.md overview/detail phase statuses disagree: ${lifecycle.phaseStatusAlignment.mismatches.join('; ')}`,
@@ -214,6 +229,7 @@ export function evaluateLifecyclePreflight({
     explicitLifecycleMutation: policy.explicitLifecycleMutation,
     closureEvidence: describeEvidenceSurface(surface),
     mutationRequest: expectsMutation,
+    authority: usesWorkAuthority ? 'work_milestone' : 'planning',
     allowed: blockers.length === 0,
     status: blockers.length === 0 ? 'allowed' : 'blocked',
     reason: blockers[0]?.code ?? null,
@@ -222,10 +238,20 @@ export function evaluateLifecyclePreflight({
     planningState,
     controlMap: controlMap.summary,
     lifecycle: {
+      authority: usesWorkAuthority ? 'work_milestone' : 'planning',
       currentMilestone: lifecycle.currentMilestone,
       currentPhase: lifecycle.currentPhase ? lifecycle.currentPhase.number : null,
       nextPhase: lifecycle.nextPhase ? lifecycle.nextPhase.number : null,
       counts: lifecycle.counts,
+      workMilestone: usesWorkAuthority
+        ? {
+            phase: workMilestone?.phaseEntry?.number ?? null,
+            status: workMilestone?.phaseEntry?.status ?? null,
+            roadmapPath: '.work/milestone/ROADMAP.md',
+            milestoneDir: '.work/milestone',
+            source: resumeWorkCheckpoint ? 'checkpoint' : 'phase',
+          }
+        : null,
     },
   };
 }
@@ -346,6 +372,186 @@ function buildPhaseBlockers({ lifecycle, phaseToken, surface }) {
   return blockers;
 }
 
+function evaluateWorkMilestoneState({ planningDir, phaseToken }) {
+  const workspaceRoot = resolve(planningDir, '..');
+  const milestoneDir = join(workspaceRoot, '.work', 'milestone');
+  const roadmapPath = join(milestoneDir, 'ROADMAP.md');
+  const phasesDir = join(milestoneDir, 'phases');
+
+  if (!existsSync(roadmapPath)) {
+    return null;
+  }
+
+  const phases = parseWorkRoadmapPhases(readFileSync(roadmapPath, 'utf-8'));
+  const phaseEntry = phases.find((phase) => phase.number === phaseToken);
+  if (!phaseEntry) {
+    return null;
+  }
+
+  return {
+    milestoneDir,
+    roadmapPath,
+    phasesDir,
+    phases,
+    phaseEntry,
+    phaseArtifacts: collectWorkPhaseArtifacts({ workspaceRoot, phasesDir, phaseToken }),
+  };
+}
+
+function parseWorkRoadmapPhases(content) {
+  return String(content || '')
+    .replace(/\r\n/g, '\n')
+    .split('\n')
+    .map((line) => {
+      const match = line.match(WORK_PHASE_LINE_RE);
+      if (!match) return null;
+      return {
+        status: parseWorkPhaseStatus(match[1]),
+        number: normalizePhaseToken(match[2]),
+        title: match[3].trim(),
+      };
+    })
+    .filter(Boolean);
+}
+
+function parseWorkPhaseStatus(rawStatus) {
+  const status = String(rawStatus || '').trim().toLowerCase();
+  if (status === 'x') return 'done';
+  if (status === '-') return 'in_progress';
+  return 'pending';
+}
+
+function evaluateResumeWorkCheckpoint({ planningDir, checkpointPath }) {
+  if (!existsSync(checkpointPath)) return null;
+
+  const workspaceRoot = resolve(planningDir, '..');
+  const milestoneDir = join(workspaceRoot, '.work', 'milestone');
+  const roadmapPath = join(milestoneDir, 'ROADMAP.md');
+  if (!existsSync(roadmapPath)) return null;
+
+  let content = '';
+  try {
+    content = readFileSync(checkpointPath, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  if (!/(^|[`"'(\s])\.work[\\/]+milestone([`"')\s/]|$)/i.test(content)) {
+    return null;
+  }
+
+  return {
+    milestoneDir,
+    roadmapPath,
+  };
+}
+
+function collectWorkPhaseArtifacts({ workspaceRoot, phasesDir, phaseToken }) {
+  if (!existsSync(phasesDir)) return [];
+
+  return collectMarkdownFiles(phasesDir)
+    .map((filePath) => {
+      const filename = filePath.split(/[\\/]/).pop();
+      const match = filename.match(/^(\d+(?:\.\d+)*[A-Za-z]?)-(.+?)\.md$/i);
+      if (!match || normalizePhaseToken(match[1]) !== phaseToken) return null;
+
+      const kind = parseWorkArtifactKind(match[2]);
+      if (!kind) return null;
+
+      return {
+        phaseToken,
+        kind,
+        path: filePath,
+        displayPath: relativeDisplayPath(workspaceRoot, filePath),
+      };
+    })
+    .filter(Boolean);
+}
+
+function collectMarkdownFiles(dir) {
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectMarkdownFiles(fullPath));
+    } else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+function parseWorkArtifactKind(rawKind) {
+  const kind = String(rawKind || '').toLowerCase();
+  if (kind === 'plan') return 'plan';
+  if (kind === 'execute') return 'execute';
+  if (kind === 'verify' || kind === 'verification') return 'verification';
+  return null;
+}
+
+function relativeDisplayPath(root, filePath) {
+  return filePath.slice(root.length + 1).replace(/\\/g, '/');
+}
+
+function buildWorkPhaseBlockers({ workMilestone, phaseToken, surface }) {
+  const blockers = [];
+  const planArtifacts = workMilestone.phaseArtifacts.filter((artifact) => artifact.kind === 'plan');
+  const executeArtifacts = workMilestone.phaseArtifacts.filter((artifact) => artifact.kind === 'execute');
+
+  if (surface === 'execute') {
+    if (planArtifacts.length === 0) {
+      blockers.push(
+        blocker(
+          'missing_plan',
+          `Phase ${phaseToken} cannot execute because no .work PLAN artifact exists.`,
+          ['.work/milestone/phases/']
+        )
+      );
+    } else if (executeArtifacts.length > 0) {
+      blockers.push(
+        blocker(
+          'no_pending_plan',
+          `Phase ${phaseToken} has already been executed in .work/milestone.`,
+          executeArtifacts.map((artifact) => artifact.displayPath)
+        )
+      );
+    }
+  }
+
+  if (surface === 'plan' && workMilestone.phaseEntry.status === 'done') {
+    blockers.push(
+      blocker(
+        'phase_already_complete',
+        `Phase ${phaseToken} is already complete in .work/milestone and should not be planned again.`,
+        ['.work/milestone/ROADMAP.md']
+      )
+    );
+  }
+
+  if (surface === 'verify') {
+    if (planArtifacts.length === 0) {
+      blockers.push(
+        blocker(
+          'missing_plan',
+          `Phase ${phaseToken} cannot be verified because no .work PLAN artifact exists.`,
+          ['.work/milestone/phases/']
+        )
+      );
+    }
+    if (executeArtifacts.length === 0) {
+      blockers.push(
+        blocker(
+          'missing_execute',
+          `Phase ${phaseToken} cannot be verified because no .work EXECUTE artifact exists yet.`,
+          ['.work/milestone/phases/']
+        )
+      );
+    }
+  }
+
+  return blockers;
+}
+
 function buildRoadmapAlignmentBlockers(lifecycle) {
   if (lifecycle.phaseStatusAlignment.mismatches.length === 0) return [];
   return [

package/docs/RUNTIME-SUPPORT.md

@@ -4,7 +4,7 @@ Workspine is a repo-native delivery spine with portable multi-runtime workflow s
 
 This matrix is the release-floor truth surface.
 
-Human repo setup and repair commands in this document use `npx -y gsdd-cli ...` because that works without a global install. If you installed `gsdd-cli` globally, the equivalent bare `gsdd ...` command is fine. For cross-repo personal use, `npx -y gsdd-cli install --global` installs reusable Workspine skills and native runtime surfaces into selected agent homes.
+Human repo setup and repair commands in this document use `npx -y gsdd-cli ...` because that works without a global install. If you installed `gsdd-cli` globally, the equivalent bare `gsdd ...` command is fine. For cross-repo personal use, `npx -y gsdd-cli install --global --auto` installs reusable Workspine skills and native runtime surfaces into detected agent homes.
 
 The install contract is deliberately skills-first: `npx -y gsdd-cli init` always creates `.agents/skills/gsdd-*` and `.planning/bin/gsdd*`; runtime-specific adapters are optional discovery or orchestration helpers layered on top.
 
@@ -55,7 +55,7 @@ Two surfaces matter for users:
 
 ## Global install surfaces
 
-`npx -y gsdd-cli install --global` can install personal cross-repo surfaces for these targets:
+`npx -y gsdd-cli install --global --auto` can install personal cross-repo surfaces for detected agent homes. Use `npx -y gsdd-cli install --global --tools <targets>` to override detection explicitly. Supported targets:
 
 | Target | Global surfaces |
 | --- | --- |
@@ -77,7 +77,7 @@ The authored source contract stays in `distilled/workflows/*`. Generated runtime
 - `npx -y gsdd-cli update` regenerates drifted generated surfaces from the authored workflow and delegate sources.
 - Bare `gsdd health` and `gsdd update` are equivalent only when `gsdd-cli` is globally installed.
 - Missing generated surfaces are not treated as drift unless the corresponding runtime surface is actually installed locally.
-- Global user-home installs are refreshed by rerunning `npx -y gsdd-cli install --global --tools <targets>`; global runtime probes remain an internal pressure-harness concern, not a public install flag.
+- Global user-home installs are refreshed by rerunning `npx -y gsdd-cli install --global --auto` or explicitly scoped with `npx -y gsdd-cli install --global --tools <targets>`; global runtime probes remain an internal pressure-harness concern, not a public install flag.
 
 ## Entry and helper surfaces
 

package/docs/USER-GUIDE.md

@@ -13,7 +13,7 @@ For a new project or a broad brownfield effort:
 3. Review the plan from `gsdd-plan` before starting `gsdd-execute`.
 4. Run `gsdd-verify` before calling the phase done.
 
-Use `npx -y gsdd-cli init` for repo-local setup. Use `npx -y gsdd-cli install --global` to install reusable Workspine skills and native runtime surfaces into selected agent homes without creating `.planning/` in the current repo.
+Use `npx -y gsdd-cli init` for repo-local setup. Use `npx -y gsdd-cli install --global --auto` to install reusable Workspine skills and native runtime surfaces into detected agent homes without creating `.planning/` in the current repo.
 
 For a bounded existing-code change, use `gsdd-quick`. For an unfamiliar or risky repo, use `gsdd-map-codebase` before choosing between `gsdd-quick` and `gsdd-new-project`.
 
@@ -188,9 +188,12 @@ Use global agent install when you want Workspine workflows available across repo
 
 ```bash
 npx -y gsdd-cli install --global
+npx -y gsdd-cli install --global --auto
 npx -y gsdd-cli install --global --tools claude,opencode,codex,copilot
 ```
 
+Use `--auto` for non-interactive global install into detected local agent homes. Use `--tools <targets>` when you want to install a specific target set regardless of detection.
+
 Global install writes Workspine-managed files under selected agent homes and records per-runtime manifests. It does not bootstrap project planning state.
 
 ### Workflows (run via generated skills or adapters)
@@ -239,7 +242,7 @@ Normal user flow:
 2. Enter workflows through your runtime surface: `/gsdd-*` or `$gsdd-*`.
 3. Use `npx -y gsdd-cli health` to check repo-local generated surfaces.
 4. Use `npx -y gsdd-cli update` when repo-local generated surfaces drift or you want the latest shipped output.
-5. For personal global installs, rerun `npx -y gsdd-cli install --global --tools <targets>` to repair or refresh selected agent homes.
+5. For personal global installs, rerun `npx -y gsdd-cli install --global --auto` to repair or refresh detected agent homes, or use `npx -y gsdd-cli install --global --tools <targets>` to scope the target set explicitly.
 
 Surface split:
 
@@ -446,7 +449,7 @@ If you've modified any templates, the generation manifest detects this and warns
 
 ### Generated Surfaces Drift Or A Runtime Command Goes Missing
 
-In a repo-local `.planning/` workspace, start with `npx -y gsdd-cli health`. If it reports drift or missing installed generated surfaces, run `npx -y gsdd-cli update` for the whole workspace or `npx -y gsdd-cli update --tools <runtime>` for a specific runtime. For global personal installs, rerun `npx -y gsdd-cli install --global --tools <targets>`.
+In a repo-local `.planning/` workspace, start with `npx -y gsdd-cli health`. If it reports drift or missing installed generated surfaces, run `npx -y gsdd-cli update` for the whole workspace or `npx -y gsdd-cli update --tools <runtime>` for a specific runtime. For global personal installs, rerun `npx -y gsdd-cli install --global --auto` or scope it explicitly with `npx -y gsdd-cli install --global --tools <targets>`.
 
 That repair path is deterministic for generated files. It does not imply that every runtime has equal native ergonomics or equal validation depth.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsdd-cli",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "Workspine — a repo-native delivery spine for long-horizon AI-assisted work, with directly validated support for Claude Code, Codex CLI, and OpenCode, published as gsdd-cli.",
   "type": "module",
   "bin": {