@poetic-ai/poetic 1.42.0

package/dist/chunk-6EQKFDBH.js

@@ -0,0 +1,457 @@
+import {
+  isRecord,
+  safeJsonParse
+} from "./chunk-S54MKU6V.js";
+import {
+  ProviderExecutionError
+} from "./chunk-LUVKFFWR.js";
+import {
+  sanitizeError,
+  sanitizeString
+} from "./chunk-LPITVM7M.js";
+
+// src/core/validation/types.ts
+var COMPLETENESS_VALIDATION_THRESHOLD = {
+  /** Stable authority id for logs, messages, and structured metadata */
+  authority: "core.validation.completeness",
+  /** Human-readable owner of this threshold */
+  owner: "completeness-validation",
+  /** Minimum acceptable score (percent-style) */
+  minimumAcceptableScore: 70
+};
+var GIT_CHANGE_COMPLETENESS_SCORER_ID = "git-change-heuristic";
+var GIT_CHANGE_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var GIT_CHANGE_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.git-change-heuristic",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var PROVIDER_DELIVERY_COMPLETENESS_SCORER_ID = "provider-delivery-attempt";
+var PROVIDER_DELIVERY_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var PROVIDER_DELIVERY_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.provider-delivery-attempt",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var LOCAL_EXECUTOR_COMPOSITE_COMPLETENESS_SCORER_ID = "local-executor-composite";
+var LOCAL_EXECUTOR_COMPOSITE_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var LOCAL_EXECUTOR_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.local-executor-composite",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_SCORER_ID = "variant-result-sanitizer-composite";
+var VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.variant-result-sanitizer-composite",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var BASIC_COMPETITION_GIT_PRESENCE_COMPLETENESS_SCORER_ID = "basic-competition-git-presence";
+var BASIC_COMPETITION_GIT_PRESENCE_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var BASIC_COMPETITION_GIT_PRESENCE_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.basic-competition-git-presence",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var ERROR_PARTIAL_CHANGE_VOLUME_COMPLETENESS_SCORER_ID = "error-partial-change-volume";
+var ERROR_PARTIAL_CHANGE_VOLUME_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var ERROR_PARTIAL_CHANGE_VOLUME_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.error-partial-change-volume",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var LOCAL_EXECUTOR_INDEPENDENT_VERIFIED_CHANGE_COMPLETENESS_SCORER_ID = "local-executor-independent-verified-change";
+var LOCAL_EXECUTOR_INDEPENDENT_VERIFIED_CHANGE_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var LOCAL_EXECUTOR_INDEPENDENT_VERIFIED_CHANGE_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.local-executor-independent-verified-change",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var WORKTREE_VALIDATION_COMPOSITE_COMPLETENESS_SCORER_ID = "worktree-validation-composite";
+var WORKTREE_VALIDATION_COMPOSITE_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var WORKTREE_VALIDATION_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.worktree-validation-composite",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var TASK_RUBRIC_COMPLETENESS_SCORER_ID = "task-rubric";
+var TASK_RUBRIC_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.task-rubric",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var PIPELINE_COMPOSITE_COMPLETENESS_SCORER_ID = "variant-execution-pipeline-composite";
+var PIPELINE_COMPOSITE_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var PIPELINE_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.variant-execution-pipeline-composite",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var BASIC_COMPETITION_MASTER_RECONCILIATION_COMPOSITE_COMPLETENESS_SCORER_ID = "basic-competition-master-reconciliation-composite";
+var BASIC_COMPETITION_MASTER_RECONCILIATION_COMPOSITE_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var BASIC_COMPETITION_MASTER_RECONCILIATION_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.basic-competition-master-reconciliation-composite",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var UNTYPED_NUMERIC_COMPLETENESS_SCORER_ID = "untyped-legacy-numeric";
+var UNTYPED_NUMERIC_COMPLETENESS_SCORER_VERSION = "0";
+
+// src/orchestrator/executors/variant-result-sanitizer.ts
+var DEFAULT_VARIANT_COMPLETENESS = {
+  completeness: 0,
+  emptyChanges: true,
+  filesChanged: 0,
+  linesAdded: 0,
+  linesRemoved: 0,
+  workspaceEditsRequested: 0,
+  workspaceEditsApplied: 0,
+  ws007Count: 0
+};
+var COMPLETENESS_CATEGORY_RANK = {
+  empty: 0,
+  planning: 1,
+  partial: 2,
+  substantial: 3,
+  full: 4
+};
+function isSuccessfulCompletedResult(result) {
+  if (result.success === false) return false;
+  if (result.terminationReason !== void 0 && result.terminationReason !== "completed") {
+    return false;
+  }
+  const exitCode = result.result?.exitCode;
+  return typeof exitCode !== "number" || exitCode === 0;
+}
+function sanitizeFiniteNumber(value, fallback, options) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) {
+    if (numeric === Number.POSITIVE_INFINITY) {
+      return typeof options?.max === "number" ? options.max : fallback;
+    }
+    if (numeric === Number.NEGATIVE_INFINITY) {
+      return typeof options?.min === "number" ? options.min : fallback;
+    }
+    return fallback;
+  }
+  let sanitized = numeric;
+  if (typeof options?.min === "number") {
+    sanitized = Math.max(options.min, sanitized);
+  }
+  if (typeof options?.max === "number") {
+    sanitized = Math.min(options.max, sanitized);
+  }
+  return sanitized;
+}
+function isValidSanitizerAuthorityAssessment(assessment) {
+  return assessment.ok === true && Number.isFinite(assessment.score) && assessment.score >= 0 && assessment.score <= 100;
+}
+function failClosedUnderSanitizerComposite(base) {
+  return {
+    score: 0,
+    scorerId: VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_SCORER_ID,
+    scorerVersion: VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_SCORER_VERSION,
+    evidenceProvenance: "sanitizer-numeric-alignment",
+    ok: false,
+    breakdown: base.breakdown,
+    threshold: {
+      authority: VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD.authority,
+      value: VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+    },
+    components: [base]
+  };
+}
+function ownAnalysisBoostUnderSanitizerComposite(base, boostedScore) {
+  const finite = Number.isFinite(boostedScore);
+  const score = finite ? boostedScore : 0;
+  return {
+    score,
+    scorerId: VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_SCORER_ID,
+    scorerVersion: VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_SCORER_VERSION,
+    evidenceProvenance: "sanitizer-numeric-alignment",
+    ok: base.ok === true && finite,
+    breakdown: base.breakdown,
+    threshold: {
+      authority: VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD.authority,
+      value: VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+    },
+    components: [base]
+  };
+}
+function applyTypedAssessmentCompletenessAuthority(result, options) {
+  const assessment = result.completenessAssessment;
+  if (!assessment) {
+    return;
+  }
+  if (!isValidSanitizerAuthorityAssessment(assessment)) {
+    if (assessment.scorerId === VARIANT_RESULT_SANITIZER_COMPOSITE_COMPLETENESS_SCORER_ID && assessment.score === 0 && assessment.ok === false) {
+      result.completeness = 0;
+      return;
+    }
+    const failed = failClosedUnderSanitizerComposite(assessment);
+    result.completenessAssessment = failed;
+    result.completeness = failed.score;
+    return;
+  }
+  result.completeness = assessment.score;
+  if (options?.preserveAnalysisCompleteness && isSuccessfulCompletedResult(result) && result.executionIntent === "analysis" && Number.isFinite(result.completenessScore?.score)) {
+    const analysisScore = Number(result.completenessScore?.score);
+    const rawBoosted = Math.max(assessment.score, analysisScore);
+    const boosted = sanitizeFiniteNumber(rawBoosted, assessment.score, { min: 0, max: 100 });
+    result.completenessScore = {
+      score: boosted,
+      category: "analysis",
+      fileTargetMatchRate: result.completenessScore?.fileTargetMatchRate
+    };
+    if (boosted > assessment.score) {
+      const next = ownAnalysisBoostUnderSanitizerComposite(assessment, boosted);
+      result.completenessAssessment = next;
+      result.completeness = next.score;
+    }
+  }
+}
+function sanitizeVariantResult(result, options) {
+  if (result.completenessAssessment) {
+    applyTypedAssessmentCompletenessAuthority(result, options);
+  } else {
+    result.completeness = sanitizeFiniteNumber(
+      result.completeness,
+      DEFAULT_VARIANT_COMPLETENESS.completeness,
+      { min: 0, max: 100 }
+    );
+    if (options?.preserveAnalysisCompleteness && isSuccessfulCompletedResult(result) && result.executionIntent === "analysis" && Number.isFinite(result.completenessScore?.score)) {
+      const boosted = Math.max(result.completeness ?? 0, result.completenessScore?.score ?? 0);
+      result.completeness = sanitizeFiniteNumber(boosted, 0, { min: 0, max: 100 });
+      result.completenessScore = {
+        score: result.completeness,
+        category: "analysis",
+        fileTargetMatchRate: result.completenessScore?.fileTargetMatchRate
+      };
+    }
+  }
+  if (result.emptyChanges === void 0) {
+    result.emptyChanges = result.completeness < 5;
+  }
+  result.filesChanged = sanitizeFiniteNumber(
+    result.filesChanged,
+    DEFAULT_VARIANT_COMPLETENESS.filesChanged
+  );
+  result.linesAdded = sanitizeFiniteNumber(
+    result.linesAdded,
+    DEFAULT_VARIANT_COMPLETENESS.linesAdded
+  );
+  result.linesRemoved = sanitizeFiniteNumber(
+    result.linesRemoved,
+    DEFAULT_VARIANT_COMPLETENESS.linesRemoved
+  );
+  result.workspaceEditsRequested = sanitizeFiniteNumber(
+    result.workspaceEditsRequested,
+    DEFAULT_VARIANT_COMPLETENESS.workspaceEditsRequested
+  );
+  result.workspaceEditsApplied = sanitizeFiniteNumber(
+    result.workspaceEditsApplied,
+    DEFAULT_VARIANT_COMPLETENESS.workspaceEditsApplied
+  );
+  result.ws007Count = sanitizeFiniteNumber(
+    result.ws007Count,
+    DEFAULT_VARIANT_COMPLETENESS.ws007Count
+  );
+  if (!result.testsExecuted && result.testStatus && result.testStatus !== "not_run") {
+    const testFinding = result.verification?.findings?.find((finding) => finding.kind === "test");
+    if (testFinding) {
+      result.testsExecuted = {
+        scope: "full",
+        filesTested: [],
+        command: testFinding.command,
+        exitCode: testFinding.exitCode,
+        ...typeof result.testMetrics?.durationMs === "number" ? { durationMs: result.testMetrics.durationMs } : {}
+      };
+    }
+  }
+  const gitLinesAdded = result.gitMetrics?.linesAdded ?? result.linesAdded ?? result.worktreeSummary?.insertions ?? 0;
+  const gitLinesDeleted = result.gitMetrics?.linesDeleted ?? result.linesRemoved ?? result.worktreeSummary?.deletions ?? 0;
+  const gitFilesChanged = result.gitMetrics?.filesChanged ?? result.filesChanged ?? result.worktreeSummary?.filesChanged ?? 0;
+  const hasRealGitChanges = gitLinesAdded > 0 || gitLinesDeleted > 0 || gitFilesChanged > 0;
+  if (hasRealGitChanges && result.completenessScore && Number.isFinite(result.completenessScore.score)) {
+    const providerScore = Number(result.completenessScore.score ?? 0);
+    const unifiedScore = Math.max(providerScore, result.completeness);
+    result.completenessScore.score = unifiedScore;
+    const category = result.completenessScore.category;
+    if (category === "planning" || category === "empty") {
+      const derivedCategory = getCategoryFromScore(unifiedScore);
+      result.completenessScore.category = COMPLETENESS_CATEGORY_RANK[derivedCategory] > COMPLETENESS_CATEGORY_RANK.substantial ? "substantial" : derivedCategory;
+      if (result.success) {
+        result.degraded = true;
+      }
+    }
+  }
+  if (result.error instanceof ProviderExecutionError) {
+    result.error.message = sanitizeString(result.error.message);
+    if (typeof result.error.stack === "string") {
+      result.error.stack = sanitizeString(result.error.stack);
+    }
+  } else if (result.error instanceof Error) {
+    result.error = sanitizeError(result.error);
+  }
+  if (result.result) {
+    const engineResult = result.result;
+    if (typeof engineResult.stdout === "string") {
+      engineResult.stdout = sanitizeString(engineResult.stdout);
+    }
+    if (typeof engineResult.stderr === "string") {
+      engineResult.stderr = sanitizeString(engineResult.stderr);
+    }
+    if (typeof engineResult.rawStdout === "string") {
+      engineResult.rawStdout = sanitizeString(engineResult.rawStdout);
+    }
+    if (typeof engineResult.rawStderr === "string") {
+      engineResult.rawStderr = sanitizeString(engineResult.rawStderr);
+    }
+  }
+  if (Array.isArray(result.logTail)) {
+    result.logTail = result.logTail.map((line) => sanitizeString(line));
+  }
+  return result;
+}
+function getCategoryFromScore(score) {
+  const safeScore = Number.isFinite(score) ? score : 0;
+  if (safeScore >= 90) {
+    return "full";
+  }
+  if (safeScore >= 60) {
+    return "substantial";
+  }
+  if (safeScore >= 5) {
+    return "partial";
+  }
+  if (safeScore > 0) {
+    return "planning";
+  }
+  return "empty";
+}
+
+// src/core/judge/process-reliability.ts
+var SHELL_ERROR_PATTERNS = [
+  /bash:\s*-c:\s*line\s*\d+:/i,
+  /zsh:\s*.*(command not found|permission denied|no such file)/i,
+  /sh:\s*.*(command not found|permission denied|no such file)/i,
+  /unexpected eof/i,
+  /syntax error:\s*unexpected end of file/i,
+  /command not found/i,
+  /permission denied/i,
+  /no such file or directory/i
+];
+var STDERR_ERROR_PATTERNS = [
+  /\berror\b/i,
+  /\bexception\b/i,
+  /\bfatal\b/i,
+  /\bfailed\b/i
+];
+function countMatches(text, patterns) {
+  let count = 0;
+  for (const pattern of patterns) {
+    if (pattern.test(text)) count++;
+  }
+  return count;
+}
+function scanStdoutForToolErrors(stdout) {
+  let shellErrorCount = 0;
+  let toolErrorCount = 0;
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) {
+      shellErrorCount += countMatches(trimmed, SHELL_ERROR_PATTERNS);
+      continue;
+    }
+    try {
+      const parsed = safeJsonParse(trimmed, {
+        context: "process reliability stdout jsonl",
+        validator: isRecord
+      });
+      const type = typeof parsed.type === "string" ? parsed.type : void 0;
+      const status = typeof parsed.status === "string" ? parsed.status : void 0;
+      if (type === "tool_use") {
+        const output = typeof parsed.output === "string" ? parsed.output : "";
+        const error = typeof parsed.error === "string" ? parsed.error : "";
+        if (status && status !== "success") {
+          toolErrorCount += 1;
+        }
+        const combined = `${output}
+${error}`.trim();
+        if (combined) {
+          shellErrorCount += countMatches(combined, SHELL_ERROR_PATTERNS);
+        }
+      }
+    } catch {
+      shellErrorCount += countMatches(trimmed, SHELL_ERROR_PATTERNS);
+    }
+  }
+  return { shellErrorCount, toolErrorCount };
+}
+function computeProcessReliabilityMetrics(input) {
+  const stdout = input.result?.stdout ?? "";
+  const stderr = input.result?.stderr ?? "";
+  const { shellErrorCount, toolErrorCount } = scanStdoutForToolErrors(stdout);
+  const stderrErrorCount = stderr ? countMatches(stderr, STDERR_ERROR_PATTERNS) : 0;
+  const recoveredFromError = Boolean((shellErrorCount > 0 || toolErrorCount > 0) && input.success);
+  let score = 100;
+  score -= Math.min(80, shellErrorCount * 30);
+  score -= Math.min(60, toolErrorCount * 20);
+  score -= Math.min(30, stderrErrorCount * 10);
+  score = Math.max(0, Math.min(100, score));
+  const notes = [];
+  if (shellErrorCount > 0) notes.push("shell_errors_detected");
+  if (toolErrorCount > 0) notes.push("tool_errors_detected");
+  if (stderrErrorCount > 0) notes.push("stderr_mentions_errors");
+  if (recoveredFromError) notes.push("recovered");
+  return {
+    score,
+    signals: {
+      shellErrorCount,
+      toolErrorCount,
+      stderrErrorCount,
+      recoveredFromError
+    },
+    notes
+  };
+}
+
+export {
+  COMPLETENESS_VALIDATION_THRESHOLD,
+  GIT_CHANGE_COMPLETENESS_SCORER_ID,
+  GIT_CHANGE_COMPLETENESS_SCORER_VERSION,
+  GIT_CHANGE_COMPLETENESS_VALIDATION_THRESHOLD,
+  PROVIDER_DELIVERY_COMPLETENESS_SCORER_ID,
+  PROVIDER_DELIVERY_COMPLETENESS_SCORER_VERSION,
+  PROVIDER_DELIVERY_COMPLETENESS_VALIDATION_THRESHOLD,
+  LOCAL_EXECUTOR_COMPOSITE_COMPLETENESS_SCORER_ID,
+  LOCAL_EXECUTOR_COMPOSITE_COMPLETENESS_SCORER_VERSION,
+  LOCAL_EXECUTOR_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD,
+  BASIC_COMPETITION_GIT_PRESENCE_COMPLETENESS_SCORER_ID,
+  BASIC_COMPETITION_GIT_PRESENCE_COMPLETENESS_SCORER_VERSION,
+  BASIC_COMPETITION_GIT_PRESENCE_COMPLETENESS_VALIDATION_THRESHOLD,
+  ERROR_PARTIAL_CHANGE_VOLUME_COMPLETENESS_SCORER_ID,
+  ERROR_PARTIAL_CHANGE_VOLUME_COMPLETENESS_SCORER_VERSION,
+  ERROR_PARTIAL_CHANGE_VOLUME_COMPLETENESS_VALIDATION_THRESHOLD,
+  LOCAL_EXECUTOR_INDEPENDENT_VERIFIED_CHANGE_COMPLETENESS_SCORER_ID,
+  LOCAL_EXECUTOR_INDEPENDENT_VERIFIED_CHANGE_COMPLETENESS_SCORER_VERSION,
+  LOCAL_EXECUTOR_INDEPENDENT_VERIFIED_CHANGE_COMPLETENESS_VALIDATION_THRESHOLD,
+  WORKTREE_VALIDATION_COMPOSITE_COMPLETENESS_SCORER_ID,
+  WORKTREE_VALIDATION_COMPOSITE_COMPLETENESS_SCORER_VERSION,
+  WORKTREE_VALIDATION_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD,
+  TASK_RUBRIC_COMPLETENESS_SCORER_ID,
+  TASK_RUBRIC_COMPLETENESS_VALIDATION_THRESHOLD,
+  PIPELINE_COMPOSITE_COMPLETENESS_SCORER_ID,
+  PIPELINE_COMPOSITE_COMPLETENESS_SCORER_VERSION,
+  PIPELINE_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD,
+  BASIC_COMPETITION_MASTER_RECONCILIATION_COMPOSITE_COMPLETENESS_SCORER_ID,
+  BASIC_COMPETITION_MASTER_RECONCILIATION_COMPOSITE_COMPLETENESS_SCORER_VERSION,
+  BASIC_COMPETITION_MASTER_RECONCILIATION_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD,
+  UNTYPED_NUMERIC_COMPLETENESS_SCORER_ID,
+  UNTYPED_NUMERIC_COMPLETENESS_SCORER_VERSION,
+  sanitizeVariantResult,
+  getCategoryFromScore,
+  computeProcessReliabilityMetrics
+};
+//# sourceMappingURL=chunk-6EQKFDBH.js.map

package/dist/chunk-6MFRHTRI.js

@@ -0,0 +1,115 @@
+import {
+  generateId
+} from "./chunk-VNSYKC25.js";
+import {
+  getBucketByName,
+  getBucketPath
+} from "./chunk-HOYBYAOA.js";
+import {
+  writeMarkdownFile
+} from "./chunk-OIS7J26S.js";
+import {
+  findRepoRoot
+} from "./chunk-L7JZLXQL.js";
+
+// src/planning/work-item-writer.ts
+import * as fs from "fs";
+import * as path from "path";
+async function createWorkItemFile(options) {
+  const repoRoot = options.repoRoot || findRepoRoot(process.cwd());
+  let bucket;
+  if (typeof options.bucket === "string") {
+    const resolved = getBucketByName(options.bucket, repoRoot);
+    if (!resolved) {
+      throw new Error(`Bucket not found: ${options.bucket}`);
+    }
+    bucket = resolved;
+  } else {
+    bucket = options.bucket;
+  }
+  const bucketPath = getBucketPath(bucket, repoRoot);
+  if (!fs.existsSync(bucketPath)) {
+    fs.mkdirSync(bucketPath, { recursive: true });
+  }
+  const id = generateId(/* @__PURE__ */ new Date());
+  const filePath = path.join(bucketPath, `${id}.md`);
+  if (fs.existsSync(filePath)) {
+    throw new Error(`Work item file already exists: ${filePath}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const kind = bucket.name;
+  const status = options.metadata?.status ?? defaultStatusForKind(kind);
+  const frontmatter = {
+    id,
+    kind,
+    title: options.title,
+    status,
+    createdAt: now,
+    updatedAt: now,
+    ...options.metadata
+  };
+  if (kind === "task" && typeof frontmatter.version !== "number") {
+    frontmatter.version = 1;
+  }
+  const body = buildMarkdownBody({
+    title: options.title,
+    description: options.description,
+    createdAt: now
+  });
+  await writeMarkdownFile(filePath, frontmatter, body);
+  return {
+    id,
+    path: filePath,
+    bucket
+  };
+}
+function defaultStatusForKind(kind) {
+  switch (kind) {
+    case "backlog":
+      return "inbox";
+    case "task":
+      return "todo";
+    case "sprint":
+      return "planning";
+    case "tech-debt":
+      return "pending";
+    case "parking-lot":
+      return "current";
+    default:
+      return "todo";
+  }
+}
+function buildMarkdownBody(params) {
+  return `# ${params.title}
+
+## Description
+
+${params.description.trim()}
+
+## Activity
+
+(No activity yet)
+`;
+}
+async function createWorkItemWithBacklink(options) {
+  let description = options.description;
+  if (options.backlinkFrom) {
+    const backlink = options.backlinkFrom;
+    const backlinkLine = backlink.path ? `Related to: [${backlink.id}${backlink.title ? ` - ${backlink.title}` : ""}](${backlink.path})` : `Related to: ${backlink.id}${backlink.title ? ` - ${backlink.title}` : ""}`;
+    description = `${description.trim()}
+
+---
+
+${backlinkLine}`;
+  }
+  return createWorkItemFile({
+    ...options,
+    description
+  });
+}
+
+export {
+  createWorkItemFile,
+  createWorkItemWithBacklink
+};
+//# sourceMappingURL=chunk-6MFRHTRI.js.map