@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.2

package/dist/chunk-MVZVGYXH.js

@@ -0,0 +1,1611 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  changeStore
+} from "./chunk-XY3P7JW7.js";
+import {
+  ManualNotifier,
+  fileStepStore
+} from "./chunk-7JUKDRSZ.js";
+import {
+  readCatalog
+} from "./chunk-27NKUS3X.js";
+import {
+  readServiceRequestExports
+} from "./chunk-23W7VWKR.js";
+import {
+  Initiative,
+  IsoDate,
+  IsoDateTime,
+  LIFECYCLE_STATES,
+  RecordId,
+  catalogDirOf,
+  external_exports,
+  loadOrgPack,
+  orgPackDirOf,
+  parseRecord,
+  recordPath,
+  require_dist,
+  serializeRecord,
+  stateDirOf,
+  toCanonicalYaml
+} from "./chunk-S2A7YC3Q.js";
+import {
+  SCHEMA_VERSION
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/initiatives/dist/journeys.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+var JOURNEYS = Initiative.shape.journey.options;
+var PartyRole = external_exports.union([
+  external_exports.enum([
+    /** The vendor party whose systems include the target. */
+    "vendor",
+    /** The party whose systems include the target (vendor or internal). */
+    "target-owner",
+    /** The party of each system that calls the target (one item per caller). */
+    "caller-owners",
+    /** The party of each system the target calls. */
+    "callee-owners",
+    /** The platform team's party. */
+    "platform",
+    /** For a request: the party that approves the request type (template `approvers`). */
+    "approver"
+  ]),
+  external_exports.string().regex(/^party:[a-z0-9][a-z0-9._-]*$/, "a role or party:<id>")
+]);
+var JourneyStep = external_exports.strictObject({
+  id: RecordId,
+  /** What has to happen; {initiative}, {target}, {targetName}, {system} and {systemName} are filled in. */
+  what: external_exports.string().min(1),
+  kind: external_exports.enum(["change", "commitment", "request", "task"]),
+  /** For commitments and requests: who it is with. */
+  party: PartyRole.optional(),
+  /** Key in the party's typicalLeadTimes (commitments; requests use the template id). */
+  leadTimeKey: external_exports.string().min(1).optional(),
+  /** For requests: the service-desk request template (org-pack/process/snow/<id>.yaml). */
+  template: RecordId.optional(),
+  /** One item, or one per caller, callee, the target, or the systems named for the initiative. */
+  per: external_exports.enum(["once", "callers", "callees", "target", "systems"]).default("once"),
+  /** For change steps: the state the change must reach. */
+  milestone: external_exports.enum(["design", "build", "release-ready", "released"]).optional(),
+  /** For change steps: the change type the change is created with. */
+  changeType: RecordId.default("feature"),
+  /** For tasks: the role that does it. */
+  owner: RecordId.optional(),
+  /** Working days the step takes when nothing better is known. */
+  days: external_exports.number().int().min(0).default(5),
+  /** Steps that must finish first. */
+  after: external_exports.array(RecordId).default([])
+});
+var JourneyTemplate = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  id: Initiative.shape.journey,
+  name: external_exports.string().min(1),
+  /** The outcome an initiative of this kind is for, in one sentence. */
+  outcome: external_exports.string().min(1),
+  phases: external_exports.array(external_exports.strictObject({
+    id: RecordId,
+    name: external_exports.string().min(1),
+    steps: external_exports.array(JourneyStep).min(1)
+  })).min(1)
+}).superRefine((t, ctx) => {
+  const steps = t.phases.flatMap((p) => p.steps);
+  const ids = /* @__PURE__ */ new Set();
+  for (const s of steps) {
+    if (ids.has(s.id))
+      ctx.addIssue({ code: "custom", path: ["phases"], message: `step ${s.id} appears twice` });
+    ids.add(s.id);
+    if (s.kind === "change" && !s.milestone)
+      ctx.addIssue({
+        code: "custom",
+        path: ["phases"],
+        message: `change step ${s.id} needs a milestone`
+      });
+    if (s.kind === "request" && !s.template)
+      ctx.addIssue({
+        code: "custom",
+        path: ["phases"],
+        message: `request step ${s.id} needs a template`
+      });
+    if ((s.kind === "commitment" || s.kind === "request") && !s.party)
+      ctx.addIssue({ code: "custom", path: ["phases"], message: `step ${s.id} needs a party` });
+  }
+  for (const s of steps)
+    for (const a of s.after)
+      if (!ids.has(a))
+        ctx.addIssue({
+          code: "custom",
+          path: ["phases"],
+          message: `step ${s.id} comes after ${a}, which doesn't exist`
+        });
+  const state = /* @__PURE__ */ new Map();
+  const byId = new Map(steps.map((s) => [s.id, s]));
+  const visit = (id) => {
+    if (state.get(id) === 1)
+      return false;
+    if (state.get(id) === 2)
+      return true;
+    state.set(id, 1);
+    for (const a of byId.get(id)?.after ?? [])
+      if (!visit(a))
+        return false;
+    state.set(id, 2);
+    return true;
+  };
+  for (const s of steps)
+    if (!visit(s.id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["phases"],
+        message: `the steps go round in a circle at ${s.id}`
+      });
+      break;
+    }
+});
+var BUILT_IN = [
+  {
+    schemaVersion: 1,
+    id: "new-feature",
+    name: "New feature",
+    outcome: "Ship a new capability in one system, with the other teams it depends on lined up in time.",
+    phases: [
+      {
+        id: "define",
+        name: "Define",
+        steps: [
+          {
+            id: "brief",
+            what: "Write and agree the brief for {targetName}",
+            kind: "task",
+            owner: "product-owner",
+            days: 5
+          },
+          {
+            id: "interfaces-confirmed",
+            what: "{systemName} confirms the interfaces {targetName} will use",
+            kind: "commitment",
+            party: "callee-owners",
+            per: "callees",
+            leadTimeKey: "system-card",
+            days: 5,
+            after: ["brief"]
+          }
+        ]
+      },
+      {
+        id: "design",
+        name: "Design",
+        steps: [
+          {
+            id: "design",
+            what: "Design approved for {targetName}",
+            kind: "change",
+            per: "target",
+            milestone: "design",
+            days: 5,
+            after: ["brief"]
+          }
+        ]
+      },
+      {
+        id: "build",
+        name: "Build",
+        steps: [
+          {
+            id: "build",
+            what: "{targetName} built and tested",
+            kind: "change",
+            per: "target",
+            milestone: "build",
+            days: 10,
+            after: ["design", "interfaces-confirmed"]
+          }
+        ]
+      },
+      {
+        id: "release",
+        name: "Release",
+        steps: [
+          { id: "qa", what: "QA sign-off", kind: "task", owner: "qa", days: 5, after: ["build"] },
+          {
+            id: "release",
+            what: "Go/no-go and release",
+            kind: "task",
+            owner: "delivery-lead",
+            days: 2,
+            after: ["qa"]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    schemaVersion: 1,
+    id: "new-integration",
+    name: "New integration",
+    outcome: "Connect the named systems to a new partner or internal system, with access, network and gateway ready in time.",
+    phases: [
+      {
+        id: "discover",
+        name: "Discover",
+        steps: [
+          {
+            id: "partner-spec",
+            what: "{targetName} shares its API spec",
+            kind: "commitment",
+            party: "target-owner",
+            leadTimeKey: "api-spec",
+            days: 10
+          },
+          {
+            id: "access",
+            what: "{targetName} grants test credentials and sandbox access",
+            kind: "commitment",
+            party: "target-owner",
+            leadTimeKey: "sandbox-access",
+            days: 10
+          }
+        ]
+      },
+      {
+        id: "design",
+        name: "Design",
+        steps: [
+          {
+            id: "design",
+            what: "Design approved for the {targetName} integration in {systemName}",
+            kind: "change",
+            per: "systems",
+            milestone: "design",
+            days: 5,
+            after: ["partner-spec"]
+          }
+        ]
+      },
+      {
+        id: "build",
+        name: "Build",
+        steps: [
+          {
+            id: "gateway-route",
+            what: "Gateway proxy for {targetName}",
+            kind: "request",
+            template: "gateway-route",
+            party: "approver",
+            days: 5,
+            after: ["design"]
+          },
+          {
+            id: "firewall-rule",
+            what: "Firewall rule to {targetName}",
+            kind: "request",
+            template: "firewall-rule",
+            party: "approver",
+            days: 10,
+            after: ["design"]
+          },
+          {
+            id: "build",
+            what: "{systemName} built against {targetName}",
+            kind: "change",
+            per: "systems",
+            milestone: "build",
+            days: 10,
+            after: ["design"]
+          }
+        ]
+      },
+      {
+        id: "test",
+        name: "Test",
+        steps: [
+          {
+            id: "integration-test",
+            what: "Joint integration test with {targetName}",
+            kind: "commitment",
+            party: "target-owner",
+            leadTimeKey: "integration-test",
+            days: 5,
+            after: ["build", "access", "gateway-route", "firewall-rule"]
+          }
+        ]
+      },
+      {
+        id: "release",
+        name: "Release",
+        steps: [
+          {
+            id: "release",
+            what: "Go/no-go and release",
+            kind: "task",
+            owner: "delivery-lead",
+            days: 2,
+            after: ["integration-test"]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    schemaVersion: 1,
+    id: "vendor-api-change",
+    name: "Vendor API change",
+    outcome: "Move every caller to a vendor's new API version before the old one is switched off.",
+    phases: [
+      {
+        id: "discover",
+        name: "Discover",
+        steps: [
+          {
+            id: "vendor-spec",
+            what: "{targetName} publishes the new API spec and changelog",
+            kind: "commitment",
+            party: "vendor",
+            leadTimeKey: "api-spec",
+            days: 10
+          },
+          {
+            id: "vendor-sandbox",
+            what: "{targetName} gives sandbox access to the new API",
+            kind: "commitment",
+            party: "vendor",
+            leadTimeKey: "sandbox-access",
+            days: 10
+          }
+        ]
+      },
+      {
+        id: "design",
+        name: "Design",
+        steps: [
+          {
+            id: "impact",
+            what: "Impact of the new {targetName} API on every caller",
+            kind: "task",
+            owner: "architect",
+            days: 3,
+            after: ["vendor-spec"]
+          },
+          {
+            id: "design",
+            what: "Design approved for moving {systemName} to the new {targetName} API",
+            kind: "change",
+            per: "callers",
+            milestone: "design",
+            days: 5,
+            after: ["impact"]
+          }
+        ]
+      },
+      {
+        id: "build",
+        name: "Build",
+        steps: [
+          {
+            id: "gateway-route",
+            what: "Gateway proxy for the new {targetName} API",
+            kind: "request",
+            template: "gateway-route",
+            party: "approver",
+            days: 5,
+            after: ["design"]
+          },
+          {
+            id: "firewall-rule",
+            what: "Firewall rule to the new {targetName} host",
+            kind: "request",
+            template: "firewall-rule",
+            party: "approver",
+            days: 10,
+            after: ["design"]
+          },
+          {
+            id: "build",
+            what: "{systemName} moved to the new {targetName} API",
+            kind: "change",
+            per: "callers",
+            milestone: "build",
+            days: 10,
+            after: ["design"]
+          }
+        ]
+      },
+      {
+        id: "test",
+        name: "Test",
+        steps: [
+          {
+            id: "vendor-certification",
+            what: "{targetName} certifies the integration in its sandbox",
+            kind: "commitment",
+            party: "vendor",
+            leadTimeKey: "certification",
+            days: 10,
+            after: ["build", "vendor-sandbox", "gateway-route", "firewall-rule"]
+          }
+        ]
+      },
+      {
+        id: "release",
+        name: "Release",
+        steps: [
+          {
+            id: "release",
+            what: "Go/no-go and release",
+            kind: "task",
+            owner: "delivery-lead",
+            days: 2,
+            after: ["vendor-certification"]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    schemaVersion: 1,
+    id: "design-change",
+    name: "Design change",
+    outcome: "Change how one system works and bring every caller along.",
+    phases: [
+      {
+        id: "design",
+        name: "Design",
+        steps: [
+          {
+            id: "design",
+            what: "Design approved for {targetName}",
+            kind: "change",
+            per: "target",
+            milestone: "design",
+            days: 5
+          },
+          {
+            id: "caller-impact",
+            what: "{systemName} confirms the impact of the {targetName} change",
+            kind: "commitment",
+            party: "caller-owners",
+            per: "callers",
+            leadTimeKey: "system-card",
+            days: 5,
+            after: ["design"]
+          }
+        ]
+      },
+      {
+        id: "build",
+        name: "Build",
+        steps: [
+          {
+            id: "build-target",
+            what: "{targetName} built",
+            kind: "change",
+            per: "target",
+            milestone: "build",
+            days: 10,
+            after: ["design"]
+          },
+          {
+            id: "build-callers",
+            what: "{systemName} updated for the {targetName} change",
+            kind: "change",
+            per: "callers",
+            milestone: "build",
+            days: 10,
+            after: ["caller-impact"]
+          }
+        ]
+      },
+      {
+        id: "release",
+        name: "Release",
+        steps: [
+          {
+            id: "release",
+            what: "Go/no-go and release",
+            kind: "task",
+            owner: "delivery-lead",
+            days: 2,
+            after: ["build-target", "build-callers"]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    schemaVersion: 1,
+    id: "migration",
+    name: "Migration",
+    outcome: "Move a system to a new platform without breaking its callers.",
+    phases: [
+      {
+        id: "prepare",
+        name: "Prepare",
+        steps: [
+          {
+            id: "inventory",
+            what: "Inventory of {targetName}'s interfaces, data and settings",
+            kind: "task",
+            owner: "architect",
+            days: 5
+          },
+          {
+            id: "platform-ready",
+            what: "The target platform is ready for {targetName}",
+            kind: "commitment",
+            party: "platform",
+            leadTimeKey: "platform-ready",
+            days: 15
+          }
+        ]
+      },
+      {
+        id: "design",
+        name: "Design",
+        steps: [
+          {
+            id: "design",
+            what: "Migration design approved for {targetName}",
+            kind: "change",
+            per: "target",
+            milestone: "design",
+            days: 5,
+            after: ["inventory"]
+          }
+        ]
+      },
+      {
+        id: "build",
+        name: "Build",
+        steps: [
+          {
+            id: "firewall-rule",
+            what: "Firewall rules for {targetName} on the new platform",
+            kind: "request",
+            template: "firewall-rule",
+            party: "approver",
+            days: 10,
+            after: ["design"]
+          },
+          {
+            id: "build",
+            what: "{targetName} running on the new platform",
+            kind: "change",
+            per: "target",
+            milestone: "build",
+            days: 15,
+            after: ["design"]
+          },
+          {
+            id: "cutover-agreed",
+            what: "{systemName} agrees the cutover window",
+            kind: "commitment",
+            party: "caller-owners",
+            per: "callers",
+            leadTimeKey: "cutover",
+            days: 5,
+            after: ["build"]
+          }
+        ]
+      },
+      {
+        id: "release",
+        name: "Cutover",
+        steps: [
+          {
+            id: "release",
+            what: "Cutover",
+            kind: "task",
+            owner: "delivery-lead",
+            days: 2,
+            after: ["platform-ready", "firewall-rule", "cutover-agreed"]
+          }
+        ]
+      }
+    ]
+  },
+  {
+    schemaVersion: 1,
+    id: "retire-system",
+    name: "Retire a system",
+    outcome: "Switch a system off after every caller has moved off it and its data is dealt with.",
+    phases: [
+      {
+        id: "notify",
+        name: "Notify",
+        steps: [
+          {
+            id: "callers-notified",
+            what: "{systemName} agrees to move off {targetName}",
+            kind: "commitment",
+            party: "caller-owners",
+            per: "callers",
+            leadTimeKey: "retire",
+            days: 20
+          },
+          {
+            id: "design",
+            what: "Retirement design approved for {targetName}",
+            kind: "change",
+            per: "target",
+            milestone: "design",
+            days: 5
+          }
+        ]
+      },
+      {
+        id: "move",
+        name: "Move callers",
+        steps: [
+          {
+            id: "caller-changes",
+            what: "{systemName} no longer calls {targetName}",
+            kind: "change",
+            per: "callers",
+            milestone: "released",
+            days: 10,
+            after: ["design", "callers-notified"]
+          }
+        ]
+      },
+      {
+        id: "data",
+        name: "Data",
+        steps: [
+          {
+            id: "data-retention",
+            what: "{targetName}'s data archived or deleted as its retention says",
+            kind: "commitment",
+            party: "target-owner",
+            leadTimeKey: "data-retention",
+            days: 10,
+            after: ["caller-changes"]
+          }
+        ]
+      },
+      {
+        id: "release",
+        name: "Switch off",
+        steps: [
+          {
+            id: "release",
+            what: "Switch {targetName} off",
+            kind: "task",
+            owner: "platform-lead",
+            days: 2,
+            after: ["caller-changes", "data-retention"]
+          }
+        ]
+      }
+    ]
+  }
+];
+var BUILT_IN_JOURNEYS = BUILT_IN.map((j) => JourneyTemplate.parse(j));
+async function loadJourneys(root) {
+  const journeys = new Map(BUILT_IN_JOURNEYS.map((j) => [j.id, { ...j, source: "built-in" }]));
+  const problems = [];
+  const dir = join(orgPackDirOf(root), "process", "journeys");
+  let names = [];
+  try {
+    names = (await readdir(dir)).filter((n) => /\.ya?ml$/.test(n)).sort();
+  } catch {
+  }
+  for (const n of names) {
+    const rel = `process/journeys/${n}`;
+    try {
+      const r = JourneyTemplate.safeParse((0, import_yaml.parse)(await readFile(join(dir, n), "utf8")));
+      if (!r.success) {
+        problems.push(`${rel}: ${r.error.issues.map((i) => `${i.path.join(".") || "(file)"} ${i.message}`).join("; ")}`);
+        continue;
+      }
+      journeys.set(r.data.id, { ...r.data, source: `org-pack/${rel}` });
+    } catch (e) {
+      problems.push(`${rel}: ${e.message.split("\n")[0]}`);
+    }
+  }
+  return { journeys, problems };
+}
+var stepsOf = (j) => j.phases.flatMap((p) => p.steps.map((s) => ({ ...s, phase: p.id })));
+
+// packages/initiatives/dist/store.js
+var import_yaml2 = __toESM(require_dist(), 1);
+import { mkdir, readFile as readFile2, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+var curatedDirOf = (root) => join2(catalogDirOf(root), "curated");
+var initiativesDirOf = (root) => join2(stateDirOf(root), "initiatives");
+var initiativeDir = (root, id) => join2(initiativesDirOf(root), id);
+var planPath = (root, id) => join2(initiativeDir(root, id), "plan.yaml");
+var InitiativeError = class extends Error {
+  code;
+  constructor(message, code = "invalid") {
+    super(message);
+    this.code = code;
+    this.name = "InitiativeError";
+  }
+};
+async function writeAtomic(path, text) {
+  await mkdir(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  try {
+    await writeFile(tmp, text, "utf8");
+    await rename(tmp, path);
+  } catch (e) {
+    await rm(tmp, { force: true });
+    throw e;
+  }
+}
+async function writeCurated(root, record) {
+  const p = parseRecord(record);
+  if (!p.ok)
+    throw new InitiativeError(`${record.kind} ${record.id}: ${p.issues.map((i) => `${i.path}: ${i.message}`).join("; ")}`);
+  const rel = recordPath(p.record);
+  await writeAtomic(join2(curatedDirOf(root), rel), serializeRecord(p.record));
+  return `catalog/curated/${rel}`;
+}
+async function readView(root) {
+  const dir = catalogDirOf(root);
+  const gen = await readCatalog(join2(dir, "generated"), { cacheRoot: root });
+  const cur = await readCatalog(join2(dir, "curated"), { cacheRoot: root });
+  const records = [...gen.records, ...cur.records];
+  const problems = [
+    ...gen.problems.map((p) => `catalog/generated/${p.file}: ${p.message}`),
+    ...cur.problems.map((p) => `catalog/curated/${p.file}: ${p.message}`)
+  ];
+  const key = (k, id) => `${k}|${id}`;
+  const byKey = new Map(records.map((r) => [key(r.kind, r.id), r]));
+  return {
+    records,
+    problems,
+    get: (kind, id) => byKey.get(key(kind, id)),
+    all: (kind) => records.filter((r) => r.kind === kind)
+  };
+}
+var manualEvidence = (by) => [
+  { source: "manual", by: by.replace(/^@/, "") }
+];
+var PlanItem = external_exports.strictObject({
+  /** The step id, or `<step>.<system>` for a step done once per system. */
+  key: external_exports.string().min(1),
+  step: RecordId,
+  phase: RecordId,
+  kind: external_exports.enum(["change", "commitment", "request", "task"]),
+  what: external_exports.string().min(1),
+  /** The system the item is for, when the step is done per system. */
+  system: RecordId.optional(),
+  party: RecordId.optional(),
+  commitment: RecordId.optional(),
+  change: RecordId.optional(),
+  milestone: external_exports.enum(["design", "build", "release-ready", "released"]).optional(),
+  template: RecordId.optional(),
+  owner: external_exports.string().optional(),
+  days: external_exports.number().int().min(0),
+  /** Where the number of days came from, cited. */
+  leadTime: external_exports.string().min(1),
+  after: external_exports.array(external_exports.string()).default([]),
+  start: IsoDate,
+  due: IsoDate
+});
+var PlanFile = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  initiative: RecordId,
+  journey: external_exports.string().min(1),
+  /** Where the journey template came from: built-in or an org-pack file. */
+  journeySource: external_exports.string().min(1),
+  target: RecordId,
+  targetRelease: IsoDate,
+  createdAt: IsoDateTime,
+  by: external_exports.string().min(1),
+  items: external_exports.array(PlanItem),
+  /** Tasks a person recorded as done: key → who and when. */
+  done: external_exports.record(external_exports.string(), external_exports.strictObject({ at: IsoDateTime, by: external_exports.string().min(1) })).default({}),
+  /** Items a person recorded as started (a request sent, a team asked): key → day. */
+  started: external_exports.record(external_exports.string(), IsoDate).default({}),
+  notes: external_exports.array(external_exports.string()).default([])
+});
+var PLAN_LEADING = [
+  "schemaVersion",
+  "initiative",
+  "journey",
+  "journeySource",
+  "target",
+  "targetRelease",
+  "createdAt",
+  "by",
+  "key",
+  "step",
+  "phase",
+  "kind",
+  "what",
+  "system",
+  "party",
+  "commitment",
+  "change",
+  "milestone",
+  "template",
+  "owner",
+  "days",
+  "leadTime",
+  "after",
+  "start",
+  "due"
+];
+async function writePlan(root, plan) {
+  const p = PlanFile.parse(plan);
+  await writeAtomic(planPath(root, p.initiative), toCanonicalYaml(p, PLAN_LEADING));
+  return `initiatives/${p.initiative}/plan.yaml`;
+}
+async function readPlan(root, id) {
+  let text;
+  try {
+    text = await readFile2(planPath(root, id), "utf8");
+  } catch {
+    return void 0;
+  }
+  const r = PlanFile.safeParse((0, import_yaml2.parse)(text));
+  if (!r.success)
+    throw new InitiativeError(`initiatives/${id}/plan.yaml: ${r.error.issues.map((i) => `${i.path.join(".")} ${i.message}`).join("; ")}`);
+  return r.data;
+}
+var slugOf = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/, "");
+
+// packages/initiatives/dist/dates.js
+var DAY = 864e5;
+var isIsoDay = (s) => /^\d{4}-\d{2}-\d{2}$/.test(s) && !Number.isNaN(Date.parse(s));
+var toDate = (d) => /* @__PURE__ */ new Date(`${d}T00:00:00Z`);
+var toDay = (d) => d.toISOString().slice(0, 10);
+var isWeekday = (d) => d.getUTCDay() !== 0 && d.getUTCDay() !== 6;
+var dayOf = (at) => typeof at === "string" ? at.slice(0, 10) : toDay(at);
+function weekdayOnOrBefore(day) {
+  let d = toDate(day);
+  while (!isWeekday(d))
+    d = new Date(d.getTime() - DAY);
+  return toDay(d);
+}
+function addWorkingDays(day, n) {
+  let d = toDate(day);
+  for (let i = 0; i < n; ) {
+    d = new Date(d.getTime() + DAY);
+    if (isWeekday(d))
+      i++;
+  }
+  return toDay(d);
+}
+function subtractWorkingDays(day, n) {
+  let d = toDate(day);
+  for (let i = 0; i < n; ) {
+    d = new Date(d.getTime() - DAY);
+    if (isWeekday(d))
+      i++;
+  }
+  return toDay(d);
+}
+function workingDays(from, to) {
+  if (to < from)
+    return -workingDays(to, from);
+  let n = 0;
+  for (let d = new Date(toDate(from).getTime() + DAY); d <= toDate(to); d = new Date(d.getTime() + DAY))
+    if (isWeekday(d))
+      n++;
+  return n;
+}
+var laterOf = (a, b) => a > b ? a : b;
+function parseLeadTime(text) {
+  const m = /^\s*(\d+(?:\.\d+)?)\s*(d|days?|wd|working days?|w|weeks?)?\s*$/i.exec(text);
+  if (!m)
+    return void 0;
+  const n = Number(m[1]);
+  const unit = (m[2] ?? "d").toLowerCase();
+  return Math.ceil(unit.startsWith("w") && unit !== "wd" && !unit.startsWith("working") ? n * 5 : n);
+}
+
+// packages/initiatives/dist/new.js
+async function newInitiative(root, o) {
+  if (!JOURNEYS.includes(o.journey))
+    throw new InitiativeError(`There is no journey ${o.journey}. Journeys: ${JOURNEYS.join(", ")}.`, "usage");
+  if (!o.title.trim())
+    throw new InitiativeError("An initiative needs a title.", "usage");
+  if (o.targetRelease && !isIsoDay(o.targetRelease))
+    throw new InitiativeError("Give the target release as YYYY-MM-DD.", "usage");
+  const id = o.id ?? slugOf(o.title);
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(id))
+    throw new InitiativeError(`${id} is not a valid id (lowercase letters, digits, ".", "_" and "-").`, "usage");
+  const view = await readView(root);
+  if (view.get("Initiative", id))
+    throw new InitiativeError(`An initiative ${id} already exists.`, "exists");
+  const initiative = {
+    schemaVersion: 2,
+    kind: "Initiative",
+    id,
+    status: "current",
+    confidence: "asserted",
+    evidence: manualEvidence(o.by),
+    title: o.title.trim(),
+    journey: o.journey,
+    changes: [],
+    parties: [],
+    commitments: [],
+    ...o.targetRelease ? { targetRelease: o.targetRelease } : {},
+    ...o.adoEpic ? { adoEpic: o.adoEpic } : {}
+  };
+  const written = await writeCurated(root, initiative);
+  return { initiative, written };
+}
+
+// packages/initiatives/dist/leadtimes.js
+var norm = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "");
+function median(xs) {
+  const s = [...xs].sort((a, b) => a - b);
+  const m = Math.floor(s.length / 2);
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+function leadTimeFor(step, party, ctx) {
+  const key = step.template ?? step.leadTimeKey;
+  if (party && key && party.typicalLeadTimes[key] !== void 0) {
+    const raw = party.typicalLeadTimes[key];
+    const days = parseLeadTime(raw);
+    if (days !== void 0)
+      return { days, source: `${party.id} typicalLeadTimes.${key} (${raw})` };
+  }
+  if (step.kind === "request" && step.template) {
+    const t = ctx.templates.find((x) => x.id === step.template);
+    const names = /* @__PURE__ */ new Set([norm(step.template), ...t ? [norm(t.requestType), norm(t.id)] : []]);
+    const past = ctx.requests.filter((r) => names.has(norm(r.type)) && r.opened && r.closed);
+    if (past.length) {
+      const days = past.map((r) => workingDays(r.opened, r.closed));
+      const med = median(days);
+      const files = [...new Set(past.map((r) => r.source.path))].sort().join(", ");
+      return {
+        days: Math.ceil(med),
+        source: `${files} (median ${med} working days over ${past.length} request${past.length === 1 ? "" : "s"}, rounded up)`
+      };
+    }
+    if (t)
+      return { days: t.leadTimeDays, source: `org-pack/process/snow/${t.id}.yaml leadTimeDays` };
+  }
+  return {
+    days: step.days,
+    source: `journey ${ctx.journey} step ${step.id} (${step.days} working days)`
+  };
+}
+
+// packages/initiatives/dist/plan.js
+var cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var nowIso = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+var norm2 = (s) => s.toLowerCase().replace(/^party\./, "").replace(/[^a-z0-9]+/g, "");
+function systemOf(view, id) {
+  if (view.get("System", id))
+    return id;
+  return view.get("Component", id)?.system;
+}
+function neighbours(view, target) {
+  const callers = /* @__PURE__ */ new Set();
+  const callees = /* @__PURE__ */ new Set();
+  for (const i of view.all("Interface")) {
+    if (i.status === "retired")
+      continue;
+    const from = systemOf(view, i.from);
+    const to = systemOf(view, i.to);
+    if (!from || !to || from === to)
+      continue;
+    if (to === target)
+      callers.add(from);
+    if (from === target)
+      callees.add(to);
+  }
+  return { callers: [...callers].sort(), callees: [...callees].sort() };
+}
+var partiesOf = (view, system) => view.all("Party").filter((p) => p.status !== "retired" && p.systems.includes(system)).sort((a, b) => cmp(a.id, b.id));
+function partyFor(view, role, o) {
+  const parties = view.all("Party").filter((p) => p.status !== "retired");
+  if (role.startsWith("party:"))
+    return view.get("Party", role.slice("party:".length));
+  switch (role) {
+    case "vendor":
+      return partiesOf(view, o.target).find((p) => p.partyKind === "vendor");
+    case "target-owner":
+      return partiesOf(view, o.target)[0];
+    case "caller-owners":
+    case "callee-owners":
+      return o.system ? partiesOf(view, o.system)[0] : void 0;
+    case "platform":
+      return parties.sort((a, b) => cmp(a.id, b.id)).find((p) => /platform/i.test(`${p.id} ${p.name} ${p.owner ?? ""}`));
+    case "approver": {
+      const want = new Set((o.approvers ?? []).map(norm2));
+      return parties.sort((a, b) => cmp(a.id, b.id)).find((p) => want.has(norm2(p.id)) || want.has(norm2(p.name)) || p.owner && want.has(norm2(p.owner)));
+    }
+    default:
+      return void 0;
+  }
+}
+var fill = (text, v) => text.replace(/\{(\w+)\}/g, (m, k) => v[k] ?? m);
+async function planJourney(root, initiativeId, o) {
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  const view = await readView(root);
+  const initiative = view.get("Initiative", initiativeId);
+  if (!initiative)
+    throw new InitiativeError(`There is no initiative ${initiativeId}.`, "not-found");
+  const previous = await readPlan(root, initiativeId);
+  const target = o.target ?? previous?.target;
+  if (!target)
+    throw new InitiativeError("Name the system the journey is about (--target <system>).", "usage");
+  if (!systemOf(view, target))
+    throw new InitiativeError(`${target} is not a system or component in the catalog.`, "usage");
+  const targetSystem = systemOf(view, target);
+  const release = o.targetRelease ?? initiative.targetRelease ?? previous?.targetRelease;
+  if (!release || !isIsoDay(release))
+    throw new InitiativeError("Give the target release as YYYY-MM-DD (--release).", "usage");
+  const { journeys, problems } = await loadJourneys(root);
+  const journey = journeys.get(initiative.journey);
+  if (!journey)
+    throw new InitiativeError(`No journey ${initiative.journey}: ${problems.join("; ")}`);
+  const orgPack = await loadOrgPack(orgPackDirOf(root));
+  const exports = await readServiceRequestExports({ root });
+  const notes = [...problems];
+  const { callers, callees } = neighbours(view, targetSystem);
+  const named = (o.systems ?? []).map((s) => systemOf(view, s) ?? s);
+  for (const s of o.systems ?? [])
+    if (!systemOf(view, s))
+      notes.push(`${s} is not in the catalog; its items use the id as given.`);
+  const scope = {
+    once: [void 0],
+    target: [targetSystem],
+    callers,
+    callees,
+    systems: named
+  };
+  const nameOf = (s) => view.get("System", s)?.name ?? s;
+  const steps = stepsOf(journey);
+  const items = [];
+  const itemsOfStep = /* @__PURE__ */ new Map();
+  const skipped = /* @__PURE__ */ new Set();
+  steps.forEach((step, order) => {
+    const systems = scope[step.per];
+    if (!systems.length) {
+      skipped.add(step.id);
+      notes.push(`Step ${step.id} is per ${step.per.replace(/s$/, "")} and ${nameOf(targetSystem)} has none: left out.`);
+      itemsOfStep.set(step.id, []);
+      return;
+    }
+    const made = [];
+    for (const system of systems) {
+      const vars = {
+        initiative: initiative.title,
+        target: targetSystem,
+        targetName: nameOf(targetSystem),
+        system: system ?? targetSystem,
+        systemName: system ? nameOf(system) : nameOf(targetSystem)
+      };
+      const template = step.template ? orgPack.serviceRequests.find((t) => t.id === step.template) : void 0;
+      if (step.kind === "request" && !template)
+        notes.push(`Step ${step.id} needs the request template ${step.template}, which the org pack doesn't have; the journey default is used.`);
+      const party = step.party ? partyFor(view, step.party, {
+        target: targetSystem,
+        ...system ? { system } : {},
+        approvers: template?.approvers ?? []
+      }) : void 0;
+      if (step.party && !party)
+        notes.push(`No party for step ${step.id}${system ? ` (${system})` : ""} (${step.party}): add a Party record to catalog/curated/party/ and plan again.`);
+      const lt = leadTimeFor(step, party, {
+        templates: orgPack.serviceRequests,
+        requests: exports.requests,
+        journey: journey.id
+      });
+      const key = step.per === "once" ? step.id : `${step.id}.${system}`;
+      const change = step.kind === "change" ? system ? `${initiative.id}-${system}` : initiative.id : void 0;
+      const d = {
+        order,
+        key,
+        step: step.id,
+        phase: step.phase,
+        kind: step.kind,
+        what: fill(step.what, vars),
+        ...system && step.per !== "once" ? { system } : {},
+        ...party ? { party: party.id } : {},
+        ...(step.kind === "commitment" || step.kind === "request") && party ? { commitment: `${initiative.id}.${key}` } : {},
+        ...change ? { change } : {},
+        ...step.milestone ? { milestone: step.milestone } : {},
+        ...step.template ? { template: step.template } : {},
+        ...step.owner ? { owner: step.owner } : {},
+        days: lt.days,
+        leadTime: lt.source,
+        after: []
+      };
+      made.push(d);
+      items.push(d);
+    }
+    itemsOfStep.set(step.id, made);
+  });
+  const stepById = new Map(steps.map((s) => [s.id, s]));
+  const predecessorsOf = (stepId, seen = /* @__PURE__ */ new Set()) => {
+    const out = [];
+    for (const a of stepById.get(stepId)?.after ?? []) {
+      if (seen.has(a))
+        continue;
+      seen.add(a);
+      if (skipped.has(a))
+        out.push(...predecessorsOf(a, seen));
+      else
+        out.push(a);
+    }
+    return out;
+  };
+  for (const d of items) {
+    const after = [];
+    for (const a of predecessorsOf(d.step)) {
+      const its = itemsOfStep.get(a) ?? [];
+      const same = d.system ? its.filter((x) => x.system === d.system) : [];
+      for (const x of same.length ? same : its)
+        if (!after.includes(x.key))
+          after.push(x.key);
+    }
+    d.after = after;
+  }
+  const successors = new Map(items.map((d) => [d.key, []]));
+  for (const d of items)
+    for (const a of d.after)
+      successors.get(a).push(d);
+  const releaseDay = weekdayOnOrBefore(release);
+  if (releaseDay !== release)
+    notes.push(`${release} is a weekend day; the plan ends on ${releaseDay}.`);
+  const dates = /* @__PURE__ */ new Map();
+  const byKey = new Map(items.map((d) => [d.key, d]));
+  const remaining = new Map(items.map((d) => [d.key, successors.get(d.key).length]));
+  const ready = items.filter((d) => remaining.get(d.key) === 0);
+  while (ready.length) {
+    ready.sort((a, b) => b.order - a.order || (a.key < b.key ? 1 : -1));
+    const d = ready.shift();
+    const succ = successors.get(d.key);
+    const due = succ.length ? succ.map((s) => dates.get(s.key).start).sort()[0] : releaseDay;
+    dates.set(d.key, { start: subtractWorkingDays(due, d.days), due });
+    for (const a of d.after) {
+      remaining.set(a, remaining.get(a) - 1);
+      if (remaining.get(a) === 0)
+        ready.push(byKey.get(a));
+    }
+  }
+  const today = now.toISOString().slice(0, 10);
+  const planItems = items.sort((a, b) => a.order - b.order || cmp(a.key, b.key)).map(({ order: _o, ...d }) => ({ ...d, ...dates.get(d.key) }));
+  const late = planItems.filter((i) => i.start < today);
+  if (late.length)
+    notes.push(`Already behind on the day it is planned: ${late.map((i) => `${i.key} (should have started ${i.start})`).join(", ")}.`);
+  const plan = {
+    schemaVersion: 1,
+    initiative: initiative.id,
+    journey: journey.id,
+    journeySource: journey.source,
+    target: targetSystem,
+    targetRelease: release,
+    createdAt: nowIso(now),
+    by: o.by.replace(/^@/, ""),
+    items: planItems,
+    done: previous?.done ?? {},
+    started: previous?.started ?? {},
+    notes
+  };
+  const keyToRef = (k) => byKey.get(k)?.change ?? k;
+  const commitments = [];
+  for (const i of planItems) {
+    if (!i.commitment || !i.party)
+      continue;
+    const party = view.get("Party", i.party);
+    const existing = view.get("Commitment", i.commitment);
+    const blocks = [...new Set(successors.get(i.key).map((s) => keyToRef(s.key)))];
+    commitments.push({
+      schemaVersion: SCHEMA_VERSION,
+      kind: "Commitment",
+      id: i.commitment,
+      status: "current",
+      confidence: "asserted",
+      evidence: existing?.evidence ?? manualEvidence(o.by),
+      initiative: initiative.id,
+      party: party.id,
+      what: i.what,
+      owner: party.owner ?? party.name,
+      neededBy: i.due,
+      blocks,
+      commitmentStatus: existing?.commitmentStatus === "done" ? "done" : "open"
+    });
+  }
+  const changes = [];
+  for (const i of planItems) {
+    if (!i.change || changes.some((c) => c.id === i.change))
+      continue;
+    const step = stepById.get(i.step);
+    const title = `${initiative.title}: ${i.system ? nameOf(i.system) : nameOf(targetSystem)}`;
+    changes.push({
+      id: i.change,
+      title,
+      type: step.changeType,
+      ...i.system ? { system: i.system } : {},
+      command: `atticus change new "${title}" --type ${step.changeType} --id ${i.change}${i.system ? ` --system ${i.system}` : ""}`
+    });
+  }
+  const updated = {
+    ...initiative,
+    changes: [.../* @__PURE__ */ new Set([...initiative.changes, ...changes.map((c) => c.id)])],
+    parties: [
+      .../* @__PURE__ */ new Set([...initiative.parties, ...planItems.flatMap((i) => i.party ? [i.party] : [])])
+    ],
+    commitments: [.../* @__PURE__ */ new Set([...initiative.commitments, ...commitments.map((c) => c.id)])],
+    targetRelease: release
+  };
+  const written = [];
+  if (!o.dryRun) {
+    written.push(await writePlan(root, plan));
+    for (const c of commitments)
+      written.push(await writeCurated(root, c));
+    written.push(await writeCurated(root, updated));
+  }
+  return { initiative: updated, plan, commitments, changes, notes, written };
+}
+
+// packages/initiatives/dist/status.js
+var cmp2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var ORDER = LIFECYCLE_STATES;
+var REACHED = {
+  design: "plan",
+  build: "qa",
+  "release-ready": "release-ready",
+  released: "released"
+};
+function reached(state, milestone) {
+  if (!state || state === "returned" || state === "draft")
+    return false;
+  const need = REACHED[milestone];
+  if (!need)
+    return false;
+  const rank = (s) => s === "post-release-review" ? ORDER.indexOf("released") + 0.5 : ORDER.indexOf(s);
+  return rank(state) >= rank(need);
+}
+async function initiativeStatus(root, id, o = {}) {
+  const today = dayOf(o.now ?? /* @__PURE__ */ new Date());
+  const view = await readView(root);
+  const initiative = view.get("Initiative", id);
+  if (!initiative)
+    throw new InitiativeError(`There is no initiative ${id}.`, "not-found");
+  const plan = await readPlan(root, id);
+  const store = changeStore(root);
+  const notes = [];
+  const changeStates = /* @__PURE__ */ new Map();
+  for (const c of initiative.changes) {
+    try {
+      changeStates.set(c, (await store.tryRead(c))?.state);
+    } catch (e) {
+      changeStates.set(c, void 0);
+      notes.push(`Change ${c}: ${e.message}`);
+    }
+  }
+  const commitmentRecords = view.all("Commitment").filter((c) => c.initiative === id);
+  const recordOf = new Map(commitmentRecords.map((c) => [c.id, c]));
+  const items = [];
+  let projectedRelease;
+  if (plan) {
+    const isDone = (i) => {
+      if (i.kind === "change")
+        return reached(changeStates.get(i.change), i.milestone);
+      if (i.commitment)
+        return recordOf.get(i.commitment)?.commitmentStatus === "done";
+      return !!plan.done[i.key];
+    };
+    const byKey = new Map(plan.items.map((i) => [i.key, i]));
+    const succ = new Map(plan.items.map((i) => [i.key, []]));
+    for (const i of plan.items)
+      for (const a of i.after)
+        succ.get(a)?.push(i.key);
+    const order = topo(plan.items);
+    const ef = /* @__PURE__ */ new Map();
+    const done = /* @__PURE__ */ new Map();
+    for (const k of order) {
+      const i = byKey.get(k);
+      const d = isDone(i);
+      done.set(k, d);
+      if (d) {
+        ef.set(k, today);
+        continue;
+      }
+      const preds = i.after.map((a) => ef.get(a)).filter(Boolean);
+      const startFrom = plan.started[k] ?? laterOf(today, i.start);
+      const es = preds.reduce((m, p) => laterOf(m, p), startFrom);
+      ef.set(k, laterOf(addWorkingDays(es, i.days), today));
+    }
+    const open = order.filter((k) => !done.get(k));
+    const end = open.map((k) => ef.get(k)).sort().at(-1) ?? today;
+    projectedRelease = end;
+    const lf = /* @__PURE__ */ new Map();
+    for (const k of [...order].reverse()) {
+      if (done.get(k))
+        continue;
+      const after = succ.get(k).filter((s) => !done.get(s));
+      const latest = after.length ? after.map((s) => subtractWorkingDays(lf.get(s), byKey.get(s).days)).sort()[0] : end;
+      lf.set(k, latest);
+    }
+    for (const i of plan.items) {
+      const d = done.get(i.key);
+      const finish = ef.get(i.key);
+      const float = d ? 0 : workingDays(finish, lf.get(i.key));
+      const status2 = d ? "done" : today > i.due ? "slipped" : finish > i.due ? "at-risk" : "open";
+      const lateBefore = i.after.filter((a) => !done.get(a) && ef.get(a) > byKey.get(a).due);
+      const why = status2 === "done" ? "Done." : status2 === "slipped" ? `Due ${i.due} and not done.` : status2 === "at-risk" ? `Projected to finish ${finish}, after its due date ${i.due}${lateBefore.length ? `, because ${lateBefore.join(", ")} ${lateBefore.length === 1 ? "is" : "are"} late` : ""}.` : `On plan: due ${i.due}.`;
+      items.push({
+        key: i.key,
+        kind: i.kind,
+        what: i.what,
+        ...i.party ? { party: i.party } : {},
+        ...i.change ? { change: i.change } : {},
+        ...i.commitment ? { commitment: i.commitment } : {},
+        start: i.start,
+        due: i.due,
+        done: d,
+        projectedFinish: finish,
+        float,
+        critical: !d && float <= 0,
+        status: status2,
+        why
+      });
+    }
+  } else
+    notes.push(`Initiative ${id} has no plan yet: run initiative plan.`);
+  const criticalPath = [];
+  const stateOf = new Map(items.map((i) => [i.key, i]));
+  const planByKey = new Map((plan?.items ?? []).map((i) => [i.key, i]));
+  const pick = (keys) => keys.map((k) => stateOf.get(k)).filter((s) => s && s.critical).sort((a, b) => a.projectedFinish === b.projectedFinish ? cmp2(a.key, b.key) : a.projectedFinish < b.projectedFinish ? 1 : -1)[0];
+  const sinks = items.filter((i) => !items.some((j) => planByKey.get(j.key)?.after.includes(i.key)));
+  let cur = pick(sinks.map((s) => s.key));
+  while (cur) {
+    criticalPath.unshift(cur.key);
+    cur = pick(planByKey.get(cur.key).after);
+  }
+  const commitments = commitmentRecords.map((c) => {
+    const item = items.find((i) => i.commitment === c.id);
+    let status2;
+    let why;
+    if (c.commitmentStatus === "done")
+      [status2, why] = ["done", "Done."];
+    else if (item)
+      [status2, why] = [item.status, item.why];
+    else if (today > c.neededBy)
+      [status2, why] = ["slipped", `Needed by ${c.neededBy} and not done.`];
+    else if (workingDays(today, c.neededBy) <= 2)
+      [status2, why] = ["at-risk", `Needed by ${c.neededBy}: two working days or less left.`];
+    else
+      [status2, why] = ["open", `Needed by ${c.neededBy}.`];
+    return {
+      id: c.id,
+      what: c.what,
+      party: c.party,
+      neededBy: c.neededBy,
+      recorded: c.commitmentStatus,
+      status: status2,
+      why
+    };
+  });
+  const changes = initiative.changes.map((c) => {
+    const state = changeStates.get(c);
+    return {
+      id: c,
+      ...state ? { state } : {},
+      milestones: (plan?.items ?? []).filter((i) => i.change === c).map((i) => ({
+        milestone: i.milestone,
+        due: i.due,
+        reached: reached(state, i.milestone)
+      }))
+    };
+  });
+  const target = plan?.targetRelease ?? initiative.targetRelease;
+  const allDone = items.length > 0 && items.every((i) => i.done);
+  const status = !plan ? "not-planned" : allDone ? "done" : target && today > target ? "slipped" : items.some((i) => i.status === "slipped" || i.status === "at-risk") || target && projectedRelease && projectedRelease > target || commitments.some((c) => c.status === "slipped" || c.status === "at-risk") ? "at-risk" : "on-track";
+  return {
+    initiative: id,
+    title: initiative.title,
+    journey: initiative.journey,
+    ...plan ? { target: plan.target } : {},
+    ...target ? { targetRelease: target } : {},
+    today,
+    ...projectedRelease ? { projectedRelease } : {},
+    status,
+    items,
+    criticalPath,
+    commitments,
+    changes,
+    notes
+  };
+}
+function topo(items) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const byKey = new Map(items.map((i) => [i.key, i]));
+  const visit = (k) => {
+    if (seen.has(k))
+      return;
+    seen.add(k);
+    for (const a of byKey.get(k)?.after ?? [])
+      visit(a);
+    out.push(k);
+  };
+  for (const i of items)
+    visit(i.key);
+  return out;
+}
+async function recordCommitment(root, id, o) {
+  const view = await readView(root);
+  const c = view.get("Commitment", id);
+  if (!c)
+    throw new InitiativeError(`There is no commitment ${id}.`, "not-found");
+  const by = o.by.replace(/^@/, "");
+  const evidence = c.evidence.some((e) => e.source === "manual" && e.by === by) ? c.evidence : [...c.evidence, ...manualEvidence(by)];
+  const updated = { ...c, commitmentStatus: o.status, evidence };
+  return { commitment: updated, written: await writeCurated(root, updated) };
+}
+
+// packages/initiatives/dist/card.js
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
+var cmp3 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var cell = (s) => s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+var op = (method, path) => method ? `${method} ${path}` : path;
+function table(header, rows) {
+  if (!rows.length)
+    return ["None known."];
+  return [
+    `| ${header.join(" | ")} |`,
+    `| ${header.map(() => "---").join(" | ")} |`,
+    ...rows.map((r) => `| ${r.map(cell).join(" | ")} |`)
+  ];
+}
+function systemCard(view, systems, o = {}) {
+  const sys = systems.map((s) => view.get("System", s)).filter((s) => !!s);
+  if (!sys.length)
+    throw new InitiativeError(`None of ${systems.join(", ")} is a system in the catalog.`, "not-found");
+  const ids = new Set(sys.map((s) => s.id));
+  const inSys = (id) => {
+    const s = systemOf(view, id);
+    return s !== void 0 && ids.has(s);
+  };
+  const label = (id) => {
+    if (inSys(id))
+      return id;
+    const s = systemOf(view, id);
+    const name = s ? view.get("System", s)?.name : void 0;
+    return s && s !== id && name ? `${id} (${name})` : id;
+  };
+  const title = sys.map((s) => s.name).join(", ");
+  const L = [`# System card: ${title}`, ""];
+  if (o.header?.length)
+    L.push(...o.header, "");
+  L.push("Please check what we know about your system, correct anything that is wrong, and answer the open questions. Your reply goes into our intake as a document; nothing here changes without a person reviewing it.", "", "## Systems", "", ...table(["System", "Boundary", "Owner", "Repos"], sys.map((s) => [
+    `${s.name} (${s.id})`,
+    s.boundary,
+    s.owner ?? "unknown",
+    s.repos.join(", ") || "none"
+  ])), "");
+  const comps = view.all("Component").filter((c) => ids.has(c.system)).sort((a, b) => cmp3(a.id, b.id));
+  if (comps.length)
+    L.push("## Components", "", ...table(["Component", "Type", "Repo"], comps.map((c) => [c.id, c.type, c.repo ?? "unknown"])), "");
+  const endpoints = view.all("Endpoint").filter((e) => inSys(e.component)).sort((a, b) => cmp3(a.id, b.id));
+  L.push("## What it offers", "", ...table(["Endpoint", "Type", "Operation"], endpoints.map((e) => [e.id, e.endpointType, op(e.method, e.pathOrTopic)])), "");
+  const ifs = view.all("Interface").filter((i) => i.status !== "retired");
+  const row = (i) => [
+    label(i.from),
+    label(i.to),
+    i.via,
+    op(i.method, i.normalizedPath),
+    i.sync
+  ];
+  const byPath = (a, b) => cmp3(a.from, b.from) || cmp3(a.to, b.to) || cmp3(a.normalizedPath, b.normalizedPath);
+  L.push("## Who calls it", "", ...table(["From", "To", "Via", "Operation", "Sync"], ifs.filter((i) => inSys(i.to) && !inSys(i.from)).sort(byPath).map(row)), "", "## What it calls", "", ...table(["From", "To", "Via", "Operation", "Sync"], ifs.filter((i) => inSys(i.from) && !inSys(i.to)).sort(byPath).map(row)), "");
+  const stores = view.all("DataStore").filter((d) => d.ownerComponent && inSys(d.ownerComponent)).sort((a, b) => cmp3(a.id, b.id));
+  const tables = view.all("Table").filter((t) => stores.some((s) => s.id === t.dataStore));
+  L.push("## Data it owns", "", ...table(["Store", "Type", "Tables"], stores.map((s) => [
+    s.id,
+    s.storeType,
+    tables.filter((t) => t.dataStore === s.id).map((t) => t.id).sort().join(", ") || "none known"
+  ])), "");
+  const questions = view.all("OwnerQuestion").filter((q) => ids.has(q.system) && q.questionState !== "answered").sort((a, b) => cmp3(a.id, b.id));
+  L.push("## Open questions", "");
+  if (questions.length)
+    for (const q of questions)
+      L.push(`- (${q.id}) ${q.question} Needed: ${q.neededFact}. Asked of: ${q.owner} (${q.questionState})`);
+  else
+    L.push("None recorded.");
+  L.push("", "## How to reply", "", "Reply in any form: edit this page, send a document or an e-mail. The reply is saved into the metarepo with `atticus intake add <file>`; it is read like any other document and every fact in it is checked against code.", "");
+  return L.join("\n");
+}
+var nowIso2 = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+async function requestFromTeam(root, initiativeId, partyId, o) {
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  const today = dayOf(now);
+  const by = o.by.replace(/^@/, "");
+  const view = await readView(root);
+  const initiative = view.get("Initiative", initiativeId);
+  if (!initiative)
+    throw new InitiativeError(`There is no initiative ${initiativeId}.`, "not-found");
+  const party = view.get("Party", partyId);
+  if (!party)
+    throw new InitiativeError(`There is no party ${partyId}.`, "not-found");
+  const systems = o.systems ?? party.systems;
+  if (!systems.length)
+    throw new InitiativeError(`Party ${partyId} names no systems; add them to its record or pass --system.`, "usage");
+  const raw = party.typicalLeadTimes["system-card"];
+  const days = (raw ? parseLeadTime(raw) : void 0) ?? 5;
+  const due = addWorkingDays(today, days);
+  const slug = partyId.replace(/^party\./, "");
+  const cardRel = `initiatives/${initiativeId}/requests/${slug}.md`;
+  const card = systemCard(view, systems, {
+    header: [
+      `For: ${initiative.title} (initiative ${initiative.id})`,
+      `Asked of: ${party.name} (${party.id}), by ${by} on ${today}`,
+      `Reply by: ${due}`
+    ]
+  });
+  const cardFile = join3(initiativeDir(root, initiativeId), "requests", `${slug}.md`);
+  await mkdir2(dirname2(cardFile), { recursive: true });
+  await writeFile2(cardFile, card, "utf8");
+  const commitment = {
+    schemaVersion: 2,
+    kind: "Commitment",
+    id: `${initiativeId}.request.${slug}`,
+    status: "current",
+    confidence: "asserted",
+    evidence: manualEvidence(by),
+    initiative: initiative.id,
+    party: party.id,
+    what: `${party.name} replies to the system card for ${systems.join(", ")}`,
+    owner: party.owner ?? party.name,
+    neededBy: due,
+    blocks: [...initiative.changes],
+    commitmentStatus: "open"
+  };
+  const written = [cardRel, await writeCurated(root, commitment)];
+  const updated = {
+    ...initiative,
+    parties: [.../* @__PURE__ */ new Set([...initiative.parties, party.id])],
+    commitments: [.../* @__PURE__ */ new Set([...initiative.commitments, commitment.id])]
+  };
+  written.push(await writeCurated(root, updated));
+  const notification = {
+    channel: party.channel ?? "email",
+    title: `System card: ${systems.join(", ")} (reply by ${due})`,
+    body: [
+      `Hello ${party.name},`,
+      "",
+      `For ${initiative.title} we need you to check what we know about ${systems.join(", ")} and answer the open questions on the attached system card by ${due}.`,
+      "Reply in any form; we take your reply in as a document and check every fact against code.",
+      "",
+      `Sent by ${by}.`
+    ].join("\n"),
+    link: cardRel,
+    ...party.contacts.length ? { mentions: party.contacts } : {}
+  };
+  const store = o.steps ?? fileStepStore(root);
+  const notifier = new ManualNotifier({ store, root, now: () => nowIso2(now) });
+  const sent = await notifier.send(notification, { by, at: nowIso2(now), ref: commitment.id });
+  const stepId = sent.id.replace(/^manual:/, "");
+  const step = await store.get(stepId);
+  written.push(`steps/${step.id}.yaml`);
+  return { card, cardPath: cardRel, commitment, notification, step, written };
+}
+
+export {
+  dayOf,
+  addWorkingDays,
+  workingDays,
+  laterOf,
+  JOURNEYS,
+  InitiativeError,
+  readView,
+  readPlan,
+  leadTimeFor,
+  newInitiative,
+  planJourney,
+  initiativeStatus,
+  recordCommitment,
+  requestFromTeam
+};