@pareto4/pp-core 1.13.0 → 1.18.0

package/scripts/sync-manifest-versions.cjs

@@ -11,10 +11,11 @@
  *   - VERSIONED_MANIFESTS — JSON runtime-integration manifests whose top-level
  *     `version` field MUST track the package version.
  *   - VERSIONED_TEXT_FILES — plain-text manifests whose ENTIRE content is the
- *     version followed by one newline.  Root `VERSION` is the repo layout's
- *     version source for `resolveCreatedWith` (src/compose-bindings.cts), so a
- *     repo build stamps `createdWith` from it.  As a plain-text file it could not
- *     join the JSON loop, so nothing kept it in step with package.json.
+ *     version followed by one newline.  Root `VERSION` is the repo layout's only
+ *     version source for `resolveCreatedWithFrom` (src/compose-bindings.cts), so a
+ *     repo build stamps `createdWith` and the practices block from it.  It drifted
+ *     from 1.11.1 through three releases because a plain-text file could not join
+ *     the JSON loop (quick 261003-kmd closed the todo).
  *
  * Usage:
  *   node scripts/sync-manifest-versions.cjs           # stamp + report

package/scripts/sync-rulesets.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-REPO="${REPO:-open-gsd/gsd-core}"
+REPO="${REPO:-pareto000/pp-core}"
 ENFORCEMENT="${ENFORCEMENT:-evaluate}"
 
 case "$ENFORCEMENT" in

package/scripts/update-size-baseline.cjs

@@ -4,309 +4,65 @@
 /**
  * @file update-size-baseline.cjs
  *
- * Regenerates the committed per-file size baselines
- * (`tests/workflow-size-baseline.json`, `tests/agent-size-baseline.json`) from
- * the current files.
+ * Regenerates the committed per-file workflow size baseline
+ * (`tests/workflow-size-baseline.json`) from the current workflow files.
  *
- * Workflow size budget policy (2026-10-11; per commit since pack 9): the guards
- * allow each commit a small DELTA BUDGET (config size_budget.*, see
- * scripts/lib/size-budget.cjs), so plans never run this script. It runs once per
- * phase, in the phase's closing commit (`--reason "phase NN close"`, from
- * execute-phase), and otherwise only when one commit must grow past the budget.
- * Because a raise is the review record of growth, RAISING any entry requires a
- * reason:
+ * Run via `npm run size:baseline` whenever a workflow file legitimately grows
+ * or shrinks.  Growth must still be justified in the PR; this script only
+ * records the new reality so the CI guard (issue #1074) can diff against it.
  *
- *   npm run size:baseline                         # lower / add / remove only
- *   npm run size:baseline -- --reason "<why>"     # also allowed to raise
- *
- * Without `--reason`, a run that would raise any entry is REFUSED: it exits
- * non-zero and writes nothing (neither baseline). With a reason, every raise is
- * recorded in the baseline file's `_rebaselines` array (newest last) as
- * `{ date, reason, deltas: [{ file, from, to, delta }] }` — the committed
- * review record of a deliberate growth.
- *
- * Idempotent: running it twice with no file changes produces no diff (a run
- * with nothing to raise never appends a `_rebaselines` entry).
+ * Idempotent: running it twice with no file changes produces no diff.
  */
 
 const fs = require('fs');
 const path = require('path');
-const { measureMdFiles, measureMdTree, WORKFLOWS_DIR } = require('./workflow-size.cjs');
+const { measureMdFiles, WORKFLOWS_DIR } = require('./workflow-size.cjs');
 
 const BASELINE_PATH = path.join(__dirname, '..', 'tests', 'workflow-size-baseline.json');
 const AGENTS_DIR = path.join(__dirname, '..', 'agents');
 const AGENT_BASELINE_PATH = path.join(__dirname, '..', 'tests', 'agent-size-baseline.json');
-const isPpAgent = (f) => f.startsWith('pp-');
-
-/** Key of the raise log inside a baseline file. Never a measured filename. */
-const REBASELINES_KEY = '_rebaselines';
-
-/**
- * Split a parsed baseline file into its size entries and its raise log.
- * Size entries are the numeric values; metadata keys (`_rebaselines`) are not
- * sizes and must never reach a guard as one.
- *
- * @param {object|null} raw - Parsed baseline JSON (null when absent).
- * @returns {{ sizes: Object<string, number>, rebaselines: Array<object> }}
- */
-function splitBaseline(raw) {
-  const sizes = {};
-  let rebaselines = [];
-  if (raw && typeof raw === 'object') {
-    for (const [key, value] of Object.entries(raw)) {
-      if (key === REBASELINES_KEY) rebaselines = value;
-      else sizes[key] = value;
-    }
-  }
-  return { sizes, rebaselines };
-}
-
-/**
- * Read and parse a baseline file; `null` when it does not exist.
- *
- * @param {string} filePath
- * @returns {object|null}
- */
-function readBaseline(filePath) {
-  let text;
-  try {
-    text = fs.readFileSync(filePath, 'utf-8');
-  } catch (err) {
-    if (err.code === 'ENOENT') return null;
-    throw err;
-  }
-  return JSON.parse(text);
-}
+const isGsdAgent = (f) => f.startsWith('pp-');
 
 /**
- * Serialize to the on-disk baseline format: size keys sorted, then the
- * `_rebaselines` log last; 2-space indent, trailing newline (a stable,
- * minimal-diff artifact).
+ * Serialize a size map to the on-disk baseline format: keys sorted, 2-space
+ * indent, trailing newline (so the file is a stable, minimal-diff artifact).
  *
  * @param {Object<string, number>} sizes
- * @param {Array<object>} [rebaselines]
  * @returns {string}
  */
-function serializeBaseline(sizes, rebaselines = []) {
+function serializeBaseline(sizes) {
   const sorted = {};
   for (const key of Object.keys(sizes).sort()) sorted[key] = sizes[key];
-  sorted[REBASELINES_KEY] = rebaselines;
   return JSON.stringify(sorted, null, 2) + '\n';
 }
 
 /**
- * Classify the difference between an old and a new size map.
- *
- * @param {Object<string, number>} oldSizes
- * @param {Object<string, number>} newSizes
- * @returns {{ raised: Array<{file:string,from:number,to:number,delta:number}>,
- *             lowered: Array<{file:string,from:number,to:number,delta:number}>,
- *             added: string[], removed: string[] }}
- */
-function diffSizes(oldSizes, newSizes) {
-  const raised = [];
-  const lowered = [];
-  const added = [];
-  for (const file of Object.keys(newSizes).sort()) {
-    if (!(file in oldSizes)) {
-      added.push(file);
-      continue;
-    }
-    const from = oldSizes[file];
-    const to = newSizes[file];
-    if (to > from) raised.push({ file, from, to, delta: to - from });
-    else if (to < from) lowered.push({ file, from, to, delta: from - to });
-  }
-  const removed = Object.keys(oldSizes).filter((f) => !(f in newSizes)).sort();
-  return { raised, lowered, added, removed };
-}
-
-/**
- * Validate a `_rebaselines` log. Returns a list of problems (empty = valid).
- * Every entry must carry an ISO date, a non-empty reason and a non-empty list
- * of positive deltas whose arithmetic holds; dates must be non-decreasing
- * (newest last).
- *
- * @param {unknown} log
- * @returns {string[]}
- */
-function validateRebaselineLog(log) {
-  if (!Array.isArray(log)) return [`${REBASELINES_KEY} must be an array, got ${JSON.stringify(log)}`];
-  const problems = [];
-  const isSize = (n) => Number.isInteger(n) && n >= 0;
-  let prevDate = '';
-  log.forEach((entry, i) => {
-    const at = `${REBASELINES_KEY}[${i}]`;
-    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
-      problems.push(`${at} must be an object`);
-      return;
-    }
-    if (typeof entry.date !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(entry.date)) {
-      problems.push(`${at}.date must be YYYY-MM-DD, got ${JSON.stringify(entry.date)}`);
-    } else {
-      if (entry.date < prevDate) problems.push(`${at}.date ${entry.date} is older than the entry before it (newest must be last)`);
-      prevDate = entry.date;
-    }
-    if (typeof entry.reason !== 'string' || entry.reason.trim() === '') {
-      problems.push(`${at}.reason must be a non-empty string`);
-    }
-    if (!Array.isArray(entry.deltas) || entry.deltas.length === 0) {
-      problems.push(`${at}.deltas must be a non-empty array`);
-      return;
-    }
-    entry.deltas.forEach((d, j) => {
-      const dat = `${at}.deltas[${j}]`;
-      if (!d || typeof d.file !== 'string' || d.file === '') problems.push(`${dat}.file must be a non-empty string`);
-      if (!d || !isSize(d.from) || !isSize(d.to)) problems.push(`${dat}.from/.to must be non-negative integers`);
-      else if (!Number.isInteger(d.delta) || d.delta <= 0 || d.delta !== d.to - d.from) {
-        problems.push(`${dat}.delta must be the positive difference to - from (${d.to - d.from}), got ${JSON.stringify(d.delta)}`);
-      }
-    });
-  });
-  return problems;
-}
-
-/**
- * Compute (but do not write) a regenerated baseline.
+ * Write a baseline file from the measured `.md` sizes in a directory.
  *
  * @param {object} [opts]
  * @param {string} [opts.dir]       - Directory to measure (default: workflows).
- * @param {string} [opts.outPath]   - Baseline file (default: workflow baseline).
- * @param {function(string): boolean} [opts.predicate] - File filter.
- * @param {function(string, function): Object<string, number>} [opts.measure] -
- *        Measurer (default: recursive `measureMdTree`; agents pass `measureMdFiles`).
- * @param {string} [opts.reason]    - Justification; required to raise any entry.
- * @param {string} [opts.today]     - Date stamp for a raise (default: today, UTC).
- * @returns {{ outPath: string, refused: boolean, count: number, content: string|null,
- *             change: ReturnType<typeof diffSizes> }}
+ * @param {string} [opts.outPath]   - Baseline file to write (default: workflow).
+ * @param {function(string): boolean} [opts.predicate] - Filename filter.
+ * @returns {{ outPath: string, count: number, content: string }}
  */
-function planBaseline({
-  dir = WORKFLOWS_DIR,
-  outPath = BASELINE_PATH,
-  predicate,
-  measure = measureMdTree,
-  reason,
-  today = new Date().toISOString().slice(0, 10),
-} = {}) {
-  const sizes = measure(dir, predicate);
-  const { sizes: oldSizes, rebaselines: oldLog } = splitBaseline(readBaseline(outPath));
-  const change = diffSizes(oldSizes, sizes);
-  const count = Object.keys(sizes).length;
-  const hasReason = typeof reason === 'string' && reason.trim() !== '';
-  if (change.raised.length > 0 && !hasReason) {
-    return { outPath, refused: true, count, content: null, change };
-  }
-  const log = Array.isArray(oldLog) ? [...oldLog] : [];
-  if (change.raised.length > 0) {
-    log.push({ date: today, reason: reason.trim(), deltas: change.raised });
-  }
-  return { outPath, refused: false, count, content: serializeBaseline(sizes, log), change };
-}
-
-/**
- * Regenerate one baseline file. A refused plan (a raise without a reason)
- * writes nothing.
- *
- * @param {Parameters<typeof planBaseline>[0]} [opts]
- * @returns {ReturnType<typeof planBaseline>}
- */
-function generateBaseline(opts = {}) {
-  const plan = planBaseline(opts);
-  if (!plan.refused) fs.writeFileSync(plan.outPath, plan.content);
-  return plan;
-}
-
-/**
- * Parse CLI arguments: only `--reason <text>` / `--reason=<text>`.
- *
- * @param {string[]} argv
- * @returns {{ reason?: string }}
- */
-function parseArgs(argv) {
-  const out = {};
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === '--reason') {
-      out.reason = argv[++i];
-      if (out.reason === undefined) throw new Error('--reason needs a value');
-    } else if (arg.startsWith('--reason=')) {
-      out.reason = arg.slice('--reason='.length);
-    } else {
-      throw new Error(`unknown argument: ${arg} (only --reason "<text>" is accepted)`);
-    }
-  }
-  if (out.reason !== undefined && out.reason.trim() === '') throw new Error('--reason must not be empty');
-  return out;
+function generateBaseline({ dir = WORKFLOWS_DIR, outPath = BASELINE_PATH, predicate } = {}) {
+  const sizes = measureMdFiles(dir, predicate);
+  const content = serializeBaseline(sizes);
+  fs.writeFileSync(outPath, content);
+  return { outPath, count: Object.keys(sizes).length, content };
 }
 
-const TARGETS = [
-  { label: 'workflow', dir: WORKFLOWS_DIR, outPath: BASELINE_PATH, measure: measureMdTree },
-  { label: 'agent', dir: AGENTS_DIR, outPath: AGENT_BASELINE_PATH, predicate: isPpAgent, measure: measureMdFiles },
-];
-
-/**
- * CLI entry. Plans every target first and writes only when none is refused,
- * so a refusal leaves BOTH baselines untouched.
- *
- * @param {string[]} argv
- * @param {object} [io]
- * @param {Array<object>} [io.targets]
- * @param {string} [io.today]
- * @param {NodeJS.WritableStream} [io.stdout]
- * @param {NodeJS.WritableStream} [io.stderr]
- * @returns {number} exit code
- */
-function main(argv, { targets = TARGETS, today, stdout = process.stdout, stderr = process.stderr } = {}) {
-  let args;
-  try {
-    args = parseArgs(argv);
-  } catch (err) {
-    stderr.write(`size:baseline: ${err.message}\n`);
-    return 2;
-  }
-  const plans = targets.map((t) => ({ t, plan: planBaseline({ ...t, reason: args.reason, today }) }));
-  const refused = plans.filter((p) => p.plan.refused);
-  if (refused.length > 0) {
-    const lines = refused.flatMap(({ t, plan }) =>
-      plan.change.raised.map((r) => `  - ${t.label}: ${r.file}: ${r.from} → ${r.to} (+${r.delta})`)
-    );
-    stderr.write(
-      'size:baseline: REFUSED — this run would RAISE baseline entries, which needs a reason:\n' +
-        `${lines.join('\n')}\n` +
-        'Shrink the file(s), or re-run with: npm run size:baseline -- --reason "<why this growth is needed>"\n' +
-        'Nothing was written.\n'
-    );
-    return 1;
-  }
-  for (const { t, plan } of plans) {
-    fs.writeFileSync(plan.outPath, plan.content);
-    const c = plan.change;
-    stdout.write(
-      `Wrote ${plan.count} ${t.label} sizes to ${path.relative(process.cwd(), plan.outPath)} ` +
-        `(raised ${c.raised.length}, lowered ${c.lowered.length}, added ${c.added.length}, removed ${c.removed.length})\n`
+if (require.main === module) {
+  const targets = [
+    { label: 'workflow', dir: WORKFLOWS_DIR, outPath: BASELINE_PATH },
+    { label: 'agent', dir: AGENTS_DIR, outPath: AGENT_BASELINE_PATH, predicate: isGsdAgent },
+  ];
+  for (const t of targets) {
+    const { outPath, count } = generateBaseline(t);
+    process.stdout.write(
+      `Wrote ${count} ${t.label} sizes to ${path.relative(process.cwd(), outPath)}\n`
     );
   }
-  if (args.reason !== undefined && plans.every((p) => p.plan.change.raised.length === 0)) {
-    stdout.write('Note: nothing was raised, so --reason was not recorded.\n');
-  }
-  return 0;
-}
-
-if (require.main === module) {
-  process.exitCode = main(process.argv.slice(2));
 }
 
-module.exports = {
-  generateBaseline,
-  planBaseline,
-  serializeBaseline,
-  splitBaseline,
-  readBaseline,
-  diffSizes,
-  validateRebaselineLog,
-  parseArgs,
-  main,
-  REBASELINES_KEY,
-  BASELINE_PATH,
-  AGENT_BASELINE_PATH,
-};
+module.exports = { generateBaseline, serializeBaseline, BASELINE_PATH, AGENT_BASELINE_PATH };

package/scripts/verify-opengsd-sweep.cjs

@@ -10,8 +10,9 @@
  *
  * Explicit carve-outs (allowlist — intentional OpenGSD references):
  *   D-07 provenance files: LICENSE, NOTICE, UPSTREAM_SYNC.md
- *   D-06 historical corpus: docs/adr/, docs/proposals/, docs/discussions/,
- *                            docs/issueevidence/, docs/prd/, docs/research/
+ *   D-06 historical corpus: docs/adr/, docs/prd/, docs/research/
+ *                            (docs/proposals, docs/discussions and docs/issueevidence
+ *                            were upstream working notes, removed from the fork)
  *   D-06 notice file:       docs/adr/README.md  (contains the history-notice header)
  *   Migration provenance:   pp-core/bin/lib/installer-migrations/005-*.cjs
  *                            (comment accurately names the upstream source package)
@@ -79,9 +80,6 @@ const PROVENANCE_FILES = new Set([
  */
 const HISTORICAL_CORPUS_DIRS = [
   path.join(ROOT, 'docs', 'adr'),
-  path.join(ROOT, 'docs', 'proposals'),
-  path.join(ROOT, 'docs', 'discussions'),
-  path.join(ROOT, 'docs', 'issueevidence'),
   path.join(ROOT, 'docs', 'prd'),
   path.join(ROOT, 'docs', 'research'),
 ];

package/scripts/workflow-size.cjs

@@ -36,10 +36,8 @@ function lfByteCount(filePath) {
 
 /**
  * List top-level workflow stems (filenames without the `.md` extension), sorted.
- * Top-level only on purpose: a stem is what the tier tables (XL/LARGE/DEFAULT)
- * classify, and only top-level files have a tier. Nested files under
- * `workflows/<name>/{steps,modes,templates}/` are still SIZE-guarded — see
- * `measureMdTree` / `measureWorkflows`, which recurse.
+ * Non-recursive by design: per-mode bodies under `workflows/<name>/modes/` and
+ * templates are NOT measured — only the always-loaded top-level workflows.
  *
  * @param {string} [dir] - Workflows directory (defaults to the canonical one).
  * @returns {string[]} Sorted stems, e.g. `['autonomous', 'plan-phase', ...]`.
@@ -54,10 +52,10 @@ function listWorkflowStems(dir = WORKFLOWS_DIR) {
 
 /**
  * Measure every top-level `.md` file in `dir`, keyed by filename, byte sizes.
- * Generic over directory and an optional filename predicate — used for agents
- * (`agents/pp-*.md`), which are a flat directory, so the agent guard and the
- * baseline generator share one measurement path (#1074).
- * Non-recursive by design; use `measureMdTree` for a nested tree.
+ * Generic over directory and an optional filename predicate — used for both
+ * workflows (`pp-core/workflows/*.md`) and agents (`agents/gsd-*.md`) so the
+ * size guards and the baseline generator share one measurement path (#1074).
+ * Non-recursive by design.
  *
  * @param {string} dir - Directory to scan.
  * @param {function(string): boolean} [predicate] - Filename filter (default: all `.md`).
@@ -74,69 +72,19 @@ function measureMdFiles(dir, predicate = () => true) {
 }
 
 /**
- * List every `.md` file under `dir`, recursively, as POSIX relative paths
- * (`plan-phase.md`, `execute-phase/steps/vault-fetch.md`), sorted.
- *
- * Keys are POSIX on every platform so the committed baseline is identical on a
- * Windows checkout. Top-level files keep their bare filename, exactly as the
- * non-recursive `measureMdFiles` keys them, so existing consumers that look up
- * `baseline['plan-phase.md']` keep working.
- *
- * @param {string} dir - Directory to walk.
- * @param {function(string): boolean} [predicate] - Filter on the POSIX relative path.
- * @returns {string[]} Sorted POSIX relative paths.
- */
-function listMdTree(dir, predicate = () => true) {
-  const out = [];
-  const walk = (abs, rel) => {
-    for (const entry of fs.readdirSync(abs, { withFileTypes: true })) {
-      const childRel = rel ? `${rel}/${entry.name}` : entry.name;
-      const childAbs = path.join(abs, entry.name);
-      if (entry.isDirectory()) walk(childAbs, childRel);
-      else if (entry.isFile() && entry.name.endsWith('.md') && predicate(childRel)) {
-        out.push(childRel);
-      }
-    }
-  };
-  walk(dir, '');
-  return out.sort();
-}
-
-/**
- * Measure every `.md` file under `dir`, recursively, keyed by POSIX relative
- * path (see `listMdTree`), LF byte sizes.
- *
- * @param {string} dir - Directory to walk.
- * @param {function(string): boolean} [predicate] - Filter on the POSIX relative path.
- * @returns {Object<string, number>} Map of relative path → LF byte size, keys sorted.
- */
-function measureMdTree(dir, predicate = () => true) {
-  const out = {};
-  for (const rel of listMdTree(dir, predicate)) {
-    out[rel] = lfByteCount(path.join(dir, ...rel.split('/')));
-  }
-  return out;
-}
-
-/**
- * Measure every workflow `.md` file — top-level AND nested (`steps/`, `modes/`,
- * `templates/`, ...) — keyed by POSIX relative path. Recursive since the
- * workflow size budget policy of 2026-10-11: a nested step file is loaded into
- * context just like its parent, so growth there must be visible too.
+ * Measure every top-level workflow file, keyed by filename (`<stem>.md`).
  *
  * @param {string} [dir] - Workflows directory (defaults to the canonical one).
- * @returns {Object<string, number>} Map of relative path → LF byte size, sorted.
+ * @returns {Object<string, number>} Map of `<stem>.md` → LF byte size, sorted.
  */
 function measureWorkflows(dir = WORKFLOWS_DIR) {
-  return measureMdTree(dir);
+  return measureMdFiles(dir);
 }
 
 module.exports = {
   WORKFLOWS_DIR,
   lfByteCount,
   listWorkflowStems,
-  listMdTree,
   measureMdFiles,
-  measureMdTree,
   measureWorkflows,
 };