gsdd-cli 0.26.0 → 0.28.0

package/bin/lib/runtime-freshness.mjs

@@ -28,7 +28,8 @@ import {
   getRuntimeModelOverride,
   loadProjectModelConfig,
   resolveRuntimeAgentModel,
-} from './models.mjs';
+} from './config.mjs';
+import { resolveStateDir } from './state-dir.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -68,7 +69,7 @@ function compareGeneratedFile({ cwd, runtime, relativePath, expectedContent, rep
   };
 }
 
-function buildClaudeEntries({ cwd, workflows }) {
+function buildClaudeEntries({ cwd, workflows, stateDirName = '.work' }) {
   const checkerModelAlias = resolveRuntimeAgentModel({
     cwd,
     runtime: 'claude',
@@ -85,8 +86,8 @@ function buildClaudeEntries({ cwd, workflows }) {
   const entries = workflows.map((workflow) => ({
     relativePath: `.claude/skills/${workflow.name}/SKILL.md`,
     expectedContent: workflow.name === 'gsdd-plan'
-      ? renderClaudePlanSkill()
-      : renderSkillContent(workflow),
+      ? renderClaudePlanSkill({ stateDirName })
+      : renderSkillContent(workflow, { stateDirName }),
   }));
 
   entries.push(
@@ -107,7 +108,7 @@ function buildClaudeEntries({ cwd, workflows }) {
   return entries;
 }
 
-function buildOpenCodeEntries({ cwd, workflows }) {
+function buildOpenCodeEntries({ cwd, workflows, stateDirName = '.work' }) {
   const config = loadProjectModelConfig(cwd);
   const checkerModelId = getRuntimeModelOverride(config, 'opencode', 'plan-checker');
   const explorerModelId = getRuntimeModelOverride(config, 'opencode', 'approach-explorer');
@@ -115,8 +116,8 @@ function buildOpenCodeEntries({ cwd, workflows }) {
   const entries = workflows.map((workflow) => ({
     relativePath: `.opencode/commands/${workflow.name}.md`,
     expectedContent: workflow.name === 'gsdd-plan'
-      ? renderOpenCodePlanCommand()
-      : renderOpenCodeCommandContent(workflow),
+      ? renderOpenCodePlanCommand({ stateDirName })
+      : renderOpenCodeCommandContent(workflow, { stateDirName }),
   }));
 
   entries.push(
@@ -150,31 +151,33 @@ function buildCodexEntries({ cwd }) {
   ];
 }
 
-function buildWorkspaceHelperEntries() {
+function buildWorkspaceHelperEntries(stateDirName) {
   return buildPlanningCliHelperEntries({
     packageName: PACKAGE_JSON.name,
     packageVersion: PACKAGE_JSON.version,
+    stateDirName,
   }).map((entry) => ({
-    relativePath: `.planning/${entry.relativePath}`,
+    relativePath: `${stateDirName}/${entry.relativePath}`,
     expectedContent: entry.content,
   }));
 }
 
 export function collectExpectedRuntimeSurfaceGroups({ cwd = process.cwd(), workflows }) {
+  const stateDirName = resolveStateDir(cwd).name;
   return [
     {
       runtime: 'workspace-helper',
       label: 'workspace workflow helper',
-      root: '.planning/bin',
+      root: `${stateDirName}/bin`,
       repairCommand: 'npx -y gsdd-cli update',
-      entries: buildWorkspaceHelperEntries(),
+      entries: buildWorkspaceHelperEntries(stateDirName),
     },
     {
       runtime: 'portable',
       label: 'portable skills',
       root: '.agents/skills',
       repairCommand: 'npx -y gsdd-cli update',
-      entries: buildPortableSkillEntries(workflows).map((entry) => ({
+      entries: buildPortableSkillEntries(workflows, { stateDirName }).map((entry) => ({
         relativePath: entry.relativePath,
         expectedContent: entry.content,
       })),
@@ -184,14 +187,14 @@ export function collectExpectedRuntimeSurfaceGroups({ cwd = process.cwd(), workf
       label: 'Claude Code native surfaces',
       root: '.claude',
       repairCommand: 'npx -y gsdd-cli update --tools claude',
-      entries: buildClaudeEntries({ cwd, workflows }),
+      entries: buildClaudeEntries({ cwd, workflows, stateDirName }),
     },
     {
       runtime: 'opencode',
       label: 'OpenCode native surfaces',
       root: '.opencode',
       repairCommand: 'npx -y gsdd-cli update --tools opencode',
-      entries: buildOpenCodeEntries({ cwd, workflows }),
+      entries: buildOpenCodeEntries({ cwd, workflows, stateDirName }),
     },
     {
       runtime: 'codex',
@@ -206,7 +209,7 @@ export function collectExpectedRuntimeSurfaceGroups({ cwd = process.cwd(), workf
 export function evaluateRuntimeFreshness({ cwd = process.cwd(), workflows = [] }) {
   const groups = collectExpectedRuntimeSurfaceGroups({ cwd, workflows }).map((group) => {
     const installed = group.runtime === 'workspace-helper'
-      ? existsSync(join(cwd, '.planning'))
+      ? existsSync(resolveStateDir(cwd).dir)
       : existsSync(join(cwd, group.root));
     const comparisons = installed
       ? group.entries.map((entry) => compareGeneratedFile({

package/bin/lib/state-dir.mjs

@@ -0,0 +1,45 @@
+// state-dir.mjs — Single source of truth for the Workspine state directory.
+//
+// Workspine keeps everything in ONE folder: .work/. Older projects used
+// .planning/. This module is the only place that decides which folder the tool
+// reads and writes for a given repo root. No other module may hardcode the name.
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+export const STATE_DIR_NAME = '.work';
+export const LEGACY_STATE_DIR_NAME = '.planning';
+
+export const MIGRATION_NOTICE =
+  'Note: reading legacy .planning/ — new Workspine projects use .work/. Your .planning/ still works; move its files under .work/ when convenient.';
+
+// True when a repo root already holds Workspine state in EITHER the current
+// (.work) or legacy (.planning) location. Used for workspace-root discovery.
+export function hasStateMarker(root) {
+  return (
+    existsSync(join(root, STATE_DIR_NAME, 'config.json')) ||
+    existsSync(join(root, STATE_DIR_NAME)) ||
+    existsSync(join(root, LEGACY_STATE_DIR_NAME, 'config.json')) ||
+    existsSync(join(root, LEGACY_STATE_DIR_NAME))
+  );
+}
+
+// Decide which state directory to use for a repo root.
+// Precedence (config.json is the "really initialized" marker):
+//   1. .work/config.json     -> .work     (migration done / new project)
+//   2. .planning/config.json -> .planning (legacy; dual-read + notice)
+//   3. .work/ dir            -> .work
+//   4. .planning/ dir        -> .planning (legacy; dual-read + notice)
+//   5. neither               -> .work     (brand-new repo default)
+export function resolveStateDir(root) {
+  const workDir = join(root, STATE_DIR_NAME);
+  const legacyDir = join(root, LEGACY_STATE_DIR_NAME);
+  const work = { dir: workDir, name: STATE_DIR_NAME, legacy: false, migrationNotice: null };
+  const legacy = { dir: legacyDir, name: LEGACY_STATE_DIR_NAME, legacy: true, migrationNotice: MIGRATION_NOTICE };
+
+  if (existsSync(join(workDir, 'config.json'))) return work;
+  if (existsSync(join(legacyDir, 'config.json'))) return legacy;
+  if (existsSync(workDir)) return work;
+  if (existsSync(legacyDir)) return legacy;
+  return work;
+}

package/bin/lib/templates.mjs

@@ -1,17 +1,20 @@
 // templates.mjs - Project template and role installation/refresh helpers
 
-import { existsSync, mkdirSync, readdirSync, cpSync, unlinkSync } from 'fs';
-import { join } from 'path';
+import { createHash } from 'crypto';
+import { existsSync, mkdirSync, readdirSync, cpSync, unlinkSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { basename, join } from 'path';
 import { fileHash, readManifest } from './manifest.mjs';
+import { localizeStateDirReferences } from './rendering.mjs';
 
-export function installProjectTemplates({ planningDir, distilledDir, agentsDir }) {
+export function installProjectTemplates({ planningDir, distilledDir, agentsDir, stateDirName = '.work' }) {
   const localTemplatesDir = join(planningDir, 'templates');
   const globalTemplatesDir = join(distilledDir, 'templates');
+  const stateName = basename(planningDir);
 
   if (!existsSync(localTemplatesDir)) {
     if (existsSync(globalTemplatesDir)) {
-      cpSync(globalTemplatesDir, localTemplatesDir, { recursive: true });
-      console.log('  - copied templates to .planning/templates/');
+      copyTemplateTree(globalTemplatesDir, localTemplatesDir, { stateDirName });
+      console.log(`  - copied templates to ${stateName}/templates/`);
       // Warn-only by design: init should not fail on missing templates because
       // the user may still proceed and fix later. The hard gate lives in
       // `gsdd health` (E6/E7/E8) which reports these as errors. This is the
@@ -33,7 +36,7 @@ export function installProjectTemplates({ planningDir, distilledDir, agentsDir }
       console.log('  - WARN: missing distilled/templates/; cannot copy templates');
     }
   } else {
-    console.log('  - .planning/templates/ already exists');
+    console.log(`  - ${stateName}/templates/ already exists`);
   }
 
   const localRolesDir = join(localTemplatesDir, 'roles');
@@ -41,18 +44,18 @@ export function installProjectTemplates({ planningDir, distilledDir, agentsDir }
     if (existsSync(agentsDir)) {
       mkdirSync(localRolesDir, { recursive: true });
       for (const file of listRoleFiles(agentsDir)) {
-        cpSync(join(agentsDir, file), join(localRolesDir, file));
+        copyTemplateFile(join(agentsDir, file), join(localRolesDir, file), { stateDirName });
       }
-      console.log('  - copied role contracts to .planning/templates/roles/');
+      console.log(`  - copied role contracts to ${stateName}/templates/roles/`);
     } else {
       console.log('  - WARN: missing agents/; cannot copy role contracts');
     }
   } else {
-    console.log('  - .planning/templates/roles/ already exists');
+    console.log(`  - ${stateName}/templates/roles/ already exists`);
   }
 }
 
-export function refreshTemplates({ planningDir, distilledDir, agentsDir, isDry = false }) {
+export function refreshTemplates({ planningDir, distilledDir, agentsDir, isDry = false, stateDirName = '.work' }) {
   const existingManifest = readManifest(planningDir);
   const globalTemplatesDir = join(distilledDir, 'templates');
   const localTemplatesDir = join(planningDir, 'templates');
@@ -65,11 +68,45 @@ export function refreshTemplates({ planningDir, distilledDir, agentsDir, isDry =
   ];
 
   for (const category of categories) {
-    refreshCategory(category, existingManifest, isDry);
+    refreshCategory(category, existingManifest, isDry, { stateDirName });
   }
 
-  refreshRootTemplates(globalTemplatesDir, localTemplatesDir, existingManifest, isDry);
-  refreshRoles(agentsDir, join(localTemplatesDir, 'roles'), existingManifest, isDry);
+  refreshRootTemplates(globalTemplatesDir, localTemplatesDir, existingManifest, isDry, { stateDirName });
+  refreshRoles(agentsDir, join(localTemplatesDir, 'roles'), existingManifest, isDry, { stateDirName });
+}
+
+function contentHash(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+function localizedTemplateContent(srcPath, { stateDirName = '.work' } = {}) {
+  return localizeStateDirReferences(readFileSync(srcPath, 'utf-8'), { stateDirName });
+}
+
+function sourceTemplateHash(srcPath, { stateDirName = '.work' } = {}) {
+  if (!srcPath.endsWith('.md')) return fileHash(srcPath);
+  return contentHash(localizedTemplateContent(srcPath, { stateDirName }));
+}
+
+function copyTemplateFile(srcPath, destPath, { stateDirName = '.work' } = {}) {
+  if (!srcPath.endsWith('.md')) {
+    cpSync(srcPath, destPath);
+    return;
+  }
+  writeFileSync(destPath, localizedTemplateContent(srcPath, { stateDirName }));
+}
+
+function copyTemplateTree(srcDir, destDir, { stateDirName = '.work' } = {}) {
+  mkdirSync(destDir, { recursive: true });
+  for (const entry of readdirSync(srcDir)) {
+    const srcPath = join(srcDir, entry);
+    const destPath = join(destDir, entry);
+    if (statSync(srcPath).isDirectory()) {
+      copyTemplateTree(srcPath, destPath, { stateDirName });
+    } else {
+      copyTemplateFile(srcPath, destPath, { stateDirName });
+    }
+  }
 }
 
 function listRoleFiles(agentsDir) {
@@ -78,7 +115,7 @@ function listRoleFiles(agentsDir) {
   );
 }
 
-function refreshCategory({ name, src, dest, manifestKey }, existingManifest, isDry) {
+function refreshCategory({ name, src, dest, manifestKey }, existingManifest, isDry, { stateDirName = '.work' } = {}) {
   if (!existsSync(src)) return;
   if (!existsSync(dest) && !isDry) {
     mkdirSync(dest, { recursive: true });
@@ -91,7 +128,7 @@ function refreshCategory({ name, src, dest, manifestKey }, existingManifest, isD
   for (const file of sourceFiles) {
     const srcPath = join(src, file);
     const destPath = join(dest, file);
-    const srcHash = fileHash(srcPath);
+    const srcHash = sourceTemplateHash(srcPath, { stateDirName });
 
     if (existsSync(destPath)) {
       const destHash = fileHash(destPath);
@@ -106,7 +143,7 @@ function refreshCategory({ name, src, dest, manifestKey }, existingManifest, isD
     if (isDry) {
       console.log(`  - would refresh ${name}/${file}`);
     } else {
-      cpSync(srcPath, destPath);
+      copyTemplateFile(srcPath, destPath, { stateDirName });
       console.log(`  - refreshed ${name}/${file}`);
     }
   }
@@ -126,7 +163,7 @@ function refreshCategory({ name, src, dest, manifestKey }, existingManifest, isD
   }
 }
 
-function refreshRootTemplates(globalTemplatesDir, localTemplatesDir, existingManifest, isDry) {
+function refreshRootTemplates(globalTemplatesDir, localTemplatesDir, existingManifest, isDry, { stateDirName = '.work' } = {}) {
   if (!existsSync(globalTemplatesDir)) return;
 
   const manifestHashes = existingManifest?.templates?.root || null;
@@ -135,7 +172,7 @@ function refreshRootTemplates(globalTemplatesDir, localTemplatesDir, existingMan
   for (const file of sourceFiles) {
     const srcPath = join(globalTemplatesDir, file);
     const destPath = join(localTemplatesDir, file);
-    const srcHash = fileHash(srcPath);
+    const srcHash = sourceTemplateHash(srcPath, { stateDirName });
 
     if (existsSync(destPath)) {
       const destHash = fileHash(destPath);
@@ -150,7 +187,7 @@ function refreshRootTemplates(globalTemplatesDir, localTemplatesDir, existingMan
     if (isDry) {
       console.log(`  - would refresh templates/${file}`);
     } else {
-      cpSync(srcPath, destPath);
+      copyTemplateFile(srcPath, destPath, { stateDirName });
       console.log(`  - refreshed templates/${file}`);
     }
   }
@@ -174,7 +211,7 @@ function refreshRootTemplates(globalTemplatesDir, localTemplatesDir, existingMan
   }
 }
 
-function refreshRoles(agentsDir, localRolesDir, existingManifest, isDry) {
+function refreshRoles(agentsDir, localRolesDir, existingManifest, isDry, { stateDirName = '.work' } = {}) {
   if (!existsSync(agentsDir)) return;
   if (!existsSync(localRolesDir) && !isDry) {
     mkdirSync(localRolesDir, { recursive: true });
@@ -189,7 +226,7 @@ function refreshRoles(agentsDir, localRolesDir, existingManifest, isDry) {
   for (const file of sourceFiles) {
     const srcPath = join(agentsDir, file);
     const destPath = join(localRolesDir, file);
-    const srcHash = fileHash(srcPath);
+    const srcHash = sourceTemplateHash(srcPath, { stateDirName });
 
     if (existsSync(destPath)) {
       const destHash = fileHash(destPath);
@@ -204,7 +241,7 @@ function refreshRoles(agentsDir, localRolesDir, existingManifest, isDry) {
     if (isDry) {
       console.log(`  - would refresh roles/${file}`);
     } else {
-      cpSync(srcPath, destPath);
+      copyTemplateFile(srcPath, destPath, { stateDirName });
       console.log(`  - refreshed roles/${file}`);
     }
   }

package/bin/lib/work-context.mjs

@@ -12,6 +12,8 @@ import {
   writeSync,
 } from 'fs';
 import { basename, dirname, join, relative, resolve } from 'path';
+import { evaluateLifecycleState } from './lifecycle-state.mjs';
+import { resolveStateDir } from './state-dir.mjs';
 
 export const WORK_DIR_NAME = '.work';
 
@@ -657,14 +659,22 @@ export function inspectWorkContext(cwd = process.cwd()) {
   const questions = readOpenQuestions(paths.workDir);
   const evidence = readJsonIfExists(paths.evidenceManifest);
   const graph = readGraphEvents(paths.workDir);
-  const planningDir = join(paths.root, '.planning');
+  const { dir: planningDir, name: stateDirName, migrationNotice } = resolveStateDir(paths.root);
+  const lifecycle = evaluateLifecycleState({ planningDir });
   const planning = {
     exists: existsSync(planningDir),
     has_spec: existsSync(join(planningDir, 'SPEC.md')),
     has_roadmap: existsSync(join(planningDir, 'ROADMAP.md')),
     has_milestones: existsSync(join(planningDir, 'MILESTONES.md')),
     has_config: existsSync(join(planningDir, 'config.json')),
+    has_brownfield_change: lifecycle.brownfieldChange.exists,
+    non_phase_state: lifecycle.nonPhaseState,
+    brownfield_change: lifecycle.brownfieldChange,
+    current_phase: lifecycle.currentPhase?.number || null,
+    next_phase: lifecycle.nextPhase?.number || null,
+    counts: lifecycle.counts,
     phases: scanPhaseEvidence(planningDir),
+    state_dir_name: stateDirName,
   };
   return {
     paths,
@@ -676,6 +686,7 @@ export function inspectWorkContext(cwd = process.cwd()) {
     evidence,
     graph,
     planning,
+    migration_notice: migrationNotice,
     milestone: inspectWorkMilestone(paths.workDir),
     focus_exists: existsSync(paths.focus),
     handoff_exists: existsSync(paths.handoff),

package/bin/lib/workflows.mjs

@@ -17,7 +17,6 @@ export const WORKFLOWS = [
   defineWorkflow({ name: 'gsdd-audit-milestone', workflow: 'audit-milestone.md', description: 'Audit a completed milestone - cross-phase integration, requirements coverage, E2E flows' }),
   defineWorkflow({ name: 'gsdd-complete-milestone', workflow: 'complete-milestone.md', description: 'Complete milestone - archive, evolve spec, collapse roadmap' }),
   defineWorkflow({ name: 'gsdd-new-milestone', workflow: 'new-milestone.md', description: 'New milestone - gather goals, define requirements, create roadmap phases' }),
-  defineWorkflow({ name: 'gsdd-plan-milestone-gaps', workflow: 'plan-milestone-gaps.md', description: 'Plan gap closure phases from audit results' }),
   defineWorkflow({ name: 'gsdd-quick', workflow: 'quick.md', description: 'Quick task - plan and execute a sub-hour task outside the phase cycle' }),
   defineWorkflow({ name: 'gsdd-pause', workflow: 'pause.md', description: 'Pause work - save session context for seamless resumption' }),
   defineWorkflow({ name: 'gsdd-resume', workflow: 'resume.md', description: 'Resume work - restore context and route to next action' }),

package/bin/lib/workspace-root.mjs

@@ -1,13 +1,14 @@
 import { existsSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
+import { hasStateMarker, resolveStateDir } from './state-dir.mjs';
 
 function normalizePath(value, cwd) {
   return resolve(cwd, String(value));
 }
 
 function hasPlanningMarker(root) {
-  return existsSync(join(root, '.planning', 'config.json')) || existsSync(join(root, '.planning'));
+  return hasStateMarker(root);
 }
 
 export function consumeWorkspaceRootArg(rawArgs = []) {
@@ -71,7 +72,7 @@ export function resolveWorkspaceContext(rawArgs = [], { cwd = process.cwd(), env
       invalid: true,
       error: 'Usage: --workspace-root <path>',
       workspaceRoot: resolve(cwd),
-      planningDir: join(resolve(cwd), '.planning'),
+      planningDir: resolveStateDir(resolve(cwd)).dir,
     };
   }
 
@@ -81,9 +82,9 @@ export function resolveWorkspaceContext(rawArgs = [], { cwd = process.cwd(), env
       return {
         args,
         invalid: true,
-        error: `Workspace root does not contain .planning/: ${workspaceRootArg}`,
+        error: `Workspace root does not contain .work/ or .planning/: ${workspaceRootArg}`,
         workspaceRoot: explicitRoot,
-        planningDir: join(explicitRoot, '.planning'),
+        planningDir: resolveStateDir(explicitRoot).dir,
       };
     }
   }
@@ -105,7 +106,9 @@ export function resolveWorkspaceContext(rawArgs = [], { cwd = process.cwd(), env
         args,
         invalid: false,
         workspaceRoot: candidate,
-        planningDir: join(candidate, '.planning'),
+        planningDir: resolveStateDir(candidate).dir,
+        stateDirName: resolveStateDir(candidate).name,
+        migrationNotice: resolveStateDir(candidate).migrationNotice,
       };
     }
   }
@@ -115,7 +118,9 @@ export function resolveWorkspaceContext(rawArgs = [], { cwd = process.cwd(), env
     args,
     invalid: false,
     workspaceRoot: fallbackRoot,
-    planningDir: join(fallbackRoot, '.planning'),
+    planningDir: resolveStateDir(fallbackRoot).dir,
+    stateDirName: resolveStateDir(fallbackRoot).name,
+    migrationNotice: resolveStateDir(fallbackRoot).migrationNotice,
   };
 }
 

package/distilled/DESIGN.md

@@ -74,6 +74,7 @@
 61. [Deliberate Subagent Contract](#d61---deliberate-subagent-contract)
 62. [Repo-Native UI Proof Contract](#d62---repo-native-ui-proof-contract)
 63. [Computed-First Control Map](#d63---computed-first-control-map)
+64. [Work-Native Continuity Authority](#d64---work-native-continuity-authority)
 
 ---
 
@@ -2507,7 +2508,7 @@ Sub-gap (b) was closed by D28's `<persistence>` mandate and guarded by G30. Sub-
 
 ## D56 - Executable Brownfield Routing And Widen-Only Escalation
 
-**Decision (2026-04-21):** Brownfield routing should treat `CHANGE.md` as the default operational anchor and allow a surviving `phase` or `quick` checkpoint to outrank it only when one strict-match rule proves the checkpoint is still the active execution surface. From concrete brownfield state, `/gsdd-new-project` remains available only as an intentional widen path into full milestone setup, not as an accidental fallback recommendation.
+**Decision (2026-04-21; revised 2026-06-30):** Brownfield routing should treat `CHANGE.md` as the default operational anchor and allow a surviving `phase` or `quick` checkpoint to outrank it only when one strict-match rule proves the checkpoint is still the active execution surface. From concrete brownfield state, `/gsdd-new-project` remains available only as an intentional widen path into full milestone setup, not as an accidental fallback recommendation. Active bounded brownfield planning uses the existing `gsdd-plan` workflow with explicit `brownfield-change` authority instead of being forced through unrelated ROADMAP phase membership.
 
 **Context:**
 - D54 defined the bounded `brownfield-change/` contract and D55 established its continuity floor, but the routing matrix above those artifacts was still inconsistent: `progress` could still route back through stale checkpoint residue, `resume` could still make a non-matching checkpoint primary, and `quick` / `map-codebase` / `new-project` still risked implying that full lifecycle initialization was the normal fallback from already-concrete bounded work.
@@ -2524,12 +2525,17 @@ Sub-gap (b) was closed by D28's `<persistence>` mandate and guarded by G30. Sub-
   - `quick` uses it when the bounded change is still undefined or when the user intentionally widens scope
   - `map-codebase` frames it as full lifecycle setup only when the user wants to widen beyond bounded brownfield work
   - `new-project` itself recognizes existing `CHANGE.md` continuity and treats invocation from that state as deliberate promotion, not mistaken routing
+- Keep `gsdd-plan` as the bounded brownfield planning entrypoint when an active `.planning/brownfield-change/CHANGE.md` exists:
+  - `gsdd next --json` reports `authority: brownfield_change` and routes to `gsdd-plan`
+  - `gsdd-plan` classifies the target before phase preflight
+  - `lifecycle-preflight plan brownfield-change` authorizes the change-folder lane without requiring the active ROADMAP phase to match a PBI or consumer ticket
 - Lock the contract with helper, guard, and generated-surface scenario coverage.
 
 **Why this fits the codebase:**
 - It extends the existing provenance helper and generated-surface workflow model instead of inventing another routing registry or hidden state store.
 - It preserves the D55 one-anchor split: checkpoints stay visible and resume-owned, but they do not silently demote the active brownfield contract unless the repo can prove the checkpoint is still current.
 - It keeps the brownfield lane bounded by removing accidental fallback escalation while still preserving an intentional route into milestone planning.
+- It fixes the consumer failure mode where PBI/ticket-sized brownfield work was blocked by an unrelated active ROADMAP phase while still avoiding a new workflow or auto-runner surface.
 - It matches the repo's anti-drift posture: ambiguous or weak routing proof fails closed in favor of the current operational anchor.
 
 **Evidence:**
@@ -2549,7 +2555,7 @@ Sub-gap (b) was closed by D28's `<persistence>` mandate and guarded by G30. Sub-
 - `get-shit-done/workflows/progress.md`, `get-shit-done/workflows/resume.md`, `get-shit-done/workflows/quick.md`, `get-shit-done/workflows/new-project.md`
 
 **Consequences:**
-- Brownfield next-step routing now has one deterministic precedence rule instead of five workflow-local interpretations.
+- Brownfield next-step routing now has one deterministic precedence rule instead of five workflow-local interpretations, and active bounded brownfield planning has one explicit preflight authority.
 - A stale or unrelated `phase` / `quick` checkpoint can remain reviewable without automatically hijacking the current brownfield lane.
 - `/gsdd-new-project` remains part of the system, but as deliberate promotion from concrete brownfield work rather than as a generic fallback.
 - Phase 43 can now focus on bounded growth and milestone handoff instead of first repairing invalid routing recommendations.
@@ -2919,6 +2925,56 @@ Posture compatibility is part of that closeout contract: `repo_closeout` and `ru
 - `closeout-report` is a compact replay/report helper, not `progress`, `verify`, milestone audit, release automation, cleanup, or a dashboard. The source CLI path includes full health diagnostics; the generated helper reports health availability as a typed warning if the full health builder is not present in that helper runtime.
 - Future health hardening can consume the same helper output for stricter reporting, but must avoid turning local annotations into product truth.
 
+## D64 - Work-Native Continuity Authority
+
+**Decision (2026-06-29; revised 2026-06-30):** `.work` becomes the canonical continuity surface for `gsdd next` and future work-native state, while `.planning` remains readable legacy lifecycle input during migration and for existing workflows that still own their write paths. The authority used by routing, preflight, verification, and auto-gate packets must be explicit in machine-readable output. Repo policy, not Workspine itself, decides whether `.work` is committed or local-only; in the Workspine framework repo, `.work` is local dogfood/runtime state and should not be tracked. During migration, `gsdd next` may also route existing `.planning` brownfield-change authority into `gsdd-plan` without treating `.planning` ROADMAP phases as the only valid plan target.
+
+**Context:**
+- PR #116 merged the first `gsdd next` / `.work` continuity slice, but the framework repo still had split truth: `.work/milestone` described a locally implemented continuity milestone while `.planning` still described v2.0.0 parallel orchestration and P65/P66.
+- Old v2.0.0 parallel orchestration is too distant to migrate wholesale. Its useful ideas are partial extraction candidates: write ownership and closeout truth gates move into work-native auto-gate safety now; the PR #113 registry material remains parked for later extraction or rescue.
+- OpenSpec's change/archive model and LeanSpec's compact spec guidance both reinforce that long-lived state needs clear ownership and small, reviewable truth surfaces rather than scattered status prose.
+- The cited OpenAI and Anthropic agent-orchestration guidance favors manager-owned orchestration, explicit handoffs, guardrails, evaluator loops, and bounded tool authority rather than an unbounded agent loop.
+- MCP and agent-tooling security guidance reinforce that tool/resource outputs and local memory surfaces are untrusted inputs unless their provenance, privacy posture, and authority boundary are explicit.
+
+**Decision:**
+- Treat `.work` as the source of truth for `gsdd next` continuity routing, focus packets, work-native milestone state, decisions, questions, evidence pointers, dogfood findings, and bounded auto-gate state.
+- Keep `.planning` readable as legacy lifecycle input. Existing `gsdd-plan`, `gsdd-execute`, `gsdd-verify`, audit, complete-milestone, phase-status, and helper write paths continue to work against `.planning` until each surface is deliberately bridged or migrated.
+- Require routing and preflight output to report authority explicitly, using scoped values such as `work_milestone`, `planning`, or `blocked/conflict`; `.work` authority must not silently mask repo truth, PR truth, or unrelated `.planning` blockers.
+- Include `brownfield_change` as an explicit scoped authority for existing bounded-change artifacts. This is a compatibility bridge, not a new lifecycle root: it reuses the current `gsdd-plan` workflow and the brownfield-change folder contract.
+- Preserve repo/control-map truth as the highest authority for branch, PR, worktree, dirty-state, and delivery claims. `.work` can carry intent and continuity; it cannot convert local prose into integrated repo truth.
+- Define execute-until-gate as task-bounded automation, not session-bounded autonomy. Auto mode may run typed, reviewed, `type=auto` tasks and bounded verification/repair cycles only until a human gate, verification gap, repeated blocker, authority conflict, trust boundary, or scope expansion stops it.
+- Keep milestone completion user-owned. `gsdd next` may route to completion approval, but it must not mark a milestone complete autonomously.
+- Treat `.work` tracking as repo policy. Consumer projects may commit `.work` if that fits their privacy and collaboration model. The Workspine framework repo keeps `.work` local-only because it is dogfooding its own runtime state while developing the framework.
+- Reframe the old v2.0.0 parallel-orchestration milestone as legacy input rather than the active next milestone. Preserve write-set ownership and closeout truth gates in the new work-native authority milestone; park PR #113/P65 registry material as extract-later.
+
+**Leverage:**
+- Lost: the old clean "v2.0.0 parallel PR orchestration next" story and the convenience of treating `.planning` as the only lifecycle state root.
+- Kept: repo-native files, plain markdown workflow contracts, existing `.planning` compatibility, computed-first control-map authority, plan/execute/verify separation, and human-owned completion.
+- Gained: a clear continuity authority for `gsdd next`, explicit migration semantics, safer execute-until-gate foundations, repo-policy-driven tracking, a brownfield compatibility bridge for bounded consumer changes, and a typed authority boundary that prevents future auto mode from running on stale or contradictory state.
+
+**Evidence:**
+- `bin/lib/next.mjs`, `bin/lib/work-context.mjs`, `bin/lib/lifecycle-preflight.mjs`
+- `tests/gsdd.next.test.cjs` and `tests/phase.test.cjs`
+- `README.md` for the public `.work` tracking policy
+- PR #116, merged 2026-06-29 with merge commit `b91a138c42f2ab3ff7376317031208c7a716decd`: `https://github.com/PatrickSys/workspine/pull/116`
+- PR #113, still open as the parked registry extraction candidate: `https://github.com/PatrickSys/workspine/pull/113`
+- GSD comparison sources: `agents/_archive/gsd-roadmapper.md`, `agents/_archive/gsd-planner.md`, `agents/_archive/gsd-executor.md`, and `agents/_archive/gsd-verifier.md`. These preserve lifecycle rigor around requirements, plans, state, execution, and verification, but they do not define a separate work-native `next` authority root; GSDD preserves the rigor while moving agent-facing continuity into `.work`.
+- OpenSpec docs: `https://openspec.dev/`
+- LeanSpec docs: `https://www.lean-spec.dev/docs/guide/first-principles`
+- OpenAI Agents SDK orchestration docs: `https://developers.openai.com/api/docs/guides/agents/orchestration`
+- OpenAI guardrails and approvals docs: `https://developers.openai.com/api/docs/guides/agents/guardrails-approvals`
+- OpenAI agent evals docs: `https://developers.openai.com/api/docs/guides/agent-evals`
+- Anthropic agent engineering guidance: `https://www.anthropic.com/engineering/building-effective-agents`
+- Anthropic long-running harness guidance: `https://www.anthropic.com/engineering/harness-design-long-running-apps`
+- Model Context Protocol security guidance: `https://modelcontextprotocol.io/specification/2025-06-18/basic/security_best_practices`
+- GitHub Copilot repository instructions docs: `https://docs.github.com/en/copilot/concepts/prompting/response-customization`
+
+**Consequences:**
+- Future `gsdd next` and auto-gate work should start by reconciling `.work`, `.planning`, repo/control-map, PR truth, and active brownfield-change authority into one conservative next action or one explicit blocker.
+- Future milestones must not say "P65 shipped, start P66" unless repo, PR, `.work`, and legacy `.planning` truth agree.
+- Future auto mode must expose typed gates, loop guards, evidence requirements, stop reasons, and authority source in JSON. It must never rely on prose such as "continue autonomously" as execution permission.
+- Future framework work should not add tracked `.work` runtime state by default. Durable product changes belong in source/design/workflow/test files; `.work` dogfood state remains local unless explicitly promoted.
+
 ---
 
 ## Maintenance

package/distilled/EVIDENCE-INDEX.md

@@ -430,10 +430,11 @@
 ## D56 — Executable Brownfield Routing And Widen-Only Escalation
 - `.planning/SPEC.md` (`BROWNFIELD-03`, Current State, key decision row)
 - `.planning/phases/42-executable-brownfield-routing/42-PLAN.md`
-- `bin/lib/provenance.mjs`
+- `bin/lib/provenance.mjs`, `bin/lib/lifecycle-state.mjs`, `bin/lib/next.mjs`, `bin/lib/work-context.mjs`, `bin/lib/lifecycle-preflight.mjs`
 - `distilled/workflows/progress.md`, `distilled/workflows/resume.md`, `distilled/workflows/quick.md`, `distilled/workflows/map-codebase.md`, `distilled/workflows/new-project.md`
+- `distilled/workflows/plan.md`
 - `.internal-research/TODO.md`, `.internal-research/gaps.md`
-- `tests/phase.test.cjs`, `tests/gsdd.guards.test.cjs`, `tests/gsdd.scenarios.test.cjs`
+- `tests/phase.test.cjs`, `tests/gsdd.next.test.cjs`, `tests/gsdd.init.test.cjs`, `tests/gsdd.guards.test.cjs`, `tests/gsdd.scenarios.test.cjs`
 - `get-shit-done/workflows/progress.md`, `get-shit-done/workflows/resume.md`, `get-shit-done/workflows/quick.md`, `get-shit-done/workflows/new-project.md`
 
 ## D57 — Bounded Brownfield Growth And Context-Preserving Milestone Handoff
@@ -515,6 +516,18 @@
 - OpenSpec comparison: OpenSpec change archive flow does not own long-running multi-worktree local-state reconciliation as a portable harness surface
 - Harness sources: https://www.anthropic.com/engineering/harness-design-long-running-apps, https://code.claude.com/docs/en/worktrees, https://developers.openai.com/codex/cloud, https://developers.openai.com/api/docs/guides/agents/orchestration, https://developers.openai.com/api/docs/guides/agents/guardrails-approvals, https://developers.openai.com/api/docs/guides/agent-evals, https://docs.github.com/en/copilot/concepts/agents/cloud-agent/about-cloud-agent, https://agent-browser.dev/sessions, https://developer.chrome.com/docs/devtools/agents
 
+## D64 — Work-Native Continuity Authority
+- `bin/lib/next.mjs`, `bin/lib/work-context.mjs`, `bin/lib/lifecycle-preflight.mjs`, `bin/lib/rendering.mjs`
+- `distilled/workflows/plan.md`
+- `tests/gsdd.next.test.cjs`, `tests/phase.test.cjs`, `tests/gsdd.init.test.cjs`, `tests/gsdd.guards.test.cjs`, `tests/gsdd.scenarios.test.cjs`
+- `README.md` for the public `.work` tracking policy
+- PR #116 merged 2026-06-29, merge commit `b91a138c42f2ab3ff7376317031208c7a716decd`: https://github.com/PatrickSys/workspine/pull/116
+- PR #113 remains open as parked registry extraction input: https://github.com/PatrickSys/workspine/pull/113
+- GSD comparison sources: `agents/_archive/gsd-roadmapper.md`, `agents/_archive/gsd-planner.md`, `agents/_archive/gsd-executor.md`, `agents/_archive/gsd-verifier.md`; upstream GSD lifecycle rigor does not define a separate work-native `next` authority root, so GSDD keeps the lifecycle rigor while moving agent-facing continuity into `.work`
+- Spec framework sources: https://openspec.dev/, https://www.lean-spec.dev/docs/guide/first-principles
+- Orchestrator sources: https://developers.openai.com/api/docs/guides/agents/orchestration, https://www.anthropic.com/engineering/building-effective-agents
+- Industry guidance sources: https://developers.openai.com/api/docs/guides/agents/guardrails-approvals, https://developers.openai.com/api/docs/guides/agent-evals, https://www.anthropic.com/engineering/harness-design-long-running-apps, https://modelcontextprotocol.io/specification/2025-06-18/basic/security_best_practices, https://docs.github.com/en/copilot/concepts/prompting/response-customization
+
 ---
 
 ## Maintenance