@opengsd/gsd-core 1.13.0 → 1.14.0

package/gsd-core/bin/lib/external-descriptor-trust.cjs

@@ -18,13 +18,10 @@
  * concern sharing the word "trust".
  */
 'use strict';
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPathConfined = isPathConfined;
 exports.assertDescriptorConfined = assertDescriptorConfined;
-const node_path_1 = __importDefault(require("node:path"));
+const security_cjs_1 = require("./security.cjs");
 /**
  * Pure LEXICAL path-containment check (cross-platform). `target` is confined
  * to `root` iff resolving it relative to `root` (via `path.resolve` — string
@@ -36,20 +33,38 @@ const node_path_1 = __importDefault(require("node:path"));
  * `root`) that would redirect the LEXICALLY-confined path to a physically
  * different, unconfined location on disk. A caller relying on this for a
  * write-confinement guarantee against a symlink-planting attacker must pair
- * it with a symlink check (or refuse to follow symlinks at write time) — see
- * capability-source.cts's install adapters (:491,577,675), which is what
- * currently keeps every caller of this function's callers symlink-safe: they
- * reject symlinks upstream, before a target ever reaches a lexical-only check
- * like this one.
+ * it with a symlink check (or refuse to follow symlinks at write time). Only
+ * the capability-loader.cts route into assertDescriptorConfined gets this for
+ * free today: capability-source.cts's staging path rejects symlinks upstream,
+ * before a target ever reaches a lexical-only check like this one — see
+ * copyDirRecursive's `entry.isSymbolicLink()` throw (capability-source.cts:585-586)
+ * and the post-copy budget-walk re-check (capability-source.cts:671-674). This
+ * does NOT extend to isPathConfined's other callers: install-engine.cts:1608
+ * and install-profiles.cts:755,880 do not go through capability-source.cts's
+ * adapters at all and have no symlink guard of their own here. Of the
+ * remaining callers, only retired-artifact-cleanup.cts:69 carries its own
+ * defense, via a local `lstatSync(destDir).isSymbolicLink()` check at line 77.
+ *
+ * `opts.pathImpl` (default: the ambient `path` module) lets a caller inject
+ * `path.win32` or `path.posix`. This is security-relevant: the win32 branch
+ * (drive letters, UNC paths, `\` separator) is otherwise only reachable by
+ * actually running this process on a Windows host, so without injection a
+ * win32-specific confinement escape would be unverified on every other
+ * platform. This mirrors the platform-injection seam already used elsewhere
+ * in this repo, e.g. src/shell-command-projection.cts's `opts.platform`
+ * (#4641). All existing 2-arg callers are unaffected: the default resolves to
+ * the ambient `path`, preserving byte-identical behaviour.
+ *
+ * The containment DECISION here now comes from the canonical predicate in
+ * src/security.cts (`tryWithinRootLexical`, ADR-4650 decision 6) — this
+ * function keeps only the lexical RESOLUTION policy (no realpath, no
+ * filesystem access) as its own choice; the comparison itself is shared.
  */
-function isPathConfined(target, root) {
+function isPathConfined(target, root, opts = {}) {
     if (typeof target !== 'string' || typeof root !== 'string' || target.length === 0 || root.length === 0) {
         return false;
     }
-    const rootResolved = node_path_1.default.resolve(root);
-    const targetResolved = node_path_1.default.resolve(root, target);
-    const prefix = rootResolved + node_path_1.default.sep;
-    return targetResolved === rootResolved || targetResolved.startsWith(prefix);
+    return (0, security_cjs_1.tryWithinRootLexical)(target, root, { pathImpl: opts.pathImpl }) !== null;
 }
 /**
  * Assert every destSubpath the descriptor declares (global + local artifact

package/gsd-core/bin/lib/gsd2-import.cjs

@@ -307,8 +307,7 @@ function buildStateMd(phaseMap) {
     const currentPhaseNum = currentEntry ? zeroPad(currentEntry.phaseNum) : zeroPad(totalPhases);
     const currentSlug = currentEntry ? slugify(currentEntry.slice.title) : 'complete';
     const status = currentEntry ? 'Ready to plan' : 'All phases complete';
-    const filled = Math.round(pct / 10);
-    const bar = `[${'█'.repeat(filled)}${'░'.repeat(10 - filled)}]`;
+    const bar = `[${(0, phase_lifecycle_cjs_1.renderProgressBar)(pct, 10)}]`;
     const today = clock_cjs_1.realClock.localToday();
     return [
         '# Project State',

package/gsd-core/bin/lib/health-diagnostic-rules/state-consistency.cjs

@@ -158,6 +158,17 @@ const RULE_W002 = {
         const normalizedValid = normalizePhaseTokenSet(validPhases);
         const sortedValid = [...validPhases].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
         const diagnostics = [];
+        // #4257: the valid set above is WORKSTREAM-scoped by construction (every
+        // source field is read from `planningPaths(cwd)`'s base, which resolves
+        // under `.planning/workstreams/<active-ws>/`), and per-workstream phase
+        // numbering is deliberate — so under a workstream the message must NAME
+        // that scope rather than make an unqualified project-wide claim (a
+        // reference to a phase declared only in a SIBLING workstream reads as
+        // "undeclared" against this list; that is the scope speaking, not drift).
+        // Root scope (`workstream === null`, flat or root-planning projects)
+        // keeps the byte-identical message — no clause is appended when none
+        // applies.
+        const scopeClause = snapshot.workstream ? ` in workstream ${snapshot.workstream}` : '';
         for (const ref of snapshot.statePhaseTokens.value) {
             const dotIdx = ref.indexOf('.');
             const head = dotIdx === -1 ? ref : ref.slice(0, dotIdx);
@@ -168,7 +179,7 @@ const RULE_W002 = {
             diagnostics.push({
                 code: 'W002',
                 severity: SEVERITY.WARNING,
-                message: `STATE.md references phase ${ref}, but only phases ${sortedValid.join(', ')} are declared`,
+                message: `STATE.md references phase ${ref}, but only phases ${sortedValid.join(', ')} are declared${scopeClause}`,
                 remedy: adviseRemedy('Review STATE.md manually before changing it; /gsd-health --repair will not overwrite an existing STATE.md for phase mismatches'),
             });
         }

package/gsd-core/bin/lib/health-diagnostic-rules/worktree-health.cjs

@@ -135,7 +135,7 @@ function checkW017(snapshot) {
 function isActiveWorktreePath(activeCwd, worktreePath, platform = process.platform) {
     const active = shellCmdProjection.toComparablePathKey(activeCwd, platform);
     const worktree = shellCmdProjection.toComparablePathKey(worktreePath, platform);
-    return active === worktree || active.startsWith(worktree + '/');
+    return active === worktree || active.startsWith(worktree + '/'); // allow-handrolled-containment: worktree identity matching, not a containment gate
 }
 function checkW027(snapshot) {
     const diagnostics = [];