@structured-vibe-coding/core 0.18.0 → 0.19.0

package/dist/{chunk-LHSR7JG2.js → chunk-2FJBFYVJ.js}

@@ -1,3 +1,10 @@
+import {
+  WORK_TYPES,
+  getHeadSha,
+  gitUserName,
+  loadConfig,
+  readTeamConfig
+} from "./chunk-TGRV6WGS.js";
 import {
   ChangeMetaSchema,
   activeStages,
@@ -5,6 +12,7 @@ import {
   changeDirName,
   clearActiveIf,
   firstActiveStageId,
+  getActiveChangeId,
   getStage,
   isStageSkipped,
   loadWorkflow,
@@ -14,7 +22,7 @@ import {
   setActiveChange,
   shouldAutoSkip,
   uniqueChangeDirName
-} from "./chunk-QHV5KZKX.js";
+} from "./chunk-HG7TPW5V.js";
 import {
   archiveDir,
   changeMetaPath,
@@ -24,6 +32,7 @@ import {
   displayArchivePath,
   ensureDir,
   listDirs,
+  listFiles,
   memoryDir,
   pathExists,
   readText,
@@ -35,7 +44,7 @@ import {
 } from "./chunk-O5SP6X5R.js";
 
 // src/greenfield.ts
-import { join as join4 } from "pathe";
+import { join as join6 } from "pathe";
 
 // src/artifacts.ts
 var PLACEHOLDER_WORD = /^(?:TBD|TODO|N\/A|NA|none|tbd|todo|n\/a|\.{3}|…|-|—|–|_|\*)$/i;
@@ -149,7 +158,7 @@ function incompleteArtifactReason(path, content) {
 }
 
 // src/change.ts
-import { join as join3 } from "pathe";
+import { join as join5 } from "pathe";
 
 // src/metrics.ts
 import { createReadStream } from "fs";
@@ -175,10 +184,22 @@ var TokenUsageMetricSchema = z.object({
   outputTokens: z.number().int().nonnegative().nullable(),
   measured: z.literal(true)
 });
+var DecisionMetricSchema = z.object({
+  workType: z.enum(WORK_TYPES),
+  kind: z.enum(["reason", "decide"]),
+  provider: z.enum(["command", "ollama"]),
+  model: z.string().min(1).nullable(),
+  startedAt: UtcTimestampSchema,
+  inputTokens: z.number().int().nonnegative().nullable(),
+  cacheReadTokens: z.number().int().nonnegative().nullable(),
+  cacheWriteTokens: z.number().int().nonnegative().nullable(),
+  outputTokens: z.number().int().nonnegative().nullable()
+});
 var ChangeMetricsSchema = z.object({
   version: z.literal(1),
   phases: z.array(PhaseMetricSchema),
-  requests: z.array(TokenUsageMetricSchema)
+  requests: z.array(TokenUsageMetricSchema),
+  decisions: z.array(DecisionMetricSchema).optional()
 });
 var MODEL_ID = /^[A-Za-z0-9._:/-]+$/;
 function metricsPath(projectRoot, config, changeId) {
@@ -198,6 +219,12 @@ async function writeChangeMetrics(projectRoot, config, changeId, metrics) {
   await writeText(path, `${JSON.stringify(validated, null, 2)}
 `);
 }
+async function recordDecisionMetric(projectRoot, config, changeId, draft) {
+  if (!config.metrics.enabled) return;
+  const metrics = await readChangeMetrics(projectRoot, config, changeId);
+  const decisions = [...metrics.decisions ?? [], DecisionMetricSchema.parse(draft)];
+  await writeChangeMetrics(projectRoot, config, changeId, { ...metrics, decisions });
+}
 async function startPhase(projectRoot, config, changeId, phase, startedAt = (/* @__PURE__ */ new Date()).toISOString()) {
   if (!config.metrics.enabled) return;
   const metrics = await readChangeMetrics(projectRoot, config, changeId);
@@ -532,19 +559,173 @@ async function importSessionMetrics(projectRoot, config, changeId, sessionLogPat
 }
 
 // src/stage-gates.ts
+import { join as join3 } from "pathe";
+
+// src/role/signoff.ts
+import { appendFile } from "fs/promises";
 import { join as join2 } from "pathe";
+function ok(stdout) {
+  return { exitCode: 0, stdout };
+}
+function fail(stdout) {
+  return { exitCode: 1, stdout };
+}
+function oneLine(note, empty, broken) {
+  const raw = note ?? "";
+  if (raw.includes("\n") || raw.includes("\r")) return fail(broken);
+  const words = raw.trim();
+  if (!words) return fail(empty);
+  return words;
+}
+function safeStageId(stage) {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(stage);
+}
+function signoffFileName(stage, sha) {
+  return `reviews/${stage}-${sha}.md`;
+}
+function renderSignoff(record) {
+  return [
+    "---",
+    `kind: ${record.kind}`,
+    `sha: ${record.sha}`,
+    `reviewer: ${record.reviewer}`,
+    `verdict: ${record.verdict}`,
+    "---",
+    record.evidence,
+    ""
+  ].join("\n");
+}
+function parseSignoff(raw) {
+  const lines = raw.split("\n");
+  if (lines[0] !== "---") return null;
+  const end = lines.indexOf("---", 1);
+  if (end <= 1) return null;
+  const fields = /* @__PURE__ */ new Map();
+  for (const line of lines.slice(1, end)) {
+    const split = line.indexOf(":");
+    if (split <= 0) return null;
+    fields.set(line.slice(0, split).trim(), line.slice(split + 1).trim());
+  }
+  const kind = fields.get("kind") ?? "";
+  const sha = fields.get("sha") ?? "";
+  const reviewer = fields.get("reviewer") ?? "";
+  const verdict = fields.get("verdict") ?? "";
+  const evidence = lines.slice(end + 1).join("\n").trim();
+  if (!kind || !sha || !reviewer || !verdict || !evidence) return null;
+  return { kind, sha, reviewer, verdict, evidence };
+}
+async function headSha(root) {
+  try {
+    const sha = await getHeadSha(root);
+    if (!sha) return fail("Cannot sign off: Git HEAD is unavailable in this project.");
+    return sha;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Git HEAD is unavailable.";
+    return fail(message);
+  }
+}
+async function openChange(root, change) {
+  const config = await loadConfig(root);
+  const requested = change?.trim() ?? "";
+  const changeId = requested || await getActiveChangeId(root, config);
+  if (!changeId) return fail("No active change.");
+  try {
+    const ctx = await buildContext(root, config, changeId);
+    return { path: ctx.path, stage: ctx.meta.stage };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Change not found.";
+    return fail(message);
+  }
+}
+function isFailure(value) {
+  return "exitCode" in value;
+}
+async function recordSignoff(root, input) {
+  const words = oneLine(input.note, "A sign-off needs a note.", "A sign-off note is one line.");
+  if (typeof words !== "string") return words;
+  const opened = await openChange(root, input.change);
+  if (isFailure(opened)) return opened;
+  const stage = (input.stage?.trim() || opened.stage).trim();
+  if (!safeStageId(stage)) return fail("A stage id is not valid.");
+  const team = await readTeamConfig(root);
+  if ("error" in team) return fail(team.error);
+  const sha = await headSha(root);
+  if (typeof sha !== "string") return sha;
+  const gitUser = gitUserName(root);
+  if (!gitUser) return fail("Git user.name is not set.");
+  if (!team.team.humans.some((human) => human.name === gitUser)) {
+    return fail("Git user.name is not a human approver.");
+  }
+  const file = join2(opened.path, signoffFileName(stage, sha));
+  const existing = await pathExists(file) ? parseSignoff(await readText(file)) : null;
+  const same = existing !== null && existing.kind === stage && existing.sha === sha && existing.reviewer === gitUser && existing.verdict === "accept";
+  if (!same) {
+    await writeText(
+      file,
+      renderSignoff({ kind: stage, sha, reviewer: gitUser, verdict: "accept", evidence: words })
+    );
+  }
+  await appendFile(
+    join2(opened.path, "decisions.md"),
+    `${nowIso()} sign-off ${stage} ${sha} ${gitUser} accept ${words}
+`
+  );
+  return ok(`Signed ${stage} at ${sha}.`);
+}
+async function recordDecisionRequest(root, input) {
+  const words = oneLine(input.note, "A decision needs a note.", "A decision note is one line.");
+  if (typeof words !== "string") return words;
+  const opened = await openChange(root, input.change);
+  if (isFailure(opened)) return opened;
+  await appendFile(join2(opened.path, "decisions.md"), `${nowIso()} decision-needed ${words}
+`);
+  return ok("Decision needed.");
+}
+async function checkHumanSignoff(root, changePath2, stageId) {
+  if (!safeStageId(stageId)) return { ok: false, message: "A stage id is not valid." };
+  const team = await readTeamConfig(root);
+  if ("error" in team) return { ok: false, message: team.error };
+  let sha;
+  try {
+    sha = await getHeadSha(root);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Git HEAD is unavailable.";
+    return { ok: false, message };
+  }
+  if (!sha) {
+    return {
+      ok: false,
+      message: `Cannot leave stage "${stageId}": Git HEAD is unavailable, so a human sign-off cannot be checked.`
+    };
+  }
+  const file = join2(changePath2, signoffFileName(stageId, sha));
+  if (!await pathExists(file)) {
+    return {
+      ok: false,
+      message: `Hard gate on stage "${stageId}" needs a human sign-off for this commit. Run \`sdd team signoff\`.`
+    };
+  }
+  const parsed = parseSignoff(await readText(file));
+  const listed = parsed !== null && parsed.kind === stageId && parsed.sha === sha && parsed.verdict === "accept" && team.team.humans.some((human) => human.name === parsed.reviewer);
+  if (!listed) {
+    return { ok: false, message: `Sign-off for stage "${stageId}" does not match this commit.` };
+  }
+  return { ok: true };
+}
+
+// src/stage-gates.ts
 async function checkRequiredArtifacts(changePath2, stageId, artifacts) {
   const errors = [];
   for (const artifact of artifacts) {
     if (!artifact.required) continue;
     if (artifact.path.endsWith("/")) {
-      const target2 = join2(changePath2, artifact.path);
+      const target2 = join3(changePath2, artifact.path);
       if (!await pathExists(target2)) {
         errors.push(`Missing required directory: ${artifact.path} (stage ${stageId})`);
       }
       continue;
     }
-    const target = join2(changePath2, artifact.path);
+    const target = join3(changePath2, artifact.path);
     if (!await pathExists(target)) {
       errors.push(incompleteArtifactReason(artifact.path, null));
       continue;
@@ -579,7 +760,7 @@ async function incompletePriorStageErrors(ctx) {
   }
   return errors;
 }
-async function canLeaveStage(ctx, config) {
+async function canLeaveStage(ctx, config, projectRoot) {
   const stage = getStage(ctx.workflow, ctx.meta, ctx.meta.stage);
   const errors = [];
   const warnings = [];
@@ -594,7 +775,23 @@ async function canLeaveStage(ctx, config) {
     effectiveGate = "hard";
   }
   const gateState = ctx.meta.gates?.[stage.id];
-  if (effectiveGate === "hard") {
+  const humanGate = effectiveGate === "hard" && (stage.gate?.approvers?.includes("human") ?? false);
+  if (humanGate) {
+    if (gateState?.status === "failed") {
+      errors.push(
+        `Hard gate on stage "${stage.id}" is not approved. Run \`sdd gate approve\` or complete the checklist.`
+      );
+    } else if (gateState?.status !== "waived") {
+      if (!projectRoot) {
+        errors.push(
+          `Cannot leave stage "${stage.id}": the project root is required to check a human sign-off.`
+        );
+      } else {
+        const signed = await checkHumanSignoff(projectRoot, ctx.path, stage.id);
+        if (!signed.ok) errors.push(signed.message);
+      }
+    }
+  } else if (effectiveGate === "hard") {
     if (!gateState || gateState.status !== "approved" && gateState.status !== "waived") {
       errors.push(
         `Hard gate on stage "${stage.id}" is not approved. Run \`sdd gate approve\` or complete the checklist.`
@@ -654,6 +851,76 @@ async function approveGate(projectRoot, config, changeId, stageId, note, status
   return buildContext(projectRoot, config, changeId);
 }
 
+// src/stage-items.ts
+import { join as join4 } from "pathe";
+import { z as z2 } from "zod";
+var itemSchema = z2.object({
+  id: z2.string().trim().min(1),
+  stage: z2.string().trim().min(1),
+  source: z2.string().trim().min(1),
+  status: z2.enum(["open", "done"])
+}).strict();
+var itemsSchema = z2.array(itemSchema);
+function itemSourcePattern(pattern) {
+  if (pattern.includes("..") || pattern.startsWith("/") || pattern.includes("\\")) return null;
+  const slash = pattern.lastIndexOf("/");
+  if (slash <= 0) return null;
+  const dir = pattern.slice(0, slash);
+  const file = pattern.slice(slash + 1);
+  if (!/^[A-Za-z0-9._-]+$/.test(dir) || dir.includes("*")) return null;
+  const star = file.indexOf("*");
+  if (star < 0 || file.indexOf("*", star + 1) !== -1) return null;
+  return { dir, prefix: file.slice(0, star), suffix: file.slice(star + 1) };
+}
+function matches(name, prefix, suffix) {
+  if (!name.startsWith(prefix) || !name.endsWith(suffix)) return false;
+  return name.length > prefix.length + suffix.length;
+}
+function itemId(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) return name;
+  return name.slice(0, dot);
+}
+async function syncStageItems(changeDir, stage) {
+  if (!stage.items_from) return [];
+  const pattern = itemSourcePattern(stage.items_from);
+  if (!pattern) throw new Error("items_from is invalid");
+  const names = (await listFiles(join4(changeDir, pattern.dir))).filter((name) => matches(name, pattern.prefix, pattern.suffix)).sort();
+  const itemsPath = join4(changeDir, "items.yaml");
+  let existing = [];
+  if (await pathExists(itemsPath)) {
+    let raw;
+    try {
+      raw = await readYaml(itemsPath);
+    } catch {
+      throw new Error("items.yaml is invalid");
+    }
+    const parsed = itemsSchema.safeParse(raw);
+    if (!parsed.success) throw new Error("items.yaml is invalid");
+    existing = parsed.data;
+  }
+  const others = existing.filter((item) => item.stage !== stage.id);
+  const mine = new Map(
+    existing.filter((item) => item.stage === stage.id).map((item) => [item.id, item])
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const next = [];
+  for (const name of names) {
+    const id = itemId(name);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const source = `${pattern.dir}/${name}`;
+    const prev = mine.get(id);
+    if (prev) next.push({ ...prev, source });
+    else next.push({ id, stage: stage.id, source, status: "open" });
+  }
+  const items = [...others, ...next].sort(
+    (a, b) => a.stage === b.stage ? a.id.localeCompare(b.id) : a.stage.localeCompare(b.stage)
+  );
+  await writeYaml(itemsPath, items);
+  return next.map((item) => item.id);
+}
+
 // src/change.ts
 async function existingChangeIds(projectRoot, config) {
   const open = await listDirs(changesDir(projectRoot, config));
@@ -703,7 +970,7 @@ async function createChange(input) {
   await materializeStageArtifacts(projectRoot, config, id, workflow, meta, firstStage);
   await setActiveChange(projectRoot, config, id);
   try {
-    const { refreshActiveAgentContext } = await import("./agents-AKSUXQHN.js");
+    const { refreshActiveAgentContext } = await import("./agents-PSIOQEYH.js");
     await refreshActiveAgentContext(projectRoot);
   } catch {
   }
@@ -714,7 +981,7 @@ async function materializeStageArtifacts(projectRoot, config, changeId, workflow
   const dir = changePath(projectRoot, config, changeId);
   const tdir = templatesDir(projectRoot);
   for (const artifact of stage.artifacts) {
-    const target = join3(dir, artifact.path);
+    const target = join5(dir, artifact.path);
     if (await pathExists(target)) continue;
     if (artifact.path.endsWith("/")) {
       await ensureDir(target);
@@ -723,11 +990,11 @@ async function materializeStageArtifacts(projectRoot, config, changeId, workflow
     }
     let content = defaultArtifactContent(artifact.id, meta, stage, workflow);
     if (artifact.template) {
-      const templatePath = join3(tdir, artifact.template.replace(/^templates\//, ""));
+      const templatePath = join5(tdir, artifact.template.replace(/^templates\//, ""));
       const candidates = [
-        join3(tdir, artifact.template),
+        join5(tdir, artifact.template),
         templatePath,
-        join3(tdir, `${artifact.id}.md`)
+        join5(tdir, `${artifact.id}.md`)
       ];
       for (const c of candidates) {
         if (await pathExists(c)) {
@@ -738,7 +1005,7 @@ async function materializeStageArtifacts(projectRoot, config, changeId, workflow
         }
       }
     } else {
-      const fallback = join3(tdir, `${artifact.id}.md`);
+      const fallback = join5(tdir, `${artifact.id}.md`);
       if (await pathExists(fallback)) {
         content = interpolate(await readText(fallback), meta, stage, workflow, {
           idea: String(meta.flags?.idea ?? meta.title ?? "")
@@ -748,6 +1015,10 @@ async function materializeStageArtifacts(projectRoot, config, changeId, workflow
     await writeText(target, content);
     created.push(artifact.path);
   }
+  if (stage.items_from) {
+    await syncStageItems(dir, stage);
+    created.push("items.yaml");
+  }
   return created;
 }
 function interpolate(template, meta, stage, workflow, extra) {
@@ -801,7 +1072,7 @@ async function advanceStage(projectRoot, config, changeId, opts) {
         stage2
       );
       try {
-        const { refreshActiveAgentContext } = await import("./agents-AKSUXQHN.js");
+        const { refreshActiveAgentContext } = await import("./agents-PSIOQEYH.js");
         await refreshActiveAgentContext(projectRoot);
       } catch {
       }
@@ -819,7 +1090,7 @@ async function advanceStage(projectRoot, config, changeId, opts) {
       };
     }
   }
-  const check = await canLeaveStage(ctx, config);
+  const check = await canLeaveStage(ctx, config, projectRoot);
   warnings.push(...check.warnings);
   if (!check.ok && !opts?.force) {
     throw new Error(check.errors.join("\n"));
@@ -858,7 +1129,7 @@ async function advanceStage(projectRoot, config, changeId, opts) {
     stage
   );
   try {
-    const { refreshActiveAgentContext } = await import("./agents-AKSUXQHN.js");
+    const { refreshActiveAgentContext } = await import("./agents-PSIOQEYH.js");
     await refreshActiveAgentContext(projectRoot);
   } catch {
   }
@@ -972,7 +1243,7 @@ async function completeChange(projectRoot, config, changeId) {
       );
     }
   }
-  const check = await canLeaveStage(ctx, config);
+  const check = await canLeaveStage(ctx, config, projectRoot);
   if (!check.ok) {
     throw new Error(check.errors.join("\n"));
   }
@@ -991,7 +1262,7 @@ async function completeChange(projectRoot, config, changeId) {
   let promoted;
   if (ctx.meta.workflow === "greenfield" || ctx.meta.flags?.greenfield === true) {
     try {
-      const { promoteGreenfieldToMemory: promoteGreenfieldToMemory2 } = await import("./greenfield-I5S5OS2D.js");
+      const { promoteGreenfieldToMemory: promoteGreenfieldToMemory2 } = await import("./greenfield-QFA5WVHE.js");
       promoted = await promoteGreenfieldToMemory2(projectRoot, config, changeId);
     } catch {
     }
@@ -1000,7 +1271,7 @@ async function completeChange(projectRoot, config, changeId) {
   let archivedTo = null;
   const shouldArchive = config.persistence.archive_on_complete && ctx.workflow.on_complete?.archive !== false;
   if (shouldArchive) {
-    const dest = join3(archiveDir(projectRoot, config), changeId);
+    const dest = join5(archiveDir(projectRoot, config), changeId);
     if (await pathExists(dest)) {
       throw new Error(`Archive already exists for change: ${changeId}`);
     }
@@ -1010,7 +1281,7 @@ async function completeChange(projectRoot, config, changeId) {
     archivedTo = dest;
   }
   if (archivedTo) {
-    const meta = ChangeMetaSchema.parse(await readYaml(join3(archivedTo, "meta.yaml")));
+    const meta = ChangeMetaSchema.parse(await readYaml(join5(archivedTo, "meta.yaml")));
     return {
       archivedTo,
       promoted,
@@ -1049,7 +1320,7 @@ async function startGreenfield(input) {
     workflowName: "greenfield",
     flags: { greenfield: true, idea }
   });
-  const visionPath = join4(ctx.path, "vision.md");
+  const visionPath = join6(ctx.path, "vision.md");
   if (await pathExists(visionPath)) {
     let body = await readText(visionPath);
     if (body.includes("{{idea}}")) {
@@ -1118,18 +1389,18 @@ function parseFeaturesBacklog(markdown, sourcePath) {
   return features;
 }
 async function findFeaturesBacklogPath(projectRoot, config) {
-  const mem = join4(memoryDir(projectRoot, config), "features.md");
+  const mem = join6(memoryDir(projectRoot, config), "features.md");
   if (await pathExists(mem)) return mem;
-  const { getActiveChangeId: getActiveChangeId2 } = await import("./change-context-REE7UKU7.js");
+  const { getActiveChangeId: getActiveChangeId2 } = await import("./change-context-EZJMSGSP.js");
   const active = await getActiveChangeId2(projectRoot, config);
   if (active) {
-    const p = join4(changePath(projectRoot, config, active), "features.md");
+    const p = join6(changePath(projectRoot, config, active), "features.md");
     if (await pathExists(p)) return p;
   }
   const ids = (await listDirs(changesDir(projectRoot, config))).sort().reverse();
   for (const id of ids) {
     try {
-      const p = join4(changePath(projectRoot, config, id), "features.md");
+      const p = join6(changePath(projectRoot, config, id), "features.md");
       if (await pathExists(p)) {
         const body = await readText(p);
         if (parseFeaturesBacklog(body, p).length) return p;
@@ -1184,7 +1455,7 @@ async function startFeatureFromBacklog(input) {
   const stage = ctx.workflow.stages.find((s) => s.id === ctx.meta.stage);
   const art = stage?.artifacts.find((a) => a.required) ?? stage?.artifacts[0];
   if (art) {
-    const artPath = join4(ctx.path, art.path);
+    const artPath = join6(ctx.path, art.path);
     if (await pathExists(artPath)) {
       let body = await readText(artPath);
       if (!isSubstantiveArtifactContent(body)) {
@@ -1240,11 +1511,11 @@ async function promoteGreenfieldToMemory(projectRoot, config, changeId) {
   ];
   const written = [];
   for (const { from, to } of map) {
-    const src = join4(dir, from);
+    const src = join6(dir, from);
     if (!await pathExists(src)) continue;
     const body = await readText(src);
     if (!isSubstantiveArtifactContent(body)) continue;
-    const dest = join4(mem, to);
+    const dest = join6(mem, to);
     await writeText(
       dest,
       body.includes("Promoted from greenfield") ? body : `${body.trim()}
@@ -1254,9 +1525,9 @@ async function promoteGreenfieldToMemory(projectRoot, config, changeId) {
 _Promoted from greenfield change \`${changeId}\`._
 `
     );
-    written.push(join4(config.memory_path, to));
+    written.push(join6(config.memory_path, to));
   }
-  const indexPath = join4(mem, "index.md");
+  const indexPath = join6(mem, "index.md");
   if (await pathExists(indexPath)) {
     let index = await readText(indexPath);
     if (!index.includes("features.md")) {
@@ -1274,14 +1545,18 @@ _Promoted from greenfield change \`${changeId}\`._
 export {
   PhaseMetricSchema,
   TokenUsageMetricSchema,
+  DecisionMetricSchema,
   ChangeMetricsSchema,
   emptyChangeMetrics,
   readChangeMetrics,
+  recordDecisionMetric,
   startPhase,
   transitionPhase,
   assertSessionLogAllowed,
   importSessionMetrics,
   isSubstantiveArtifactContent,
+  recordSignoff,
+  recordDecisionRequest,
   incompletePriorStageErrors,
   canLeaveStage,
   fallbackIncompleteStageId,

package/dist/{chunk-QGP43XCN.js → chunk-H55RFAEI.js}

@@ -26,7 +26,7 @@ function toProcessEnv(base, extra) {
 }
 
 // src/version.ts
-var SDD_CORE_VERSION = "0.18.0" ? "0.18.0" : "0.0.0-dev";
+var SDD_CORE_VERSION = "0.19.0" ? "0.19.0" : "0.0.0-dev";
 
 // src/mcp/client.ts
 function mcpTimeoutMs() {