codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/personal-sync-service.js

@@ -0,0 +1,232 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var personal_sync_service_exports = {};
+__export(personal_sync_service_exports, {
+  exportSync: () => exportSync,
+  getSyncStatus: () => getSyncStatus,
+  importSync: () => importSync,
+  peekImport: () => peekImport
+});
+module.exports = __toCommonJS(personal_sync_service_exports);
+var _lazy___settings_service = __toESM(require("./settings-service"));
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_os = __toESM(require("node:os"));
+var import_settings_service = require("./settings-service");
+const SYNC_DIR_NAME = "codetrellis-sync";
+function getMachineId() {
+  const crypto = require("node:crypto");
+  return crypto.createHash("sha256").update(`${import_node_os.default.hostname()}:${import_node_os.default.homedir()}`).digest("hex").slice(0, 12);
+}
+function getSyncDir() {
+  const settings = (0, import_settings_service.getSettings)();
+  const syncPath = settings.data.personalSyncPath;
+  if (!syncPath || !syncPath.trim()) return null;
+  return import_node_path.default.join(syncPath, SYNC_DIR_NAME);
+}
+function ensureSyncDir() {
+  const dir = getSyncDir();
+  if (!dir) return null;
+  if (!import_node_fs.default.existsSync(dir)) {
+    try {
+      import_node_fs.default.mkdirSync(dir, { recursive: true });
+    } catch (err) {
+      console.warn("[PersonalSync] Cannot create sync directory:", err);
+      return null;
+    }
+  }
+  return dir;
+}
+function exportSync(recentProjects = []) {
+  const dir = ensureSyncDir();
+  if (!dir) return { exported: false, syncDir: null, error: "No sync path configured" };
+  const settings = (0, import_settings_service.getSettings)();
+  if (settings.data.personalSyncMode === "none") {
+    return { exported: false, syncDir: dir, error: 'Sync mode is "none"' };
+  }
+  try {
+    const settingsSnapshot = { ...settings };
+    const exportSettings = {
+      ...settingsSnapshot,
+      data: {
+        ...settingsSnapshot.data,
+        dataDirOverride: "",
+        // machine-local
+        personalSyncPath: ""
+        // machine-local
+      }
+    };
+    atomicWrite(import_node_path.default.join(dir, "settings.json"), JSON.stringify(exportSettings, null, 2));
+    atomicWrite(import_node_path.default.join(dir, "recent-projects.json"), JSON.stringify(recentProjects, null, 2));
+    const meta = {
+      machineId: getMachineId(),
+      hostname: import_node_os.default.hostname(),
+      lastExportAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    atomicWrite(import_node_path.default.join(dir, ".sync-meta.json"), JSON.stringify(meta, null, 2));
+    return { exported: true, syncDir: dir };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error("[PersonalSync] Export failed:", msg);
+    return { exported: false, syncDir: dir, error: msg };
+  }
+}
+function peekImport() {
+  const dir = getSyncDir();
+  if (!dir || !import_node_fs.default.existsSync(dir)) {
+    return {
+      available: false,
+      syncDir: dir,
+      remoteMachine: null,
+      lastExportAt: null,
+      hasSettings: false,
+      hasRecentProjects: false,
+      recentProjectCount: 0
+    };
+  }
+  const hasSettings = import_node_fs.default.existsSync(import_node_path.default.join(dir, "settings.json"));
+  const hasRecentProjects = import_node_fs.default.existsSync(import_node_path.default.join(dir, "recent-projects.json"));
+  let remoteMachine = null;
+  let lastExportAt = null;
+  let recentProjectCount = 0;
+  try {
+    const metaPath = import_node_path.default.join(dir, ".sync-meta.json");
+    if (import_node_fs.default.existsSync(metaPath)) {
+      const meta = JSON.parse(import_node_fs.default.readFileSync(metaPath, "utf-8"));
+      remoteMachine = meta.hostname || null;
+      lastExportAt = meta.lastExportAt || null;
+    }
+  } catch {
+  }
+  try {
+    if (hasRecentProjects) {
+      const projects = JSON.parse(
+        import_node_fs.default.readFileSync(import_node_path.default.join(dir, "recent-projects.json"), "utf-8")
+      );
+      recentProjectCount = Array.isArray(projects) ? projects.length : 0;
+    }
+  } catch {
+  }
+  return {
+    available: hasSettings || hasRecentProjects,
+    syncDir: dir,
+    remoteMachine,
+    lastExportAt,
+    hasSettings,
+    hasRecentProjects,
+    recentProjectCount
+  };
+}
+function importSync() {
+  const dir = getSyncDir();
+  if (!dir || !import_node_fs.default.existsSync(dir)) {
+    return { imported: false, error: "Sync directory does not exist", settingsImported: false, recentProjects: [] };
+  }
+  let settingsImported = false;
+  const recentProjects = [];
+  try {
+    const settingsPath = import_node_path.default.join(dir, "settings.json");
+    if (import_node_fs.default.existsSync(settingsPath)) {
+      const imported = JSON.parse(import_node_fs.default.readFileSync(settingsPath, "utf-8"));
+      const { updateSettings } = _lazy___settings_service;
+      updateSettings({
+        identity: imported.identity,
+        plans: imported.plans,
+        firstRunComplete: imported.firstRunComplete
+      });
+      settingsImported = true;
+    }
+    const projectsPath = import_node_path.default.join(dir, "recent-projects.json");
+    if (import_node_fs.default.existsSync(projectsPath)) {
+      const projects = JSON.parse(import_node_fs.default.readFileSync(projectsPath, "utf-8"));
+      if (Array.isArray(projects)) {
+        recentProjects.push(...projects);
+      }
+    }
+    return { imported: true, settingsImported, recentProjects };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error("[PersonalSync] Import failed:", msg);
+    return { imported: false, error: msg, settingsImported: false, recentProjects: [] };
+  }
+}
+function getSyncStatus() {
+  const settings = (0, import_settings_service.getSettings)();
+  const syncPath = settings.data.personalSyncPath;
+  const dir = getSyncDir();
+  if (!syncPath || !dir) {
+    return {
+      configured: false,
+      mode: settings.data.personalSyncMode,
+      syncPath: "",
+      syncDirExists: false,
+      lastExportAt: null,
+      lastImportAvailable: false,
+      remoteMachine: null
+    };
+  }
+  const syncDirExists = import_node_fs.default.existsSync(dir);
+  let lastExportAt = null;
+  let remoteMachine = null;
+  let lastImportAvailable = false;
+  if (syncDirExists) {
+    try {
+      const metaPath = import_node_path.default.join(dir, ".sync-meta.json");
+      if (import_node_fs.default.existsSync(metaPath)) {
+        const meta = JSON.parse(import_node_fs.default.readFileSync(metaPath, "utf-8"));
+        lastExportAt = meta.lastExportAt;
+        if (meta.machineId !== getMachineId()) {
+          remoteMachine = meta.hostname;
+          lastImportAvailable = true;
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    configured: true,
+    mode: settings.data.personalSyncMode,
+    syncPath,
+    syncDirExists,
+    lastExportAt,
+    lastImportAvailable,
+    remoteMachine
+  };
+}
+function atomicWrite(filePath, content) {
+  const tmpPath = `${filePath}.tmp`;
+  import_node_fs.default.writeFileSync(tmpPath, content);
+  import_node_fs.default.renameSync(tmpPath, filePath);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportSync,
+  getSyncStatus,
+  importSync,
+  peekImport
+});

package/src/backend/services/pipeline-approvals.js

@@ -0,0 +1,72 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pipeline_approvals_exports = {};
+__export(pipeline_approvals_exports, {
+  approvePipeline: () => approvePipeline,
+  pipelineView: () => pipelineView
+});
+module.exports = __toCommonJS(pipeline_approvals_exports);
+var import_node_child_process = require("node:child_process");
+var import_rule_approvals = require("./rule-approvals");
+var import_pipeline = require("./pipeline");
+function headOf(projectRoot) {
+  try {
+    return (0, import_node_child_process.execFileSync)("git", ["-C", projectRoot, "rev-parse", "--verify", "--quiet", "HEAD^{commit}"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function pendingChanges(projectRoot) {
+  const head = headOf(projectRoot);
+  if (!head) return [];
+  const was = await (0, import_pipeline.pipelineAt)(projectRoot, head);
+  const now = (0, import_pipeline.readPipeline)(projectRoot);
+  const loosens = (0, import_pipeline.diffPipeline)(was?.pipeline ?? null, now?.pipeline ?? null).filter((c) => c.effect === "loosens");
+  if (!loosens.length) return [];
+  const approvals = (0, import_rule_approvals.approvalsHere)(projectRoot);
+  const keys = (0, import_rule_approvals.keysAt)(projectRoot, head);
+  try {
+    return loosens.filter((c) => (0, import_rule_approvals.approvalFor)(projectRoot, c, approvals, keys, head) === null);
+  } finally {
+    keys.done();
+  }
+}
+async function pipelineView(projectRoot) {
+  const got = (0, import_pipeline.readPipeline)(projectRoot);
+  const pending = await pendingChanges(projectRoot);
+  return {
+    where: import_pipeline.PIPELINE_FILE,
+    pipeline: got?.pipeline ?? null,
+    problems: got?.problems ?? [],
+    words: got?.pipeline?.stages.map(import_pipeline.stageWords) ?? [],
+    pending: pending.map((c) => ({ stage: c.rule.slice("pipeline.".length), words: c.words }))
+  };
+}
+async function approvePipeline(projectRoot, me) {
+  const signed = [];
+  for (const c of await pendingChanges(projectRoot)) {
+    const s = (0, import_rule_approvals.signRuleChange)(projectRoot, { rule: c.rule, before: c.before, after: c.after }, me);
+    signed.push({ stage: c.rule.slice("pipeline.".length), file: s.file, how: s.how });
+  }
+  return { signed, view: await pipelineView(projectRoot) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  approvePipeline,
+  pipelineView
+});

package/src/backend/services/pipeline.js

@@ -0,0 +1,232 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pipeline_exports = {};
+__export(pipeline_exports, {
+  PIPELINE_FILE: () => PIPELINE_FILE,
+  diffPipeline: () => diffPipeline,
+  parsePipeline: () => parsePipeline,
+  pipelineAt: () => pipelineAt,
+  readPipeline: () => readPipeline,
+  stageRule: () => stageRule,
+  stageScope: () => stageScope,
+  stageWords: () => stageWords,
+  waves: () => waves
+});
+module.exports = __toCommonJS(pipeline_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_yaml = require("yaml");
+var import_architecture_rules = require("../../shared/types/architecture-rules");
+var import_confined_fs = require("./confined-fs");
+var import_git_env = require("./git-env");
+var import_rule_changes = require("./rule-changes");
+const PIPELINE_FILE = ".codetrellis/pipeline.yaml";
+const ID_RE = /^[a-z0-9][a-z0-9-]{0,62}$/;
+const MAX_STAGES = 20;
+const MAX_BYTES = 64 * 1024;
+const SELECTORS = ["suite", "engine", "strength", "id", "tag"];
+const list = (v) => v === void 0 ? [] : typeof v === "string" ? [v] : Array.isArray(v) && v.every((x) => typeof x === "string") ? v.map((x) => x.trim()).filter(Boolean) : null;
+function parsePipeline(text) {
+  if (Buffer.byteLength(text, "utf8") > MAX_BYTES) return { pipeline: null, problems: [`${PIPELINE_FILE} is larger than a pipeline can be`] };
+  const doc = (0, import_yaml.parseDocument)(text);
+  if (doc.errors.length) return { pipeline: null, problems: [`${PIPELINE_FILE} is not YAML: ${doc.errors[0].message.split("\n")[0]}`] };
+  let raw;
+  try {
+    raw = doc.toJS({ maxAliasCount: 0 });
+  } catch {
+    return { pipeline: null, problems: [`${PIPELINE_FILE} may not use YAML aliases`] };
+  }
+  const items = raw && typeof raw === "object" && !Array.isArray(raw) ? raw.stages : null;
+  if (!Array.isArray(items) || items.length === 0) return { pipeline: null, problems: [`${PIPELINE_FILE} holds stages: a list of at least one`] };
+  if (items.length > MAX_STAGES) return { pipeline: null, problems: [`a pipeline has at most ${MAX_STAGES} stages`] };
+  const problems = [];
+  const stages = [];
+  const before = [];
+  let wave = [];
+  for (const [i, item] of items.entries()) {
+    const r = item && typeof item === "object" ? item : {};
+    const why = [];
+    const id = typeof r.id === "string" && ID_RE.test(r.id) ? r.id : null;
+    if (!id) why.push("id must be a short slug, like fast");
+    else if (stages.some((s) => s.id === id)) why.push(`${id} is already a stage`);
+    const rules = {};
+    if (r.rules !== void 0 && r.rules !== "all") {
+      if (!r.rules || typeof r.rules !== "object" || Array.isArray(r.rules)) why.push("rules selects by suite, engine, strength, id or tag, like { engine: deterministic }, or is all");
+      else {
+        for (const [k, v] of Object.entries(r.rules)) {
+          const values = list(v);
+          if (!SELECTORS.includes(k)) {
+            why.push(`rules selects by suite, engine, strength, id or tag, not ${k}`);
+            continue;
+          }
+          if (!values || values.length === 0) {
+            why.push(`rules.${k} is a name or a list of them`);
+            continue;
+          }
+          if (k === "engine" && values.some((x) => !import_architecture_rules.RULE_ENGINES.includes(x))) why.push("rules.engine is deterministic, fuzzy or agent");
+          if (k === "strength" && values.some((x) => !import_architecture_rules.RULE_STRENGTHS.includes(x))) why.push("rules.strength is block, warn or guide");
+          rules[k] = values;
+        }
+      }
+    }
+    const parallel = r.parallel === true;
+    if (r.parallel !== void 0 && typeof r.parallel !== "boolean") why.push("parallel is true or false");
+    if (parallel && i === 0) why.push("the first stage has no stage to run beside");
+    const earlier = parallel ? before : [...before, ...wave];
+    const refs = (name, v) => {
+      const xs = list(v);
+      if (xs === null) {
+        why.push(`${name} is a list of stages`);
+        return null;
+      }
+      for (const x of xs) if (!earlier.includes(x)) why.push(`${name} names ${x}, which is not a stage that finishes before this one`);
+      return xs;
+    };
+    const needs = refs("needs", r.needs);
+    const grounding = refs("grounding", r.grounding);
+    let when;
+    if (r.when !== void 0) {
+      if (!r.when || typeof r.when !== "object" || Array.isArray(r.when)) why.push("when says which stages must have passed or failed, like { fast: passed }");
+      else {
+        when = {};
+        for (const [k, v] of Object.entries(r.when)) {
+          if (v !== "passed" && v !== "failed") {
+            why.push(`when.${k} is passed or failed`);
+            continue;
+          }
+          if (!earlier.includes(k)) {
+            why.push(`when names ${k}, which is not a stage that finishes before this one`);
+            continue;
+          }
+          when[k] = v;
+        }
+      }
+    }
+    if (r.advisory !== void 0 && typeof r.advisory !== "boolean") why.push("advisory is true or false");
+    if (why.length) {
+      problems.push(`stage ${id ?? i + 1}: ${why.join("; ")}`);
+      continue;
+    }
+    if (!parallel) {
+      before.push(...wave);
+      wave = [];
+    }
+    wave.push(id);
+    stages.push({
+      id,
+      rules,
+      ...parallel ? { parallel: true } : {},
+      ...needs && needs.length ? { needs } : {},
+      ...when && Object.keys(when).length ? { when } : {},
+      ...grounding && grounding.length ? { grounding } : {},
+      ...r.advisory === true ? { advisory: true } : {}
+    });
+  }
+  return problems.length ? { pipeline: null, problems } : { pipeline: { stages }, problems: [] };
+}
+function readPipeline(projectRoot) {
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(projectRoot, PIPELINE_FILE))) return null;
+  try {
+    return parsePipeline((0, import_confined_fs.readTextWithin)(projectRoot, PIPELINE_FILE, "pipeline"));
+  } catch (err) {
+    return { pipeline: null, problems: [`${PIPELINE_FILE} could not be read: ${err.message}`] };
+  }
+}
+async function pipelineAt(projectRoot, commit) {
+  if (!/^[0-9a-f]{40}$/.test(commit)) return null;
+  try {
+    const text = await (0, import_git_env.gitAsync)(projectRoot, ["show", `${commit}:./${PIPELINE_FILE}`]);
+    return parsePipeline(String(text));
+  } catch {
+    return null;
+  }
+}
+function stageScope(s) {
+  return {
+    ...s.rules.suite ? { suite: s.rules.suite.join(",") } : {},
+    ...s.rules.id ? { rule: s.rules.id.join(",") } : {},
+    ...s.rules.engine ? { engine: s.rules.engine.join(",") } : {},
+    ...s.rules.strength ? { strength: s.rules.strength.join(",") } : {},
+    ...s.rules.tag ? { tag: s.rules.tag.join(",") } : {}
+  };
+}
+function waves(p) {
+  const out = [];
+  for (const s of p.stages) {
+    if (s.parallel && out.length) out[out.length - 1].push(s);
+    else out.push([s]);
+  }
+  return out;
+}
+function stageWords(s) {
+  const and = (xs) => xs.length < 2 ? xs.join("") : `${xs.slice(0, -1).join(", ")} and ${xs[xs.length - 1]}`;
+  const sel = [];
+  if (s.rules.engine) sel.push(`${and(s.rules.engine)}`);
+  if (s.rules.strength) sel.push(`${and(s.rules.strength)}-strength`);
+  const what = `${sel.length ? `${sel.join(" ")} ` : ""}rules${s.rules.tag ? ` tagged ${s.rules.tag.join(" or ")}` : ""}${s.rules.suite ? ` in ${and(s.rules.suite)}` : ""}${s.rules.id ? ` ${and(s.rules.id)}` : ""}`;
+  const parts = [s.rules.engine || s.rules.strength || s.rules.suite || s.rules.id || s.rules.tag ? what : "every rule"];
+  if (s.parallel) parts.push("beside the stage before");
+  if (s.needs) parts.push(`after ${and(s.needs)}`);
+  if (s.when) parts.push(`when ${and(Object.entries(s.when).map(([k, v]) => `${k} ${v}`))}`);
+  if (s.grounding) parts.push(`grounded by ${and(s.grounding)}`);
+  return `${s.id}: ${parts.join(", ")}${s.advisory ? " (advisory)" : ""}`;
+}
+const sorted = (xs) => [...xs ?? []].sort();
+function stageRule(s) {
+  const terms = {
+    rules: Object.fromEntries(Object.entries(s.rules).sort().map(([k, v]) => [k, sorted(v)])),
+    needs: sorted(s.needs),
+    grounding: sorted(s.grounding),
+    when: Object.fromEntries(Object.entries(s.when ?? {}).sort())
+  };
+  return { id: `pipeline.${s.id}`, from: "pipeline", mayNotImport: JSON.stringify(terms), except: [], because: "", since: "", by: "", strength: s.advisory ? "warn" : "block" };
+}
+function diffPipeline(base, head) {
+  const b = new Map((base?.stages ?? []).map((s) => [s.id, s]));
+  const h = new Map((head?.stages ?? []).map((s) => [s.id, s]));
+  return (0, import_rule_changes.diffRules)([...b.values()].map(stageRule), [...h.values()].map(stageRule), []).map((c) => {
+    const id = c.rule.slice("pipeline.".length);
+    const was = b.get(id);
+    const now = h.get(id);
+    const said = (s) => s ? `\u201C${stageWords(s)}\u201D` : "";
+    const words = c.change === "removed" ? `\u2717 This change removes the stage ${id} from the pipeline (${said(was)}).${import_rule_changes.NEEDS}` : c.change === "added" ? `\u26A0 This change adds the stage ${id} to the pipeline (${said(now)}). It runs once it is on the base branch.` : c.effect === "loosens" ? `\u2717 This change loosens the pipeline's stage ${id}, from ${said(was)} to ${said(now)}.${import_rule_changes.NEEDS}` : `\u26A0 This change tightens the pipeline's stage ${id}, from ${said(was)} to ${said(now)}.`;
+    return { ...c, words };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PIPELINE_FILE,
+  diffPipeline,
+  parsePipeline,
+  pipelineAt,
+  readPipeline,
+  stageRule,
+  stageScope,
+  stageWords,
+  waves
+});

package/src/backend/services/plan-arrivals.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_arrivals_exports = {};
+__export(plan_arrivals_exports, {
+  allPlanArrivals: () => allPlanArrivals,
+  arrivalWords: () => arrivalWords,
+  completePlanArrival: () => completePlanArrival,
+  getPlanArrival: () => getPlanArrival,
+  recordPlanArrival: () => recordPlanArrival
+});
+module.exports = __toCommonJS(plan_arrivals_exports);
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_skill_arrival_service = require("./skill-arrival-service");
+function recordPlanArrival(planUid, planFile, now = Date.now()) {
+  const { addedBy, commit } = (0, import_skill_arrival_service.lastCommitOf)(planFile);
+  (0, import_database.getDb)().run(
+    `INSERT OR IGNORE INTO plan_arrivals (plan_uid, added_by, commit_sha, arrived_at) VALUES (?, ?, ?, ?)`,
+    [planUid, addedBy, commit, now]
+  );
+  (0, import_persistence.markDirty)();
+  return getPlanArrival(planUid) ?? { addedBy, commit, arrivedAt: now };
+}
+function completePlanArrival(planUid, planFile) {
+  const known = getPlanArrival(planUid);
+  if (!known || known.commit) return;
+  const { addedBy, commit } = (0, import_skill_arrival_service.lastCommitOf)(planFile);
+  if (!commit) return;
+  (0, import_database.getDb)().run(`UPDATE plan_arrivals SET added_by = ?, commit_sha = ? WHERE plan_uid = ? AND commit_sha IS NULL`, [addedBy, commit, planUid]);
+  (0, import_persistence.markDirty)();
+}
+function getPlanArrival(planUid) {
+  const r = (0, import_database.getDb)().exec(`SELECT added_by, commit_sha, arrived_at FROM plan_arrivals WHERE plan_uid = ?`, [planUid])[0]?.values[0];
+  return r ? { addedBy: r[0] ?? null, commit: r[1] ?? null, arrivedAt: r[2] } : null;
+}
+function allPlanArrivals() {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of (0, import_database.getDb)().exec(`SELECT plan_uid, added_by, commit_sha, arrived_at FROM plan_arrivals`)[0]?.values ?? []) {
+    out.set(r[0], { addedBy: r[1] ?? null, commit: r[2] ?? null, arrivedAt: r[3] });
+  }
+  return out;
+}
+function arrivalWords(a) {
+  return a.addedBy && a.commit ? `from ${a.addedBy}, in ${a.commit}` : "arrived in its files, not committed yet";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allPlanArrivals,
+  arrivalWords,
+  completePlanArrival,
+  getPlanArrival,
+  recordPlanArrival
+});