@opengsd/gsd-core 1.13.0 → 1.14.0

package/gsd-core/bin/lib/verification.cjs

@@ -48,6 +48,7 @@ const coreUtilsMod = require("./core-utils.cjs");
 const planningScopeMod = require("./planning-scope.cjs");
 const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
 const runtime_slash_cjs_1 = require("./runtime-slash.cjs");
+const security_cjs_1 = require("./security.cjs");
 const { output, error } = io;
 const { extractPhaseToken, scopeToPhase } = phaseId;
 const { extractFrontmatter } = frontmatterMod;
@@ -251,8 +252,11 @@ function computeCoveredDigest(projectRoot, coveredFiles) {
             // confinement check above is not enough. realpathSync resolves the
             // actual target; re-confining against realRoot closes that gap.
             const real = node_fs_1.default.realpathSync(resolved);
-            const realRel = node_path_1.default.relative(realRoot, real);
-            if (realRel === '' || realRel === '..' || realRel.startsWith(`..${node_path_1.default.sep}`) || node_path_1.default.isAbsolute(realRel)) {
+            // Both operands are already realpath-resolved (this fn's own realpathSync calls
+            // above), so the shared containment comparison applies directly (ADR-4650) —
+            // no re-resolution through assertWithinRoot/tryWithinRoot, which would redo work
+            // this function already owns for its exists-vs-escaped tri-state.
+            if (!(0, security_cjs_1.isContainedIn)(real, realRoot)) {
                 return null;
             }
             const st = node_fs_1.default.statSync(real);
@@ -471,7 +475,7 @@ function resolvePhaseArtifactFile(entries, bareName, options = {}) {
         // filtered out, and if that leaves nothing the code falls through to
         // `allowBare`/`null` deliberately.
         const scoped = options.phaseDirName
-            ? scopeToPhase(candidates, options.phaseDirName)
+            ? scopeToPhase(candidates, options.phaseDirName, options.convention)
             : candidates;
         if (scoped.length > 0)
             return scoped[0];
@@ -528,7 +532,7 @@ function resolveVerificationFile(entries, options = {}) {
 function resolveUatFile(entries, options = {}) {
     return resolvePhaseArtifactFile(entries, 'UAT.md', options);
 }
-function findStaleVerificationSummary(phaseDir, fsImpl = defaultFsImpl, phaseCleanCommitTimesMs = defaultPhaseCleanCommitTimesMs) {
+function findStaleVerificationSummary(phaseDir, fsImpl = defaultFsImpl, phaseCleanCommitTimesMs = defaultPhaseCleanCommitTimesMs, convention) {
     // FS errors (TOCTOU: a SUMMARY listed by scanPhasePlans then removed before statSync;
     // unreadable dir; broken symlink; file->dir swap) must degrade rather than throw
     // uncaught into callers that are NOT under the planning lock (init.manager /
@@ -544,9 +548,20 @@ function findStaleVerificationSummary(phaseDir, fsImpl = defaultFsImpl, phaseCle
         // or sentinel-numbered canonically-shaped file cannot outrank this
         // phase's own (possibly non-canonical) report. #3511: phaseDirName scopes
         // the fallback path to this same phase (see resolveVerificationFile docs).
+        // #4187: allowBare — this staleness seam must see the same report set the
+        // status reader sees, or a bare report could never read `stale` while its
+        // dashed twin could (two answers from one verb).
         const phaseDirName = node_path_1.default.basename(phaseDir);
-        const phaseToken = extractPhaseToken(phaseDirName);
-        const verificationFile = resolveVerificationFile(phaseFiles, { phaseToken, phaseDirName });
+        // #612: derive the token with the resolved convention so a bracket dir's
+        // own token is read behind its `{CODE}.{MM}-` prefix. #4187: keep the bare
+        // report tier aligned with the status reader.
+        const phaseToken = extractPhaseToken(phaseDirName, convention);
+        const verificationFile = resolveVerificationFile(phaseFiles, {
+            allowBare: true,
+            phaseToken,
+            phaseDirName,
+            convention,
+        });
         if (!verificationFile)
             return { determined: true, stale: false };
         const summaryFiles = scanPhasePlans(phaseDir).summaryFiles
@@ -587,7 +602,9 @@ function findStaleVerificationSummary(phaseDir, fsImpl = defaultFsImpl, phaseCle
  * 1. Find the phase's verification report via `resolveVerificationFile`
  *    (canonical `<phase-token>-VERIFICATION.md` preferred; falls back to the
  *    alphabetically-first `*-VERIFICATION.md` that belongs to THIS phase when
- *    none is canonical — #3357/#3511). If none → status 'missing'.
+ *    none is canonical — #3357/#3511; and, when the directory's only report
+ *    is a bare `VERIFICATION.md`, that file — #4187, matching
+ *    `verification.resolve-file`). If none → status 'missing'.
  * 2. Extract `status` from FRONTMATTER ONLY via the shared extractFrontmatter
  *    parser (DEFECT.FRONTMATTER-SCALAR-BROAD-GREP fix — parser anchors at byte 0).
  *    If no frontmatter block or no `status` key → status 'missing'.
@@ -608,7 +625,12 @@ function readVerificationStatus(phaseDir, opts = {}) {
     const fsImpl = opts.fs ?? defaultFsImpl;
     const phaseCleanCommitTimesMs = opts.phaseCleanCommitTimesMs ?? defaultPhaseCleanCommitTimesMs;
     const runtime = opts.runtime ?? 'claude';
-    // Phase token for the gaps_found command
+    // Phase token for the gaps_found command — deliberately convention-LESS
+    // even when `opts.convention` is present: the token becomes a bare COMMAND
+    // ARGUMENT below, and a bare bracket phase number is milestone-ambiguous
+    // (`02` cannot tell GSD.01-02 from GSD.02-02), so the argument keeps its
+    // pre-#612 shape. The convention-aware token is derived separately for
+    // FILE RESOLUTION only (`resolutionToken`, at the readdir below).
     const baseName = node_path_1.default.basename(phaseDir);
     const phaseToken = extractPhaseToken(baseName);
     const derivedPhaseNumber = phaseToken.length > 0 ? phaseToken : baseName;
@@ -624,12 +646,21 @@ function readVerificationStatus(phaseDir, opts = {}) {
     let verificationFile = null;
     try {
         const entries = fsImpl.readdirSync(phaseDir);
-        // #3492: pin selection to THIS phase's own token (already derived above
-        // for the routed command argument) so a stray cross-phase or
-        // sentinel-numbered canonically-shaped file cannot outrank this phase's
-        // own (possibly non-canonical) report. #3511: baseName also scopes the
-        // fallback path to this same phase (see resolveVerificationFile docs).
-        verificationFile = resolveVerificationFile(entries, { phaseToken, phaseDirName: baseName });
+        // #3492: pin selection to THIS phase's own token so a stray cross-phase
+        // or sentinel-numbered canonically-shaped file cannot outrank this phase's
+        // own report. #612: derive a separate convention-aware RESOLUTION token
+        // for bracket directories while the routed command argument above stays
+        // convention-less and milestone-unambiguous. #4187: keep the bare report
+        // tier aligned with every other verification reader.
+        const resolutionToken = opts.convention === 'bracket'
+            ? extractPhaseToken(baseName, opts.convention)
+            : phaseToken;
+        verificationFile = resolveVerificationFile(entries, {
+            allowBare: true,
+            phaseToken: resolutionToken,
+            phaseDirName: baseName,
+            convention: opts.convention,
+        });
     }
     catch {
         // Directory unreadable → treat as missing
@@ -716,7 +747,7 @@ function readVerificationStatus(phaseDir, opts = {}) {
                 !allCurrentArtifactsCovered(phaseDir, coveredFilesVal);
     }
     else {
-        const staleCheck = findStaleVerificationSummary(phaseDir, fsImpl, phaseCleanCommitTimesMs);
+        const staleCheck = findStaleVerificationSummary(phaseDir, fsImpl, phaseCleanCommitTimesMs, opts.convention);
         isStale = staleCheck.determined && staleCheck.stale;
         // staleCheck is either {determined:true, stale:false} (checked; nothing
         // stale) or {determined:false} (could not check — fs/scan/clock failure).
@@ -800,6 +831,7 @@ function isPhaseComplete(phaseDir, deps = {}) {
         phaseCleanCommitTimesMs: deps.phaseCleanCommitTimesMs,
         runtime: deps.runtime,
         phaseNumber: deps.phaseNumber,
+        convention: deps.convention,
     });
     return {
         value: {

package/gsd-core/bin/lib/verify-command-grounding.cjs

@@ -453,7 +453,7 @@ function declaredPathCovers(declaredPaths, norm) {
         if (typeof p !== 'string')
             return false;
         const dp = stripLeadingDotSlash(toSlash(p));
-        return dp === target || dp.startsWith(target + '/');
+        return dp === target || dp.startsWith(target + '/'); // allow-handrolled-containment: declared-path coverage for pending-creation detection, not containment
     });
 }
 /**

package/gsd-core/bin/lib/verify.cjs

@@ -13,6 +13,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_os_1 = __importDefault(require("node:os"));
 const validate_cjs_1 = require("./validate.cjs");
+const security_cjs_1 = require("./security.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- planning-workspace.cjs is an export= CommonJS module
 const planningWorkspace = require("./planning-workspace.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- frontmatter.cjs is an export= CommonJS module
@@ -37,7 +38,7 @@ const worktreeSafetyMod = require("./worktree-safety.cjs");
 // codebase-drift --name-status parse loop).
 const { decodeGitQuotedPath } = worktreeSafetyMod;
 const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
-const security_cjs_1 = require("./security.cjs");
+const security_cjs_2 = require("./security.cjs");
 const runtime_slash_cjs_1 = require("./runtime-slash.cjs");
 const schema_detect_cjs_1 = require("./schema-detect.cjs");
 const markdown_sectionizer_cjs_1 = require("./markdown-sectionizer.cjs");
@@ -63,7 +64,11 @@ const { SEVERITY: HEALTH_SEVERITY, REMEDY_ACTION, REMEDY_RISK, evaluateRules, ev
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- planning-snapshot.cjs is an export= CommonJS module
 const planningSnapshotMod = require("./planning-snapshot.cjs");
 const { buildPlanningSnapshot } = planningSnapshotMod;
-const { planningDir } = planningWorkspace;
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- onboard-projection.cjs is an export= CommonJS module
+const onboardProjectionMod = require("./onboard-projection.cjs");
+const { REQUIRED_CODEBASE_MAP_FILES } = onboardProjectionMod;
+const clock_cjs_1 = require("./clock.cjs");
+const { planningDir, planningRoot, withPlanningLock } = planningWorkspace;
 const { defaultPhaseCleanCommitTimesMs } = verificationMod;
 const { extractFrontmatter, parseMustHavesBlock } = frontmatterMod;
 const { readStateHeadFreshness } = stateMod;
@@ -152,9 +157,12 @@ function verifySummaryCore(cwd, summaryPath, checkFileCount, opts) {
         if (firstSegment.indexOf('.') > 0)
             return false;
         // Containment guard: a `../`-bearing reference must not turn this advisory
-        // into a filesystem existence probe outside the project.
-        const resolved = node_path_1.default.resolve(projectRoot, candidate);
-        if (resolved !== projectRoot && !resolved.startsWith(projectRoot + node_path_1.default.sep))
+        // into a filesystem existence probe outside the project. Lexical (ADR-4650
+        // decision 6): the candidate is a string pulled from a SUMMARY document and
+        // by construction may not exist yet — existence is what gets probed
+        // downstream — and this is a pure string-heuristic filter with no other fs
+        // access, so a realpath call would also change its cost profile.
+        if ((0, security_cjs_1.tryWithinRootLexical)(candidate, projectRoot) === null)
             return false;
         return true;
     };
@@ -1378,11 +1386,11 @@ function cmdVerifyKeyLinks(cwd, planFilePath, raw) {
             // project. Leave sourceContent as null so the existing not-found /
             // pending classification below runs unchanged. Note this guard is
             // narrower than it may look: `from: "."` is a non-empty string, so it
-            // still reaches validatePath and safeReadFile below, and DOES read the
+            // still reaches tryWithinRoot and safeReadFile below, and DOES read the
             // cwd directory (yielding "Source read failed: EISDIR") — this branch
             // only short-circuits the true empty-string case.
-            const fromCheck = (0, security_cjs_1.validatePath)(fromPath, cwd);
-            if (!fromCheck.safe) {
+            const fromContained = (0, security_cjs_2.tryWithinRoot)(fromPath, cwd);
+            if (fromContained === null) {
                 // Do not echo result.error — it embeds absolute host paths.
                 check['path_rejected'] = 'from';
                 check['detail'] = 'Source path rejected — resolves outside the project directory';
@@ -1390,7 +1398,7 @@ function cmdVerifyKeyLinks(cwd, planFilePath, raw) {
                 continue;
             }
             try {
-                sourceContent = (0, shell_command_projection_cjs_1.platformReadSync)(fromCheck.resolved);
+                sourceContent = (0, shell_command_projection_cjs_1.platformReadSync)(fromContained);
             }
             catch (err) {
                 // Report the errno only — never the message or path (untrusted `from:`
@@ -1458,8 +1466,8 @@ function cmdVerifyKeyLinks(cwd, planFilePath, raw) {
                             // An empty/missing `to:` is a malformed plan, not a
                             // path-confinement violation — only a non-empty path that
                             // actually resolves outside the project is path_rejected.
-                            const toCheck = (0, security_cjs_1.validatePath)(toPath, cwd);
-                            if (!toCheck.safe) {
+                            const toContained = (0, security_cjs_2.tryWithinRoot)(toPath, cwd);
+                            if (toContained === null) {
                                 // Do not read a rejected `to:` — treat as no target content
                                 // and do not echo result.error, which embeds absolute host
                                 // paths.
@@ -1467,7 +1475,7 @@ function cmdVerifyKeyLinks(cwd, planFilePath, raw) {
                                 check['detail'] = `Pattern "${link['pattern']}" not found in source; target path rejected — resolves outside the project directory`;
                             }
                             else {
-                                targetContent = (0, shell_command_projection_cjs_1.platformReadSync)(toCheck.resolved);
+                                targetContent = (0, shell_command_projection_cjs_1.platformReadSync)(toContained);
                             }
                         }
                         if (targetContent && pat.test(targetContent)) {
@@ -1823,9 +1831,9 @@ function resolvePhaseDirByToken(phasesDir, phaseArg) {
     const matched = matchPhaseDirs(dirNames, normalizedPhase).matches[0];
     if (matched)
         return node_path_1.default.join(phasesDir, matched);
-    const check = (0, security_cjs_1.validatePath)(phaseArg, phasesDir);
-    if (check.safe && node_fs_1.default.existsSync(check.resolved))
-        return check.resolved;
+    const contained = (0, security_cjs_2.tryWithinRoot)(phaseArg, phasesDir);
+    if (contained !== null && node_fs_1.default.existsSync(contained))
+        return contained;
     return null;
 }
 /**
@@ -1986,6 +1994,110 @@ function cmdVerifySchemaDrift(cwd, phaseArg, skipFlag, raw) {
         skipped: isSkipped,
     }, raw);
 }
+/**
+ * Stamp `last_mapped_commit` (plus `last_mapped_at`) into the frontmatter of
+ * every codebase-map document that exists on disk, using the current HEAD sha.
+ *
+ * #3418: `drift.cjs` shipped a correct `writeMappedCommit` with no production
+ * caller, so no full `/gsd:map-codebase` run ever wrote the machine-readable
+ * baseline that `cmdVerifyCodebaseDrift` reads. The stamp lives in CODE rather
+ * than in a prose instruction to the mapper agent on purpose: an agent that
+ * decides its work is already done skips a prose step silently, which is the
+ * exact class of failure the stamp exists to detect.
+ *
+ * Only documents that already exist are stamped -- a `--fast` map produces four
+ * of the seven, and this must not conjure the missing three as frontmatter-only
+ * stubs that would then satisfy the seven-file completeness probe. `only`
+ * (`--files a.md,b.md`) narrows further, for a caller that refreshed a subset.
+ *
+ * Non-blocking by contract, like every other drift surface: any failure emits
+ * `skipped` with a reason and exits 0.
+ */
+function cmdStampCodebaseMap(cwd, raw, only) {
+    // Non-hoisted: load-order matters for circular dep guard
+    // eslint-disable-next-line @typescript-eslint/no-require-imports -- drift.cjs is an export= CommonJS module
+    const drift = require('./drift.cjs');
+    const emit = (payload) => output(payload, raw);
+    const skip = (reason) => ({
+        stamped: [],
+        commit: null,
+        stamped_at: null,
+        skipped: true,
+        reason,
+    });
+    try {
+        // Probed outside the lock on purpose: taking the lock creates `.planning/`
+        // if absent, and a stamp against a project that has no codebase map at all
+        // must not conjure the directory. The per-document existence check inside
+        // the lock is the one that matters -- a map deleted after this probe lands
+        // on `no-codebase-map` there rather than being recreated as stubs.
+        const codebaseDir = node_path_1.default.join(planningDir(cwd), 'codebase');
+        if (!node_fs_1.default.existsSync(codebaseDir)) {
+            emit(skip('no-codebase-dir'));
+            return;
+        }
+        // `--files` restricts the stamp to the documents a caller actually
+        // refreshed. The execute-phase auto-remap path rewrites STRUCTURE.md and
+        // ARCHITECTURE.md only; stamping the other five at HEAD there would claim a
+        // currency they do not have. Membership is checked against the closed
+        // seven-document set, so an unknown name is a fail-loud non-answer rather
+        // than a path this function tries to resolve. An empty value is refused
+        // rather than read as "no filter": a caller that meant to narrow the scope
+        // must not silently widen it to all seven.
+        let candidates = REQUIRED_CODEBASE_MAP_FILES;
+        if (only) {
+            if (only.length === 0) {
+                emit(skip('empty-codebase-map-file-filter'));
+                return;
+            }
+            const unknown = only.filter((file) => !candidates.includes(file));
+            if (unknown.length > 0) {
+                emit(skip('unknown-codebase-map-file: ' + unknown.join(',')));
+                return;
+            }
+            candidates = candidates.filter((file) => only.includes(file));
+        }
+        // Everything the stamp reads is read under the lock it writes under, the
+        // same lock the rest of the .planning/ writers take. Two stampers can run
+        // at once (the full map-codebase run and the execute-phase auto-remap);
+        // one that resolved HEAD or listed the present documents before waiting on
+        // the lock would write its now-stale sha over the newer one, or recreate a
+        // document deleted while it waited as a frontmatter-only stub.
+        const result = withPlanningLock(cwd, () => {
+            const revProbe = (0, shell_command_projection_cjs_1.execGit)(['rev-parse', 'HEAD'], { cwd });
+            if (revProbe.exitCode !== 0)
+                return skip('not-a-git-repo');
+            const commit = revProbe.stdout.trim();
+            if (!/^[0-9a-f]{7,40}$/.test(commit))
+                return skip('unreadable-head');
+            const present = candidates.filter((file) => node_fs_1.default.existsSync(node_path_1.default.join(codebaseDir, file)));
+            if (present.length === 0)
+                return skip('no-codebase-map');
+            // Host-local calendar day, matching the `**Analysis Date:**` line the
+            // mapper agent writes -- the two freshness markers must not disagree by
+            // a timezone.
+            const stampedAt = clock_cjs_1.realClock.localToday();
+            const write = drift['writeMappedCommit'];
+            const stamped = [];
+            const failed = [];
+            for (const file of present) {
+                try {
+                    write(node_path_1.default.join(codebaseDir, file), commit, stampedAt);
+                    stamped.push(file);
+                }
+                catch (err) {
+                    // One unwritable document must not cost the stamp on the other six.
+                    failed.push({ file, reason: err instanceof Error ? err.message : String(err) });
+                }
+            }
+            return { stamped, failed, commit, stamped_at: stampedAt, skipped: false, reason: null };
+        });
+        emit(result);
+    }
+    catch (err) {
+        emit(skip('exception: ' + (err instanceof Error ? err.message : String(err))));
+    }
+}
 function cmdVerifyCodebaseDrift(cwd, raw) {
     // Non-hoisted: load-order matters for circular dep guard
     // eslint-disable-next-line @typescript-eslint/no-require-imports -- drift.cjs is an export= CommonJS module
@@ -2034,16 +2146,45 @@ function cmdVerifyCodebaseDrift(cwd, raw) {
             });
             return;
         }
-        const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
-        let base = lastMapped;
-        if (!base) {
-            base = EMPTY_TREE;
+        // #3418: an absent or unresolvable baseline means NO COMPARISON IS POSSIBLE.
+        // It is neither zero drift nor total drift, and reporting it as either is a
+        // lie the consumer cannot detect. The former fallback diffed HEAD against
+        // the empty tree, so every tracked file read as newly added and the gate
+        // reported maximum drift identically on every run -- which made a genuinely
+        // stale map indistinguishable from a fresh one, and let `spawn_mapper` fire
+        // a whole-repo remap while presenting itself as an incremental one.
+        if (!lastMapped) {
+            emit({
+                block: false,
+                skipped: true,
+                reason: 'no-mapped-commit',
+                action_required: false,
+                directive: 'none',
+                elements: [],
+                last_mapped_commit: null,
+            });
+            return;
         }
-        else {
-            const verify = (0, shell_command_projection_cjs_1.execGit)(['cat-file', '-t', base], { cwd });
-            if (verify.exitCode !== 0)
-                base = EMPTY_TREE;
+        const baseProbe = (0, shell_command_projection_cjs_1.execGit)(['cat-file', '-t', lastMapped], { cwd });
+        if (baseProbe.exitCode !== 0 || baseProbe.stdout.trim() !== 'commit') {
+            // A stamp git cannot resolve: history rewrite, GC, or a shallow clone.
+            // Distinct reason from 'no-mapped-commit' -- the map claims a baseline,
+            // this repository just cannot see it, which is an operator-actionable
+            // difference (re-map vs. unshallow). A resolvable non-commit (a tree or
+            // blob sha, a ref name) is the same class of bad baseline: git would
+            // happily diff against it and report drift against the wrong object.
+            emit({
+                block: false,
+                skipped: true,
+                reason: 'unresolvable-mapped-commit',
+                action_required: false,
+                directive: 'none',
+                elements: [],
+                last_mapped_commit: lastMapped,
+            });
+            return;
         }
+        const base = lastMapped;
         const diff = (0, shell_command_projection_cjs_1.execGit)(['diff', '--name-status', base, 'HEAD'], { cwd });
         if (diff.exitCode !== 0) {
             emit({
@@ -2056,6 +2197,27 @@ function cmdVerifyCodebaseDrift(cwd, raw) {
             });
             return;
         }
+        // #3418: GSD's own planning artifacts are not codebase structure. A
+        // map-codebase run commits `.planning/codebase/*.md`, so a correctly
+        // stamped baseline would be re-poisoned by the very commit that carries
+        // the stamp -- the next gate invocation would report the map's own seven
+        // documents as seven new directories, back over the default threshold of
+        // three. Derived from planningRoot() rather than a hardcoded literal so a
+        // repoint of the planning root cannot leave this filter behind.
+        //
+        // `git diff --name-status` always prints repo-root-relative paths, so a cwd
+        // below the root needs the `sub/` prefix or the filter matches nothing.
+        // That prefix comes from git (`--show-prefix`: root-relative, forward
+        // slashes, trailing slash, empty at the root). The rejected alternative was
+        // path.relative(`--show-toplevel`, cwd), which mixes two path producers: on
+        // Windows os.tmpdir() hands back the 8.3 short form while git resolves the
+        // long one, so relative() between them yields a `../..` chain that matches
+        // nothing. The `.planning` half below is safe to compute with relative()
+        // because both of its sides are the same cwd string.
+        const prefixProbe = (0, shell_command_projection_cjs_1.execGit)(['rev-parse', '--show-prefix'], { cwd });
+        const repoPrefix = prefixProbe.exitCode === 0 ? prefixProbe.stdout.trim() : '';
+        const planningPrefix = repoPrefix + node_path_1.default.relative(cwd, planningRoot(cwd)).split(node_path_1.default.sep).join('/') + '/';
+        const isPlanningArtifact = (file) => file.split('\\').join('/').startsWith(planningPrefix);
         const added = [];
         const modified = [];
         const deleted = [];
@@ -2076,6 +2238,8 @@ function cmdVerifyCodebaseDrift(cwd, raw) {
             // ASCII common case — passes through untouched. Both capture groups are
             // decoded: R/C lines carry old AND new paths, either may be quoted.
             const file = decodeGitQuotedPath(m[3] || m[2]);
+            if (isPlanningArtifact(file))
+                continue;
             if (status === 'A' || status === 'R' || status === 'C')
                 added.push(file);
             else if (status === 'M')
@@ -2154,5 +2318,6 @@ module.exports = {
     cmdVerifyCodebaseDrift,
     computeContextDrift,
     cmdVerifyContextDrift,
+    cmdStampCodebaseMap,
     STATE_HEAD_ADVISORY_COMMITS,
 };

package/gsd-core/bin/lib/workstream-inventory.cjs

@@ -733,6 +733,7 @@ module.exports = {
     inspectWorkstream,
     isCompletedInventory: workstream_inventory_builder_cjs_1.isCompletedInventory,
     listWorkstreamInventories,
+    readCurrentMilestoneVersion,
     sortWorkstreamInventories,
     workstreamsRoot,
 };

package/gsd-core/bin/lib/worktree-safety.cjs

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
+const security_cjs_1 = require("./security.cjs");
 // Default timeout for worktree-related git subprocess calls.
 // 10 s is generous enough for normal git operations on large repos while still
 // providing a deterministic failure path when git stalls (locked index, hung
@@ -578,7 +579,7 @@ function normalizeScopePath(raw) {
  */
 function isSummaryArtifactRelPath(relPath) {
     const normalized = normalizeScopePath(relPath);
-    return normalized.startsWith(`${SUMMARY_ARTIFACT_DIR}/`)
+    return normalized.startsWith(`${SUMMARY_ARTIFACT_DIR}/`) // allow-handrolled-containment: artifact-type classification by a fixed known subdirectory name, not a filesystem root-confinement gate
         && normalized.endsWith(SUMMARY_ARTIFACT_SUFFIX);
 }
 /**
@@ -772,7 +773,8 @@ function planWaveScopeConformance(changedPaths, declaredFiles, branch) {
         seen.add(changed);
         if (isSummaryArtifactRelPath(changed))
             continue;
-        const covered = prefixes.some((prefix) => (prefix === null || changed === prefix || changed.startsWith(`${prefix}/`)));
+        const covered = prefixes.some((prefix) => (prefix === null || changed === prefix || changed.startsWith(`${prefix}/`) // allow-handrolled-containment: advisory scope-coverage match against a caller-declared prefix (documented above as deliberately distinct from a security gate) — not a filesystem root-confinement decision
+        ));
         if (covered)
             continue;
         warnings.push({ code: WAVE_CLEANUP_WARNING.SCOPE_OUT_OF_DECLARED, branch, path: changed });
@@ -1581,11 +1583,15 @@ function cmdWorktreeCreate(cwd, args = [], deps = {}) {
     {
         const absRoot = node_path_1.default.resolve(cwd, rootFlag);
         const absWorktree = node_path_1.default.resolve(cwd, plan.entry.worktree_path);
-        const rel = node_path_1.default.relative(absRoot, absWorktree);
-        // rel === ''           → the worktree IS the root (would clobber the checkout)
-        // rel === '..' / '../…' → escapes the root
-        // path.isAbsolute(rel) → a different Windows drive or UNC root
-        if (rel === '' || rel === '..' || rel.startsWith(`..${node_path_1.default.sep}`) || node_path_1.default.isAbsolute(rel)) {
+        // Lexical containment (ADR-4650): the worktree does not exist yet, so there is
+        // nothing to realpath. Both operands are already resolved above, so the shared
+        // `isContainedIn` comparison applies directly (mirrors the already-resolved-caller
+        // exception documented on `isContainedIn`) — a different Windows drive/UNC root
+        // fails the prefix comparison the same way an escaping relative path does.
+        // The canonical predicate treats target === root as CONTAINED; this call site
+        // explicitly REJECTS that case (absWorktree === absRoot below), because a worktree
+        // AT the root would clobber the checkout — the inversion this migration preserves.
+        if (absWorktree === absRoot || !(0, security_cjs_1.isContainedIn)(absWorktree, absRoot)) {
             const hint = `--path must resolve INSIDE --root (root="${absRoot}", path="${absWorktree}"). A worktree outside the declared root is unreachable by manifest-scoped cleanup and would let a spawned executor write outside the project.`;
             writeErr(`[gsd] worktree.create: path_outside_root — ${hint}\n`);
             write(`${JSON.stringify({ ok: false, reason: 'path_outside_root', hint }, null, 2)}\n`);

package/gsd-core/bin/shared/config-defaults.manifest.json

@@ -38,6 +38,7 @@
     "ui_phase": true,
     "ui_safety_gate": true,
     "text_mode": false,
+    "compact_content": false,
     "research_before_questions": false,
     "discuss_mode": "discuss",
     "skip_discuss": false,

package/gsd-core/bin/shared/config-schema.manifest.json

@@ -22,6 +22,7 @@
     "workflow.smart_zone_tokens",
     "workflow.human_verify_mode",
     "workflow.text_mode",
+    "workflow.compact_content",
     "workflow.research_before_questions",
     "workflow.discuss_mode",
     "workflow.skip_discuss",
@@ -75,7 +76,11 @@
     "planner.stall_threshold_minutes",
     "workflow.inline_plan_threshold",
     "hooks.context_warnings",
+    "hooks.context_warning_threshold",
+    "hooks.context_critical_threshold",
     "hooks.workflow_guard",
+    "hooks.commit_types",
+    "hooks.community",
     "workflow.context_coverage_gate",
     "statusline.show_last_command",
     "statusline.context_position",