@structured-vibe-coding/core 0.9.1 → 0.10.1

package/dist/{chunk-M245MC6E.js → chunk-UAOFNSLQ.js}

@@ -1,287 +1,30 @@
-// src/agents.ts
-import { join as join4 } from "pathe";
-
-// src/fs.ts
-import { promises as fs } from "fs";
-import { dirname } from "pathe";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-async function pathExists(path) {
-  try {
-    await fs.access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function ensureDir(path) {
-  await fs.mkdir(path, { recursive: true });
-}
-async function readText(path) {
-  return fs.readFile(path, "utf8");
-}
-async function writeText(path, content) {
-  await ensureDir(dirname(path));
-  await fs.writeFile(path, content, "utf8");
-}
-async function readYaml(path) {
-  const raw = await readText(path);
-  return parseYaml(raw);
-}
-async function writeYaml(path, data) {
-  const content = stringifyYaml(data, {
-    lineWidth: 100,
-    defaultStringType: "PLAIN",
-    defaultKeyType: "PLAIN"
-  });
-  await writeText(path, content.endsWith("\n") ? content : `${content}
-`);
-}
-async function listDirs(path) {
-  if (!await pathExists(path)) return [];
-  const entries = await fs.readdir(path, { withFileTypes: true });
-  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-}
-async function listFiles(path) {
-  if (!await pathExists(path)) return [];
-  const entries = await fs.readdir(path, { withFileTypes: true });
-  return entries.filter((e) => e.isFile()).map((e) => e.name);
-}
-async function copyDir(src, dest) {
-  await ensureDir(dest);
-  const entries = await fs.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const from = `${src}/${entry.name}`;
-    const to = `${dest}/${entry.name}`;
-    if (entry.isDirectory()) {
-      await copyDir(from, to);
-    } else {
-      await ensureDir(dirname(to));
-      await fs.copyFile(from, to);
-    }
-  }
-}
-async function copyDirSkipExisting(src, dest) {
-  await ensureDir(dest);
-  const entries = await fs.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const from = `${src}/${entry.name}`;
-    const to = `${dest}/${entry.name}`;
-    if (entry.isDirectory()) {
-      await copyDirSkipExisting(from, to);
-    } else if (!await pathExists(to)) {
-      await ensureDir(dirname(to));
-      await fs.copyFile(from, to);
-    }
-  }
-}
-async function writeTextIfMissing(path, content) {
-  if (await pathExists(path)) return false;
-  await writeText(path, content);
-  return true;
-}
-async function removePath(path) {
-  await fs.rm(path, { recursive: true, force: true });
-}
-
-// src/schemas.ts
-import { z } from "zod";
-var GateSchema = z.object({
-  type: z.enum(["none", "soft", "hard"]).default("soft"),
-  mode: z.enum(["none", "human_approval", "checklist"]).default("checklist"),
-  checklist: z.array(z.string()).default([]),
-  overridable: z.boolean().default(true)
-});
-var ArtifactDefSchema = z.object({
-  id: z.string(),
-  path: z.string(),
-  template: z.string().optional(),
-  required: z.boolean().default(true)
-});
-var VerifyCommandSchema = z.object({
-  name: z.string(),
-  run: z.string(),
-  required: z.boolean().default(false)
-});
-var StageSchema = z.object({
-  id: z.string(),
-  title: z.string().optional(),
-  summary: z.string().optional(),
-  /**
-   * standard — normal work stage
-   * brainstorm — optional multi-approach exploration (before design)
-   * clarify — optional Q&A before leaving a major stage
-   */
-  kind: z.enum(["standard", "brainstorm", "clarify"]).default("standard"),
-  /** When true, stage is optional (skippable); agents may skip if not needed */
-  optional: z.boolean().default(false),
-  artifacts: z.array(ArtifactDefSchema).default([]),
-  gate: GateSchema.default({}),
-  skippable: z.boolean().default(true),
-  skip_when: z.object({
-    flags: z.array(z.string()).optional()
-  }).optional(),
-  verify: z.object({
-    commands: z.array(VerifyCommandSchema).default([]),
-    evidence_dir: z.string().optional()
-  }).optional(),
-  agent_context: z.object({
-    include: z.array(z.string()).default([]),
-    instructions: z.string().optional()
-  }).optional()
-});
-var WorkflowSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  version: z.number().default(1),
-  stages: z.array(StageSchema).min(1),
-  recommendation: z.object({
-    when: z.object({
-      labels: z.array(z.string()).optional(),
-      keywords: z.array(z.string()).optional(),
-      max_complexity: z.enum(["low", "medium", "high"]).optional(),
-      min_complexity: z.enum(["low", "medium", "high"]).optional()
-    }).optional(),
-    priority: z.number().default(0)
-  }).optional(),
-  on_complete: z.object({
-    archive: z.boolean().default(false),
-    domain_sync: z.enum(["never", "recommend", "require"]).default("never")
-  }).optional()
-});
-var ConfigSchema = z.object({
-  version: z.number().default(1),
-  memory_path: z.string().default("memory"),
-  changes_path: z.string().default("changes"),
-  archive_path: z.string().default("archive"),
-  domains_path: z.string().default("domains"),
-  default_workflow: z.string().default("recommend"),
-  allowed_workflows: z.array(z.string()).optional(),
-  per_change: z.object({
-    allow_skip: z.boolean().default(true),
-    allow_gate_override: z.enum(["true", "false", "soft_only"]).default("soft_only"),
-    allow_custom_stages: z.boolean().default(true),
-    require_reason_on_skip: z.boolean().default(true)
-  }).default({}),
-  persistence: z.object({
-    default: z.enum(["change_only", "domain_sync"]).default("change_only"),
-    archive_on_complete: z.boolean().default(false),
-    domain_sync: z.object({
-      mode: z.enum(["never", "recommend", "require"]).default("never"),
-      anchored_domains: z.array(z.string()).default([])
-    }).default({})
-  }).default({}),
-  policy: z.object({
-    gates: z.enum(["soft", "hard"]).default("soft")
-  }).default({})
-});
-var ChangeMetaSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  workflow: z.string(),
-  created: z.string(),
-  updated: z.string().optional(),
-  status: z.enum(["in_progress", "blocked", "completed", "abandoned"]).default("in_progress"),
-  stage: z.string(),
-  branch: z.string().optional(),
-  domain: z.string().optional(),
-  flags: z.record(z.union([z.boolean(), z.string(), z.number()])).default({}),
-  overrides: z.object({
-    skip_stages: z.array(z.string()).default([]),
-    gates: z.record(z.enum(["none", "soft", "hard"])).default({}),
-    extra_stages: z.array(StageSchema).default([])
-  }).default({}),
-  skipped: z.array(
-    z.object({
-      stage: z.string(),
-      reason: z.string(),
-      at: z.string()
-    })
-  ).default([]),
-  gates: z.record(
-    z.object({
-      status: z.enum(["pending", "approved", "failed", "waived"]),
-      note: z.string().optional(),
-      at: z.string().optional()
-    })
-  ).default({}),
-  /** Results from `sdd verify` keyed by stage id */
-  verify_results: z.record(
-    z.object({
-      ok: z.boolean(),
-      at: z.string(),
-      results: z.array(
-        z.object({
-          name: z.string(),
-          exitCode: z.number().nullable()
-        })
-      ).default([])
-    })
-  ).default({}),
-  pr: z.object({
-    number: z.number().optional(),
-    url: z.string().optional()
-  }).optional(),
-  completed_at: z.string().optional()
-});
-
-// src/paths.ts
-import { join } from "pathe";
-var SDD_DIR = ".sdd";
-function sddRoot(projectRoot) {
-  return join(projectRoot, SDD_DIR);
-}
-function configPath(projectRoot) {
-  return join(sddRoot(projectRoot), "config.yaml");
-}
-function workflowsDir(projectRoot) {
-  return join(sddRoot(projectRoot), "workflows");
-}
-function templatesDir(projectRoot) {
-  return join(sddRoot(projectRoot), "templates");
-}
-function memoryDir(projectRoot, config) {
-  return join(projectRoot, config.memory_path);
-}
-function changesDir(projectRoot, config) {
-  return join(projectRoot, config.changes_path);
-}
-function archiveDir(projectRoot, config) {
-  return join(projectRoot, config.archive_path);
-}
-function domainsDir(projectRoot, config) {
-  return join(projectRoot, config.domains_path);
-}
-function changePath(projectRoot, config, changeId) {
-  return join(changesDir(projectRoot, config), changeId);
-}
-function changeMetaPath(projectRoot, config, changeId) {
-  return join(changePath(projectRoot, config, changeId), "meta.yaml");
-}
-function activePointerPath(projectRoot, config) {
-  return join(changesDir(projectRoot, config), ".active");
-}
+import {
+  ChangeMetaSchema,
+  WorkflowSchema,
+  loadConfig
+} from "./chunk-KZHNYGD6.js";
+import {
+  activePointerPath,
+  changeMetaPath,
+  changePath,
+  changesDir,
+  sddRoot,
+  workflowsDir
+} from "./chunk-7MJYPJMR.js";
+import {
+  ensureDir,
+  listDirs,
+  listFiles,
+  pathExists,
+  readText,
+  readYaml,
+  removePath,
+  writeText,
+  writeYaml
+} from "./chunk-EPFURATC.js";
 
-// src/config.ts
-async function isInitialized(projectRoot) {
-  return pathExists(configPath(projectRoot));
-}
-async function loadConfig(projectRoot) {
-  const path = configPath(projectRoot);
-  if (!await pathExists(path)) {
-    throw new Error(
-      `SDD is not initialized in ${projectRoot}. Run \`sdd init\` first.`
-    );
-  }
-  const raw = await readYaml(path);
-  return ConfigSchema.parse(raw);
-}
-async function saveConfig(projectRoot, config) {
-  await ensureDir(sddRoot(projectRoot));
-  await writeYaml(configPath(projectRoot), ConfigSchema.parse(config));
-}
-function defaultConfig() {
-  return ConfigSchema.parse({});
-}
+// src/agents.ts
+import { join as join3 } from "pathe";
 
 // src/slug.ts
 function slugify(input) {
@@ -305,7 +48,7 @@ function uniqueChangeDirName(base, taken) {
 }
 
 // src/workflow.ts
-import { join as join2 } from "pathe";
+import { join } from "pathe";
 async function listWorkflowNames(projectRoot) {
   const dir = workflowsDir(projectRoot);
   const files = await listFiles(dir);
@@ -315,7 +58,7 @@ async function loadWorkflow(projectRoot, name) {
   const dir = workflowsDir(projectRoot);
   const candidates = [`${name}.yaml`, `${name}.yml`];
   for (const file of candidates) {
-    const path = join2(dir, file);
+    const path = join(dir, file);
     if (await pathExists(path)) {
       const raw = await readYaml(path);
       const workflow = WorkflowSchema.parse(raw);
@@ -553,7 +296,7 @@ async function resolveChangeId(projectRoot, config, changeId) {
 }
 
 // src/agent-handoff.ts
-import { join as join3 } from "pathe";
+import { join as join2 } from "pathe";
 function formatStatus(ctx) {
   const lines = [];
   lines.push(`Change: ${ctx.meta.title}`);
@@ -621,12 +364,12 @@ async function buildAgentPrompt(ctx, config, projectRoot) {
   parts.push(`- Prefer small, reviewable commits.`);
   parts.push("");
   parts.push(`## Artifacts to read`);
-  const memoryHint = join3(projectRoot, config.memory_path);
+  const memoryHint = join2(projectRoot, config.memory_path);
   parts.push(`- Documentation map (if present): ${memoryHint}/index.md`);
   parts.push(`- Memory: ${memoryHint}/`);
   for (const s of ctx.stages) {
     for (const a of s.artifacts) {
-      parts.push(`- ${join3(ctx.path, a.path)}`);
+      parts.push(`- ${join2(ctx.path, a.path)}`);
     }
   }
   parts.push("");
@@ -637,6 +380,27 @@ async function buildAgentPrompt(ctx, config, projectRoot) {
     }
   }
   parts.push("");
+  const stageId = ctx.meta.stage;
+  if (stageId === "implement" || stageId === "local_verify") {
+    parts.push(`## Code context (product code)`);
+    parts.push("");
+    parts.push(
+      `Process context above is not enough for product code structure.`
+    );
+    parts.push(
+      `When you need symbols, callers, or package-boundary context:`
+    );
+    parts.push(
+      `1. Run: \`sdd context\` (optional: \`--path \u2026\`, \`--symbol \u2026\`, \`--out change\`)`
+    );
+    parts.push(
+      `2. If present, read: \`changes/${ctx.id}/code-context.md\` (regenerate if stale)`
+    );
+    parts.push(
+      `Do not dump unbounded source into the prompt; prefer the sliced output.`
+    );
+    parts.push("");
+  }
   parts.push(
     `When done with this stage, the human will run \`sdd next\` or \`sdd verify\` / \`sdd complete\`.`
   );
@@ -732,7 +496,7 @@ async function removeOtherAgentHosts(projectRoot, keep) {
   for (const integ of AGENT_INTEGRATIONS) {
     if (integ.id === keep) continue;
     for (const rel of agentHostPaths(integ.id)) {
-      const full = join4(projectRoot, rel);
+      const full = join3(projectRoot, rel);
       if (await pathExists(full)) {
         await removePath(full);
         removed.push(rel);
@@ -740,7 +504,7 @@ async function removeOtherAgentHosts(projectRoot, keep) {
     }
   }
   for (const rel of LEGACY_AGENT_PATHS) {
-    const full = join4(projectRoot, rel);
+    const full = join3(projectRoot, rel);
     if (await pathExists(full)) {
       await removePath(full);
       removed.push(rel);
@@ -748,7 +512,7 @@ async function removeOtherAgentHosts(projectRoot, keep) {
   }
   for (const parent of [".claude", ".idea", ".grok"]) {
     if (keep === "grok" && parent === ".grok") continue;
-    const full = join4(projectRoot, parent);
+    const full = join3(projectRoot, parent);
     if (!await pathExists(full)) continue;
     try {
       const { readdir } = await import("fs/promises");
@@ -803,7 +567,8 @@ var SDD_AGENT_ROLES = [
     roleRules: [
       "If stage is intent/feature/design/tasks/stories/research: act as planner (artifacts, little or no product code).",
       "If stage is implement: act as implementer (scoped code only).",
-      "If stage is local_verify: act as reviewer (gaps vs acceptance; fixes only)."
+      "If stage is local_verify: act as reviewer (gaps vs acceptance; fixes only).",
+      "If kickoff/brief says refine or analyze: follow changes/<id>/refine-brief.md \u2014 stage-scoped refine; never edit constitution; do not sdd next."
     ]
   },
   {
@@ -842,7 +607,7 @@ async function installAgentIntegration(opts) {
   const force = opts.force ?? false;
   await removeOtherAgentHosts(root, opts.target);
   const write = async (rel, content) => {
-    const full = join4(root, rel);
+    const full = join3(root, rel);
     if (await pathExists(full) && !force) {
       skipped.push(rel);
       return;
@@ -850,7 +615,7 @@ async function installAgentIntegration(opts) {
     await writeText(full, content);
     created.push(rel);
   };
-  await write(join4(".sdd", "protocol.md"), PROTOCOL_MD);
+  await write(join3(".sdd", "protocol.md"), PROTOCOL_MD);
   await refreshActiveAgentContext(root);
   const roles = integ.rolesToInstall?.length ? SDD_AGENT_ROLES.filter((r) => integ.rolesToInstall.includes(r.id)) : SDD_AGENT_ROLES;
   for (const role of roles) {
@@ -858,7 +623,7 @@ async function installAgentIntegration(opts) {
   }
   await write("AGENTS.md", renderAgentsMd(integ));
   await write(
-    join4(".sdd", "agents.json"),
+    join3(".sdd", "agents.json"),
     JSON.stringify(
       {
         version: 3,
@@ -926,7 +691,7 @@ Do not claim the change is complete without local verification when the workflow
 `;
 }
 async function loadInstalledAgent(projectRoot) {
-  const path = join4(sddRoot(projectRoot), "agents.json");
+  const path = join3(sddRoot(projectRoot), "agents.json");
   if (!await pathExists(path)) return null;
   try {
     const raw = JSON.parse(await readText(path));
@@ -941,7 +706,7 @@ async function loadInstalledAgent(projectRoot) {
 async function writeAgentHandoff(projectRoot, config, changeId) {
   const ctx = await buildContext(projectRoot, config, changeId);
   const body = await buildAgentPrompt(ctx, config, projectRoot);
-  const outPath = join4(sddRoot(projectRoot), "handoff.md");
+  const outPath = join3(sddRoot(projectRoot), "handoff.md");
   const header = `# SDD handoff (auto)
 
 > Generated for the AI coding agent configured at init.  
@@ -957,6 +722,15 @@ Also read: \`.sdd/active-context.md\`, \`.sdd/protocol.md\`, \`memory/constituti
 }
 function agentKickoffMessage(opts) {
   const event = opts.event ?? "context updated";
+  if (opts.instructions?.trim()) {
+    return [
+      `SDD: ${event}.`,
+      `Title: ${opts.title}`,
+      `Change: ${opts.changeId}`,
+      `Stage: ${opts.stage}`,
+      opts.instructions.trim()
+    ].join(" ");
+  }
   return [
     `SDD: ${event}.`,
     `Title: ${opts.title}`,
@@ -969,16 +743,16 @@ function agentKickoffMessage(opts) {
 }
 async function refreshActiveAgentContext(projectRoot) {
   const markerDir = sddRoot(projectRoot);
-  if (!await pathExists(join4(markerDir, "config.yaml"))) {
+  if (!await pathExists(join3(markerDir, "config.yaml"))) {
     return null;
   }
-  const protocolPath = join4(markerDir, "protocol.md");
+  const protocolPath = join3(markerDir, "protocol.md");
   if (!await pathExists(protocolPath)) {
     await writeText(protocolPath, PROTOCOL_MD);
   }
   const config = await loadConfig(projectRoot);
   const activeId = await getActiveChangeId(projectRoot, config);
-  const outPath = join4(markerDir, "active-context.md");
+  const outPath = join3(markerDir, "active-context.md");
   if (!activeId) {
     const empty = `# SDD active context
 
@@ -1101,41 +875,6 @@ Refresh context: \`sdd agents refresh\`.
 }
 
 export {
-  GateSchema,
-  ArtifactDefSchema,
-  VerifyCommandSchema,
-  StageSchema,
-  WorkflowSchema,
-  ConfigSchema,
-  ChangeMetaSchema,
-  SDD_DIR,
-  sddRoot,
-  configPath,
-  workflowsDir,
-  templatesDir,
-  memoryDir,
-  changesDir,
-  archiveDir,
-  domainsDir,
-  changePath,
-  changeMetaPath,
-  activePointerPath,
-  pathExists,
-  ensureDir,
-  readText,
-  writeText,
-  readYaml,
-  writeYaml,
-  listDirs,
-  listFiles,
-  copyDir,
-  copyDirSkipExisting,
-  writeTextIfMissing,
-  removePath,
-  isInitialized,
-  loadConfig,
-  saveConfig,
-  defaultConfig,
   listWorkflowNames,
   loadWorkflow,
   resolveStages,

package/dist/config-4QZMRSL3.js

@@ -0,0 +1,14 @@
+import {
+  defaultConfig,
+  isInitialized,
+  loadConfig,
+  saveConfig
+} from "./chunk-KZHNYGD6.js";
+import "./chunk-7MJYPJMR.js";
+import "./chunk-EPFURATC.js";
+export {
+  defaultConfig,
+  isInitialized,
+  loadConfig,
+  saveConfig
+};

package/dist/fs-J6DIV6CX.js

@@ -0,0 +1,28 @@
+import {
+  copyDir,
+  copyDirSkipExisting,
+  ensureDir,
+  listDirs,
+  listFiles,
+  pathExists,
+  readText,
+  readYaml,
+  removePath,
+  writeText,
+  writeTextIfMissing,
+  writeYaml
+} from "./chunk-EPFURATC.js";
+export {
+  copyDir,
+  copyDirSkipExisting,
+  ensureDir,
+  listDirs,
+  listFiles,
+  pathExists,
+  readText,
+  readYaml,
+  removePath,
+  writeText,
+  writeTextIfMissing,
+  writeYaml
+};