opencode-swarm 7.123.0 → 7.125.0

package/dist/cli/index-mg54y5gc.js

@@ -0,0 +1,564 @@
+// @bun
+// src/background/workspace-snapshot.ts
+import * as child_process from "child_process";
+import { createHash } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var GIT_SNAPSHOT_TIMEOUT_MS = 3000;
+var GIT_SNAPSHOT_MAX_BUFFER = 512 * 1024;
+var REVISION_MAX_FILES = 5000;
+var REVISION_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+var REVISION_READ_CHUNK_BYTES = 64 * 1024;
+var REVISION_YIELD_EVERY_CHUNKS = 16;
+function runGit(directory, args, timeoutMs = GIT_SNAPSHOT_TIMEOUT_MS) {
+  const result = _internals.spawnSync("git", ["-C", directory, ...args], {
+    cwd: directory,
+    encoding: "utf-8",
+    timeout: timeoutMs,
+    maxBuffer: GIT_SNAPSHOT_MAX_BUFFER,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.error || result.status !== 0)
+    return null;
+  return typeof result.stdout === "string" ? result.stdout.trimEnd() : null;
+}
+async function runGitAsync(directory, args, timeoutMs = GIT_SNAPSHOT_TIMEOUT_MS) {
+  return await new Promise((resolve2) => {
+    let settled = false;
+    let stdout = "";
+    let stderrBytes = 0;
+    let timeout;
+    let child;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timeout)
+        clearTimeout(timeout);
+      try {
+        child?.kill();
+      } catch {}
+      resolve2(value);
+    };
+    try {
+      child = child_process.spawn("git", ["-C", directory, ...args], {
+        cwd: directory,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true
+      });
+    } catch {
+      finish(null);
+      return;
+    }
+    timeout = setTimeout(() => finish(null), timeoutMs);
+    child.stdout?.setEncoding("utf-8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+      if (Buffer.byteLength(stdout, "utf-8") > GIT_SNAPSHOT_MAX_BUFFER) {
+        finish(null);
+      }
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderrBytes += chunk.length;
+      if (stderrBytes > GIT_SNAPSHOT_MAX_BUFFER) {
+        finish(null);
+      }
+    });
+    child.once("error", () => finish(null));
+    child.once("close", (code) => finish(code === 0 ? stdout.trimEnd() : null));
+  });
+}
+function readGitTextAtRevision(directory, revision, relativePath) {
+  if (!isSafeGitRevisionToken(revision) || !/^\.?(?:[A-Za-z0-9][A-Za-z0-9._-]*\/)*[A-Za-z0-9][A-Za-z0-9._-]*$/.test(relativePath) || relativePath.split("/").includes("..")) {
+    return null;
+  }
+  const result = _internals.spawnSync("git", ["-C", directory, "show", `${revision}:${relativePath}`], {
+    cwd: directory,
+    encoding: "utf-8",
+    timeout: GIT_SNAPSHOT_TIMEOUT_MS,
+    maxBuffer: GIT_SNAPSHOT_MAX_BUFFER,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.error || result.status !== 0 || typeof result.stdout !== "string")
+    return null;
+  return result.stdout;
+}
+function resolveCurrentGitHead(directory) {
+  return runGit(directory, ["rev-parse", "--verify", "HEAD^{commit}"]);
+}
+function resolveExactMergeBase(directory, baseRef, prHeadSha) {
+  if (!isSafeGitRevisionToken(baseRef) || !isSafeGitRevisionToken(prHeadSha))
+    return null;
+  const mergeBase = runGit(directory, ["merge-base", "--", baseRef, prHeadSha]);
+  return mergeBase && /^[0-9a-f]{6,64}$/i.test(mergeBase) ? mergeBase : null;
+}
+function isSafeGitRevisionToken(value) {
+  return /^(?!-)[A-Za-z0-9][A-Za-z0-9._/-]{0,255}$/.test(value) && !value.includes("..") && !value.includes("//") && !value.includes("@{");
+}
+function resolveCurrentUpstreamRemoteRef(directory) {
+  const upstream = runGit(directory, [
+    "rev-parse",
+    "--symbolic-full-name",
+    "@{upstream}"
+  ]);
+  if (!upstream?.startsWith("refs/remotes/") || upstream.endsWith("/HEAD")) {
+    return null;
+  }
+  return upstream;
+}
+function resolveCurrentUpstreamPushTarget(directory) {
+  const localBranchRef = runGit(directory, ["symbolic-ref", "--quiet", "HEAD"]);
+  if (!localBranchRef?.startsWith("refs/heads/"))
+    return null;
+  const encoded = runGit(directory, [
+    "for-each-ref",
+    "--format=%(upstream:remotename)%00%(upstream:remoteref)%00%(upstream)",
+    localBranchRef
+  ]);
+  if (!encoded)
+    return null;
+  const [remoteName, remoteBranchRef, remoteTrackingRef, ...extras] = encoded.split("\x00");
+  if (extras.length > 0 || !remoteName || remoteName.startsWith("-") || /[\s;&|<>`]/.test(remoteName) || !remoteBranchRef?.startsWith("refs/heads/") || remoteBranchRef === "refs/heads/" || /[\s;&|<>`]/.test(remoteBranchRef) || !remoteTrackingRef?.startsWith("refs/remotes/") || remoteTrackingRef.endsWith("/HEAD")) {
+    return null;
+  }
+  return { remoteName, remoteBranchRef, remoteTrackingRef };
+}
+function resolveExactRemoteBranchHead(directory, remoteName, remoteBranchRef) {
+  if (!remoteName || remoteName.startsWith("-") || /[\s;&|<>`]/.test(remoteName) || !remoteBranchRef.startsWith("refs/heads/") || remoteBranchRef === "refs/heads/" || /[\s;&|<>`]/.test(remoteBranchRef)) {
+    return null;
+  }
+  const output = runGit(directory, ["ls-remote", "--exit-code", "--heads", remoteName, remoteBranchRef], 20000);
+  if (!output)
+    return null;
+  const rows = output.split(/\r?\n/).filter(Boolean);
+  if (rows.length !== 1)
+    return null;
+  const [objectName, refName, ...extras] = rows[0].split(/\s+/);
+  if (extras.length > 0 || refName !== remoteBranchRef || !objectName || !(/^[0-9a-f]{40}$/i.test(objectName) || /^[0-9a-f]{64}$/i.test(objectName))) {
+    return null;
+  }
+  return objectName;
+}
+function resolveGitControlStateDigest(directory) {
+  const head = runGit(directory, ["rev-parse", "--verify", "HEAD^{commit}"]);
+  const symbolicHead = runGit(directory, ["symbolic-ref", "--quiet", "HEAD"]);
+  const upstream = resolveCurrentUpstreamPushTarget(directory);
+  const refs = runGit(directory, [
+    "for-each-ref",
+    "--format=%(refname)%00%(objectname)",
+    "refs/heads",
+    "refs/remotes",
+    "refs/tags"
+  ]);
+  const config = runGit(directory, [
+    "config",
+    "--null",
+    "--show-origin",
+    "--show-scope",
+    "--list"
+  ]);
+  const index = runGit(directory, ["ls-files", "--stage", "-z"]);
+  if (head === null || symbolicHead === null || !upstream || refs === null || config === null || index === null) {
+    return null;
+  }
+  return digest(`head\x00${head}\x00symbolic\x00${symbolicHead}\x00upstream\x00${upstream.remoteName}\x00${upstream.remoteBranchRef}\x00${upstream.remoteTrackingRef}\x00refs\x00${refs}\x00config\x00${config}\x00index\x00${index}`);
+}
+function resolveIsWorkingTreeClean(directory) {
+  const status = runGit(directory, [
+    "status",
+    "--porcelain=v1",
+    "--untracked-files=all"
+  ]);
+  return status === null ? null : status.length === 0;
+}
+function resolveCommitCountSince(directory, baseHeadSha, currentHeadSha) {
+  const output = runGit(directory, [
+    "rev-list",
+    "--count",
+    "--ancestry-path",
+    `${baseHeadSha}..${currentHeadSha}`
+  ]);
+  if (!output || !/^\d+$/.test(output))
+    return null;
+  const count = Number(output);
+  return Number.isSafeInteger(count) ? count : null;
+}
+function resolveIsExactSingleChildCommit(directory, baseHeadSha, currentHeadSha) {
+  const base = runGit(directory, [
+    "rev-parse",
+    "--verify",
+    `${baseHeadSha}^{commit}`
+  ]);
+  const current = runGit(directory, [
+    "rev-parse",
+    "--verify",
+    `${currentHeadSha}^{commit}`
+  ]);
+  if (!base || !current)
+    return null;
+  const commitAndParents = runGit(directory, [
+    "rev-list",
+    "--parents",
+    "-n",
+    "1",
+    current
+  ]);
+  if (commitAndParents === null)
+    return null;
+  const fields = commitAndParents.trim().split(/\s+/);
+  return fields.length === 2 && fields[0]?.toLowerCase() === current.toLowerCase() && fields[1]?.toLowerCase() === base.toLowerCase();
+}
+function resolveRemoteRefsContainingHead(directory, headSha) {
+  const output = runGit(directory, [
+    "for-each-ref",
+    "--format=%(refname)%09%(objectname)",
+    "refs/remotes"
+  ]);
+  if (output === null)
+    return null;
+  return output.split(/\r?\n/).map((line) => line.trim().split("\t")).filter(([ref, objectName]) => ref?.startsWith("refs/remotes/") && !ref.endsWith("/HEAD") && objectName?.toLowerCase() === headSha.toLowerCase()).map(([ref]) => ref);
+}
+function resolvePrWorkflowRevisionDigest(directory, baseHeadSha) {
+  const projectRoot = path.resolve(directory);
+  const baseHead = runGit(projectRoot, [
+    "rev-parse",
+    "--verify",
+    `${baseHeadSha}^{commit}`
+  ]);
+  const diffNames = runGit(projectRoot, [
+    "diff",
+    "--no-ext-diff",
+    "--name-only",
+    "-z",
+    baseHeadSha
+  ]);
+  const porcelain = runGit(projectRoot, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all"
+  ]);
+  if (!baseHead || diffNames === null || porcelain === null)
+    return null;
+  const porcelainPaths = parsePorcelainPaths(porcelain);
+  if (!porcelainPaths)
+    return null;
+  const changedPaths = [
+    ...new Set([...parseNulPaths(diffNames), ...porcelainPaths])
+  ].sort((left, right) => left.localeCompare(right));
+  if (changedPaths.length > REVISION_MAX_FILES)
+    return null;
+  const hash = createHash("sha256");
+  hash.update(`base\x00${baseHead}\x00`);
+  let totalBytes = 0;
+  for (const relativePath of changedPaths) {
+    const resolvedPath = path.resolve(projectRoot, relativePath);
+    const relativeToRoot = path.relative(projectRoot, resolvedPath);
+    if (!relativeToRoot || relativeToRoot.startsWith("..") || path.isAbsolute(relativeToRoot))
+      return null;
+    hash.update(`path\x00${relativePath}\x00`);
+    let stats;
+    try {
+      stats = fs.lstatSync(resolvedPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        hash.update("deleted\x00");
+        continue;
+      }
+      return null;
+    }
+    if (stats.isSymbolicLink()) {
+      try {
+        hash.update(`symlink\x00${fs.readlinkSync(resolvedPath)}\x00`);
+        continue;
+      } catch {
+        return null;
+      }
+    }
+    if (!stats.isFile()) {
+      hash.update(`node\x00${stats.mode}\x00`);
+      continue;
+    }
+    totalBytes += stats.size;
+    if (totalBytes > REVISION_MAX_TOTAL_BYTES)
+      return null;
+    try {
+      hash.update(`file\x00${stats.mode}\x00`);
+      hash.update(fs.readFileSync(resolvedPath));
+      hash.update("\x00");
+    } catch {
+      return null;
+    }
+  }
+  return hash.digest("hex");
+}
+async function resolvePrWorkflowRevisionDigestAsync(directory, baseHeadSha) {
+  const projectRoot = path.resolve(directory);
+  const [baseHead, diffNames, porcelain] = await Promise.all([
+    runGitAsync(projectRoot, [
+      "rev-parse",
+      "--verify",
+      `${baseHeadSha}^{commit}`
+    ]),
+    runGitAsync(projectRoot, [
+      "diff",
+      "--no-ext-diff",
+      "--name-only",
+      "-z",
+      baseHeadSha
+    ]),
+    runGitAsync(projectRoot, [
+      "status",
+      "--porcelain=v1",
+      "-z",
+      "--untracked-files=all"
+    ])
+  ]);
+  if (!baseHead || diffNames === null || porcelain === null)
+    return null;
+  const porcelainPaths = parsePorcelainPaths(porcelain);
+  if (!porcelainPaths)
+    return null;
+  const changedPaths = [
+    ...new Set([...parseNulPaths(diffNames), ...porcelainPaths])
+  ].sort((left, right) => left.localeCompare(right));
+  if (changedPaths.length > REVISION_MAX_FILES)
+    return null;
+  const hash = createHash("sha256");
+  hash.update(`base\x00${baseHead}\x00`);
+  let totalBytes = 0;
+  let chunksSinceYield = 0;
+  for (const relativePath of changedPaths) {
+    const resolvedPath = path.resolve(projectRoot, relativePath);
+    const relativeToRoot = path.relative(projectRoot, resolvedPath);
+    if (!relativeToRoot || relativeToRoot.startsWith("..") || path.isAbsolute(relativeToRoot))
+      return null;
+    hash.update(`path\x00${relativePath}\x00`);
+    let stats;
+    try {
+      stats = await fs.promises.lstat(resolvedPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        hash.update("deleted\x00");
+        continue;
+      }
+      return null;
+    }
+    if (stats.isSymbolicLink()) {
+      try {
+        hash.update(`symlink\x00${await fs.promises.readlink(resolvedPath)}\x00`);
+        continue;
+      } catch {
+        return null;
+      }
+    }
+    if (!stats.isFile()) {
+      hash.update(`node\x00${stats.mode}\x00`);
+      continue;
+    }
+    totalBytes += stats.size;
+    if (totalBytes > REVISION_MAX_TOTAL_BYTES)
+      return null;
+    hash.update(`file\x00${stats.mode}\x00`);
+    let handle;
+    try {
+      handle = await fs.promises.open(resolvedPath, "r");
+      const buffer = Buffer.allocUnsafe(REVISION_READ_CHUNK_BYTES);
+      for (let position = 0;position < stats.size; ) {
+        const length = Math.min(REVISION_READ_CHUNK_BYTES, stats.size - position);
+        const { bytesRead } = await handle.read(buffer, 0, length, position);
+        if (bytesRead <= 0)
+          return null;
+        hash.update(buffer.subarray(0, bytesRead));
+        position += bytesRead;
+        chunksSinceYield++;
+        if (chunksSinceYield >= REVISION_YIELD_EVERY_CHUNKS) {
+          chunksSinceYield = 0;
+          await _internals.yieldControl();
+        }
+      }
+      hash.update("\x00");
+    } catch {
+      return null;
+    } finally {
+      await handle?.close().catch(() => {
+        return;
+      });
+    }
+  }
+  return hash.digest("hex");
+}
+function parseNulPaths(output) {
+  return output.split("\x00").filter((entry) => entry.length > 0);
+}
+function parsePorcelainPaths(output) {
+  const entries = parseNulPaths(output);
+  const paths = [];
+  for (let index = 0;index < entries.length; index++) {
+    const entry = entries[index];
+    if (entry.length < 4 || entry[2] !== " ")
+      return null;
+    const status = entry.slice(0, 2);
+    const changedPath = entry.slice(3);
+    if (!changedPath)
+      return null;
+    paths.push(changedPath);
+    if (status.includes("R") || status.includes("C")) {
+      const originalPath = entries[++index];
+      if (!originalPath)
+        return null;
+      paths.push(originalPath);
+    }
+  }
+  return [...new Set(paths)];
+}
+function parsePorcelainV2Snapshot(output) {
+  const records = output.split("\x00");
+  const headers = [];
+  while (records[0]?.startsWith("# ")) {
+    headers.push(records.shift());
+  }
+  const oidMatch = headers.join(`
+`).match(/^# branch\.oid (.+)$/m);
+  if (!oidMatch)
+    return null;
+  const gitHead = /^[0-9a-f]{6,64}$/i.test(oidMatch[1]) ? oidMatch[1] : oidMatch[1] === "(initial)" ? null : null;
+  const paths = [];
+  for (let index = 0;index < records.length; index++) {
+    const record = records[index];
+    if (!record)
+      continue;
+    if (record.startsWith("? ")) {
+      paths.push(record.slice(2));
+      continue;
+    }
+    if (record.startsWith("1 ")) {
+      const changedPath = porcelainV2PathAfterFields(record, 8);
+      if (!changedPath)
+        return null;
+      paths.push(changedPath);
+      continue;
+    }
+    if (record.startsWith("2 ")) {
+      const changedPath = porcelainV2PathAfterFields(record, 9);
+      const originalPath = records[++index];
+      if (!changedPath || !originalPath)
+        return null;
+      paths.push(changedPath, originalPath);
+      continue;
+    }
+    if (record.startsWith("u ")) {
+      const changedPath = porcelainV2PathAfterFields(record, 10);
+      if (!changedPath)
+        return null;
+      paths.push(changedPath);
+      continue;
+    }
+    return null;
+  }
+  return { gitHead, changedFiles: [...new Set(paths)] };
+}
+function porcelainV2PathAfterFields(record, fields) {
+  let offset = 0;
+  for (let index = 0;index < fields; index++) {
+    const delimiter = record.indexOf(" ", offset);
+    if (delimiter < 0)
+      return null;
+    offset = delimiter + 1;
+  }
+  const pathValue = record.slice(offset);
+  return pathValue || null;
+}
+function captureWorkspaceSnapshot(directory, optionsOrScope = null, prHeadShaArg = null) {
+  const scope = typeof optionsOrScope === "object" && optionsOrScope !== null ? optionsOrScope.scope ?? null : optionsOrScope;
+  const configuredPrHeadSha = (() => {
+    if (typeof optionsOrScope !== "object" || optionsOrScope === null) {
+      return prHeadShaArg;
+    }
+    return optionsOrScope.prHeadSha ?? null;
+  })();
+  const resolveCurrentPrHeadSha = typeof optionsOrScope === "object" && optionsOrScope !== null && optionsOrScope.resolveCurrentPrHeadSha === true;
+  const upstreamBefore = resolveCurrentPrHeadSha ? runGit(directory, ["rev-parse", "@{upstream}"]) : null;
+  const porcelain = runGit(directory, [
+    "status",
+    "--porcelain=v2",
+    "--branch",
+    "-z",
+    "--untracked-files=all"
+  ]);
+  const snapshot = porcelain === null ? null : parsePorcelainV2Snapshot(porcelain);
+  const upstreamAfter = resolveCurrentPrHeadSha ? runGit(directory, ["rev-parse", "@{upstream}"]) : null;
+  const prHeadSha = resolveCurrentPrHeadSha ? upstreamBefore && upstreamBefore === upstreamAfter ? upstreamBefore : null : configuredPrHeadSha;
+  return {
+    directory: path.resolve(directory),
+    gitHead: snapshot?.gitHead ?? null,
+    dirtyHash: porcelain === null ? null : digest(porcelain),
+    changedFiles: snapshot?.changedFiles ?? null,
+    prHeadSha,
+    scope
+  };
+}
+function changedFilesSinceSnapshot(directory, baseline) {
+  if (!baseline?.gitHead || baseline.changedFiles == null)
+    return null;
+  if (baseline.changedFiles.length > 0)
+    return null;
+  const current = captureWorkspaceSnapshot(directory);
+  if (!current.gitHead || current.changedFiles == null)
+    return null;
+  const changed = new Set(current.changedFiles);
+  if (baseline.gitHead !== current.gitHead) {
+    const committed = runGit(directory, [
+      "diff",
+      "--name-only",
+      "-z",
+      baseline.gitHead,
+      current.gitHead
+    ]);
+    if (committed === null)
+      return null;
+    for (const changedPath of parseNulPaths(committed))
+      changed.add(changedPath);
+  }
+  return [...changed];
+}
+function workspaceSnapshotMatches(expected, current) {
+  if (!expected)
+    return { ok: true };
+  if (path.resolve(expected.directory) !== path.resolve(current.directory)) {
+    return {
+      ok: false,
+      reason: `directory changed: expected ${expected.directory}, got ${current.directory}`
+    };
+  }
+  const checks = ["gitHead", "dirtyHash", "prHeadSha"];
+  for (const key of checks) {
+    const expectedValue = expected[key];
+    if (expectedValue === null)
+      continue;
+    if (current[key] !== expectedValue) {
+      return {
+        ok: false,
+        reason: `${key} changed: expected ${expectedValue}, got ${current[key] ?? "unknown"}`
+      };
+    }
+  }
+  return { ok: true };
+}
+var compareWorkspaceSnapshot = workspaceSnapshotMatches;
+function compareWorkspaceSnapshots(expected, current) {
+  const result = workspaceSnapshotMatches(expected, current);
+  if (result.ok)
+    return { stale: false };
+  return { stale: true, reason: result.reason };
+}
+function digest(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+var _internals = {
+  spawnSync: child_process.spawnSync,
+  yieldControl: () => new Promise((resolve2) => setImmediate(resolve2)),
+  parsePorcelainV2Snapshot
+};
+
+export { readGitTextAtRevision, resolveCurrentGitHead, resolveExactMergeBase, resolveCurrentUpstreamRemoteRef, resolveCurrentUpstreamPushTarget, resolveExactRemoteBranchHead, resolveGitControlStateDigest, resolveIsWorkingTreeClean, resolveCommitCountSince, resolveIsExactSingleChildCommit, resolveRemoteRefsContainingHead, resolvePrWorkflowRevisionDigest, resolvePrWorkflowRevisionDigestAsync, parsePorcelainPaths, captureWorkspaceSnapshot, changedFilesSinceSnapshot, workspaceSnapshotMatches, compareWorkspaceSnapshot, compareWorkspaceSnapshots, digest, _internals };

package/dist/cli/{index-dywekeen.js → index-n6chz2g8.js}

@@ -608,7 +608,7 @@ async function applyKnowledgeVerdictFeedback(directory, options) {
       deltas.push({ id, delta });
     }
     if (deltas.length > 0) {
-      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-e07b4s54.js");
+      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-hqngpt2v.js");
       await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
     }
     return {

package/dist/cli/{index-gnp9x6se.js → index-n832052r.js}

@@ -1,9 +1,11 @@
 // @bun
 import {
-  exports_external
-} from "./index-293f68mj.js";
+  exports_external,
+  init_zod
+} from "./index-bpmtbmy9.js";
 
 // src/config/spec-schema.ts
+init_zod();
 var ObligationSchema = exports_external.enum(["MUST", "SHALL", "SHOULD", "MAY"]);
 var SpecRequirementSchema = exports_external.object({
   id: exports_external.string().regex(/^FR-(?!000)\d{3}$/, "Requirement ID must match FR-### pattern (e.g., FR-001)"),

package/dist/cli/{index-816rkp4y.js → index-s9mj4rb9.js}

@@ -1,15 +1,17 @@
 // @bun
 import {
   validateSpecContent
-} from "./index-gnp9x6se.js";
+} from "./index-n832052r.js";
 import {
-  advisoryWarn
-} from "./index-ye3fndsw.js";
+  advisoryWarn,
+  init_warning_buffer
+} from "./index-gacm5s2n.js";
 
 // src/sdd/effective-spec.ts
 import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
+init_warning_buffer();
 var SWARM_SPEC_REL = path.join(".swarm", "spec.md");
 var OPENSPEC_ROOT = "openspec";
 var SPECKIT_MARKER = ".specify";

package/dist/cli/{index-gw3m5fw0.js → index-v2rdhwx8.js}

@@ -1,7 +1,8 @@
 // @bun
 import {
-  advisoryWarn
-} from "./index-ye3fndsw.js";
+  advisoryWarn,
+  init_warning_buffer
+} from "./index-gacm5s2n.js";
 import {
   log
 } from "./index-zgwm4ryv.js";
@@ -13,6 +14,7 @@ import {
 } from "./index-a76rekgs.js";
 
 // src/worktree/core.ts
+init_warning_buffer();
 import * as fs from "fs";
 import * as fsPromises from "fs/promises";
 import * as os from "os";
@@ -37,7 +39,7 @@ var _internals = {
     symlinkSync: fs.symlinkSync
   },
   writeScopeToDisk: async (directory, taskId, files) => {
-    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-d9erwnvb.js");
+    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-habn4q8a.js");
     return realWrite(directory, taskId, files);
   },
   writeLaneProfileToDisk: async (_worktreePath, _laneIndex, _envOverrides) => {

package/dist/cli/{index-q00e4s1s.js → index-vtwqjr4z.js}

@@ -2,24 +2,26 @@
 import {
   ALLOWED_SKILL_PATH_PREFIXES,
   validateSkillPath
-} from "./index-m0bmh3w0.js";
+} from "./index-dx2c2wjt.js";
 import {
   computeOutcomeSignal,
   readKnowledge,
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   transactKnowledge
-} from "./index-n2712byd.js";
+} from "./index-yt1v62pv.js";
 import {
   effectiveRetrievalOutcomes,
   readKnowledgeCounterRollups
-} from "./index-dywekeen.js";
+} from "./index-n6chz2g8.js";
 import {
+  init_knowledge_types,
   isActiveStatus
-} from "./index-4rhcth7a.js";
+} from "./index-bk5tah7q.js";
 import {
-  advisoryWarn
-} from "./index-ye3fndsw.js";
+  advisoryWarn,
+  init_warning_buffer
+} from "./index-gacm5s2n.js";
 import {
   init_logger,
   log,
@@ -35,10 +37,11 @@ import { mkdir as mkdir4, readFile as readFile4, rename as rename3, unlink, writ
 import * as path4 from "path";
 
 // src/config/bundled-skills.ts
+init_warning_buffer();
+init_logger();
 import { randomUUID } from "crypto";
 import * as fsp from "fs/promises";
 import * as path from "path";
-init_logger();
 var BUNDLED_PROJECT_SKILLS = [
   "brainstorm",
   "specify",
@@ -326,6 +329,7 @@ async function syncBundledProjectSkillsIfMissingAsync(projectDirectory, packageR
 }
 
 // src/services/skill-generator.ts
+init_knowledge_types();
 init_logger();
 
 // src/services/skill-changelog.ts