@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-NWRUSEXG.js

@@ -0,0 +1,322 @@
+import {
+  matchesErrorPattern
+} from "./chunk-2YFUIER7.js";
+
+// src/core/config/failure-taxonomy.ts
+var DEFAULT_FAILOVER_POLICY = {
+  auth_unavailable: { action: "failover" },
+  idle_terminated: { action: "failover" },
+  // Deliberate policy change: a timeout alone is NOT provider unavailability, and
+  // without mutation-ledger evidence we cannot know whether the timed-out run
+  // already mutated state. Failing over could double-apply work. Until a mutation
+  // ledger exists, timeouts are retry-or-halt, never provider failover. The
+  // envelope only reports failoverEligible when the caller affirmatively provides
+  // mutationState === 'none-observed'.
+  startup_timeout: { action: "configurable", retryWithBackoff: true },
+  transport_error: { action: "failover" },
+  // Deliberate policy change: malformed output is often transient (a garbled
+  // stream, a truncated tool read) but it is NOT evidence the provider is
+  // unavailable. Retry the same provider first; do not auto-failover.
+  output_malformed: { action: "configurable", retryWithBackoff: true },
+  rate_limited: { action: "configurable", retryWithBackoff: true },
+  output_semantically_invalid: { action: "no_failover" },
+  execution_semantic_failure: { action: "no_failover" },
+  cli_missing: { action: "failover" },
+  quota_exhausted: { action: "failover" },
+  model_unavailable: { action: "failover" },
+  sandbox_denied: { action: "no_failover" },
+  context_overflow: { action: "no_failover" },
+  invalid_configuration: { action: "no_failover" },
+  user_cancelled: { action: "no_failover" },
+  unknown: { action: "halt_disclose" }
+};
+function categoryFromStructuredReason(reason) {
+  if (typeof reason !== "string") return void 0;
+  switch (reason.toLowerCase()) {
+    case "abort":
+    case "aborted":
+    case "cancelled":
+      return "user_cancelled";
+    case "command_not_found":
+    case "missing_runtime_dependency":
+      return "cli_missing";
+    case "missing_api_key":
+    case "provider_auth_environment":
+      return "auth_unavailable";
+    case "missing_model":
+    case "unresolved_model":
+      return "model_unavailable";
+    case "sandbox_boundary_required":
+    case "sandbox_capability_denied":
+    case "sandbox_environment_failure":
+      return "sandbox_denied";
+    case "invalid_timeout":
+    case "missing_api_config":
+    case "missing_cli_config":
+    case "invalid_config_transport":
+    case "invalid_env_transport":
+    case "invalid_variant_transport":
+    case "unsupported_transport":
+    case "unsupported_option":
+    case "cli_flag_incompatibility":
+      return "invalid_configuration";
+    case "deadline_exhausted":
+    case "timeout":
+      return "startup_timeout";
+    case "provider_transport_failure":
+    case "tmux_exec_transport_unavailable":
+      return "transport_error";
+    case "idle_timeout":
+      return "idle_terminated";
+    default:
+      return void 0;
+  }
+}
+function classifyFailure(error) {
+  if (!error || typeof error !== "object") {
+    return "unknown";
+  }
+  const err = error;
+  const readParsedProviderError = (value) => {
+    if (!value || typeof value !== "object") {
+      return void 0;
+    }
+    const parsed = value;
+    return {
+      type: typeof parsed.type === "string" ? parsed.type : void 0,
+      retryable: typeof parsed.retryable === "boolean" ? parsed.retryable : void 0
+    };
+  };
+  if (err.idleTerminated === true) {
+    return "idle_terminated";
+  }
+  const details = err.details;
+  if (details && typeof details === "object") {
+    const d = details;
+    if (d.idleTerminated === true) {
+      return "idle_terminated";
+    }
+    if (d.timedOut === true || d.providerExitCode === 143 || d.providerExitCode === 124) {
+      return "startup_timeout";
+    }
+  }
+  if (err.timedOut === true || err.providerExitCode === 143 || err.providerExitCode === 124) {
+    return "startup_timeout";
+  }
+  const statusCode = typeof err.statusCode === "number" ? err.statusCode : typeof err.status === "number" ? err.status : void 0;
+  if (typeof statusCode === "number") {
+    if (statusCode === 401 || statusCode === 403) return "auth_unavailable";
+    if (statusCode === 429) return "rate_limited";
+    if (statusCode >= 500) return "transport_error";
+  }
+  const parsedProviderError = readParsedProviderError(err.parsedError) ?? readParsedProviderError(details?.parsedError);
+  if (parsedProviderError) {
+    if (parsedProviderError.type === "auth") {
+      return "auth_unavailable";
+    }
+    if (parsedProviderError.type === "rate_limit") {
+      return "rate_limited";
+    }
+    if (parsedProviderError.type === "timeout") {
+      return "startup_timeout";
+    }
+    if (parsedProviderError.type === "network" || parsedProviderError.type === "capacity") {
+      return "transport_error";
+    }
+    const reason2 = typeof err.reason === "string" ? err.reason : void 0;
+    if (parsedProviderError.retryable === true && reason2 === "non_zero_exit") {
+      return "transport_error";
+    }
+  }
+  const structuredReasonCategory = categoryFromStructuredReason(err.reason);
+  if (structuredReasonCategory) {
+    return structuredReasonCategory;
+  }
+  const message = err.message;
+  if (typeof message === "string") {
+    const msg = message.toLowerCase();
+    if (msg.includes("not authenticated") || msg.includes("unauthorized") || msg.includes("auth") && (msg.includes("fail") || msg.includes("missing") || msg.includes("expired"))) {
+      return "auth_unavailable";
+    }
+    if (msg.includes("idle timeout") || msg.includes("idle_timeout") || msg.includes("idle kill") || msg.includes("idle_kill") || msg.includes("appears idle") || msg.includes("no output/cpu activity")) {
+      return "idle_terminated";
+    }
+    if (msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("network") || msg.includes("socket hang up") || msg.includes("fetch failed")) {
+      return "transport_error";
+    }
+    if (msg.includes("rate limit") || matchesErrorPattern(msg, "429") || msg.includes("too many requests") || msg.includes("throttl")) {
+      return "rate_limited";
+    }
+    if (msg.includes("quota exceeded") || msg.includes("insufficient quota") || msg.includes("insufficient balance") || msg.includes("requires more credits") || msg.includes("no resource package")) {
+      return "quota_exhausted";
+    }
+    if (msg.includes("command not found") || msg.includes("not found on path") || msg.includes("is not available on this system") || msg.includes("enoent")) {
+      return "cli_missing";
+    }
+    if (msg.includes("model") && (msg.includes("not found") || msg.includes("does not exist") || msg.includes("unavailable") || msg.includes("not supported") || msg.includes("unknown model")) || msg.includes("no such model")) {
+      return "model_unavailable";
+    }
+    if (msg.includes("sandbox_capability_denied") || msg.includes("sandbox/policy blocked") || msg.includes("sandbox-exec:") || msg.includes("sandbox") && msg.includes("policy") && msg.includes("blocked")) {
+      return "sandbox_denied";
+    }
+    if (msg.includes("json") && (msg.includes("parse") || msg.includes("syntax")) || msg.includes("schema") && msg.includes("valid") || msg.includes("unexpected token") || msg.includes("truncated") || msg.includes("exceeds maximum allowed tokens") && msg.includes("offset and limit parameters")) {
+      return "output_malformed";
+    }
+    if (msg.includes("context length") || msg.includes("context window") || msg.includes("maximum context") || msg.includes("context_length_exceeded") || msg.includes("prompt") && msg.includes("too long")) {
+      return "context_overflow";
+    }
+    if (msg.includes("invalid configuration") || msg.includes("invalid config") || msg.includes("unknown option") || msg.includes("unrecognized option") || msg.includes("unknown argument")) {
+      return "invalid_configuration";
+    }
+    if (msg.includes("user cancelled") || msg.includes("user canceled") || msg.includes("operation cancelled") || msg.includes("operation canceled") || msg.includes("aborted by user") || msg.includes("sigint")) {
+      return "user_cancelled";
+    }
+  }
+  const reason = typeof err.reason === "string" ? err.reason.toLowerCase() : "";
+  if (reason === "linux_desktop_consent_required") {
+    return "invalid_configuration";
+  }
+  if (reason === "sandbox_capability_denied") {
+    return "sandbox_denied";
+  }
+  if (reason === "abort" || reason === "aborted" || reason === "cancelled") {
+    return "user_cancelled";
+  }
+  if (reason === "command_not_found") {
+    return "cli_missing";
+  }
+  return "unknown";
+}
+function envelopeTraitsFor(category, mutationState) {
+  switch (category) {
+    case "auth_unavailable":
+      return { retryable: false, failoverEligible: true };
+    case "idle_terminated":
+      return { retryable: true, failoverEligible: true };
+    case "startup_timeout":
+      return { retryable: true, failoverEligible: mutationState === "none-observed" };
+    case "transport_error":
+      return { retryable: true, failoverEligible: true };
+    case "output_malformed":
+      return { retryable: true, failoverEligible: false };
+    case "rate_limited":
+      return { retryable: true, failoverEligible: true };
+    case "cli_missing":
+      return { retryable: false, failoverEligible: true };
+    case "quota_exhausted":
+      return { retryable: false, failoverEligible: true };
+    case "model_unavailable":
+      return { retryable: false, failoverEligible: true };
+    case "output_semantically_invalid":
+    case "execution_semantic_failure":
+    case "sandbox_denied":
+    case "context_overflow":
+    case "invalid_configuration":
+    case "user_cancelled":
+      return { retryable: false, failoverEligible: false };
+    case "unknown":
+      return { retryable: false, failoverEligible: false };
+  }
+}
+function evidenceSourceFor(error) {
+  if (!error || typeof error !== "object") {
+    return { source: "heuristic" };
+  }
+  const err = error;
+  const statusCode = typeof err.statusCode === "number" ? err.statusCode : typeof err.status === "number" ? err.status : void 0;
+  if (typeof statusCode === "number") {
+    return { source: "typed" };
+  }
+  const details = err.details;
+  const readType = (value) => {
+    if (!value || typeof value !== "object") return void 0;
+    const t = value.type;
+    return typeof t === "string" ? t : void 0;
+  };
+  const parsedType = readType(err.parsedError) ?? readType(details?.parsedError);
+  if (parsedType) {
+    return { source: "parsed", parsedType };
+  }
+  if (categoryFromStructuredReason(err.reason) !== void 0) {
+    return { source: "typed" };
+  }
+  return { source: "heuristic" };
+}
+function classifyFailureEnvelope(error, context = {}) {
+  const category = classifyFailure(error);
+  const mutationState = context.mutationState ?? "unknown";
+  const { retryable, failoverEligible } = envelopeTraitsFor(category, mutationState);
+  const { source, parsedType } = evidenceSourceFor(error);
+  const err = error && typeof error === "object" ? error : void 0;
+  const statusCode = typeof err?.statusCode === "number" ? err.statusCode : typeof err?.status === "number" ? err.status : void 0;
+  const message = typeof err?.message === "string" ? err.message : void 0;
+  const confidence = category === "unknown" ? "low" : source === "heuristic" ? "low" : "high";
+  return {
+    category,
+    evidenceSource: source,
+    executionPhase: context.executionPhase,
+    mutationState,
+    retryable,
+    failoverEligible,
+    confidence,
+    raw: {
+      ...statusCode !== void 0 ? { statusCode } : {},
+      ...message !== void 0 ? { message } : {},
+      ...parsedType !== void 0 ? { parsedType } : {}
+    }
+  };
+}
+function infraReasonToFailureCategory(reason) {
+  switch (reason) {
+    case "CLI_MISSING":
+      return "cli_missing";
+    case "AUTH_FAILURE":
+      return "auth_unavailable";
+    case "QUOTA_EXCEEDED":
+      return "quota_exhausted";
+    case "RATE_LIMIT":
+      return "rate_limited";
+    case "NETWORK_ERROR":
+      return "transport_error";
+    case "CLI_CRASH":
+      return "transport_error";
+    case "PROVIDER_TRANSPORT_FAILURE":
+      return "transport_error";
+    case "SANDBOX_DENIED":
+      return "sandbox_denied";
+    case "WALL_CLOCK_TIMEOUT":
+      return "startup_timeout";
+    case "MAX_TURNS_EXCEEDED":
+      return "execution_semantic_failure";
+    case "HARNESS_ERROR":
+    case "UNKNOWN":
+      return "unknown";
+  }
+}
+function infraReasonToEnvelope(reason, context = {}) {
+  const category = infraReasonToFailureCategory(reason);
+  const mutationState = context.mutationState ?? "unknown";
+  const { retryable, failoverEligible } = envelopeTraitsFor(category, mutationState);
+  return {
+    category,
+    evidenceSource: "parsed",
+    executionPhase: context.executionPhase,
+    mutationState,
+    retryable,
+    failoverEligible,
+    confidence: category === "unknown" ? "low" : "high",
+    raw: { infraReason: reason }
+  };
+}
+function shouldFailover(category, policyOverrides) {
+  const policy = policyOverrides?.[category] ?? DEFAULT_FAILOVER_POLICY[category];
+  return policy.action === "failover";
+}
+
+export {
+  classifyFailure,
+  classifyFailureEnvelope,
+  infraReasonToEnvelope,
+  shouldFailover
+};
+//# sourceMappingURL=chunk-NWRUSEXG.js.map

package/dist/chunk-O6V4PNLO.js

@@ -0,0 +1,63 @@
+import {
+  BACKUP_DB_ROOTS,
+  resolvePoeticBase
+} from "./chunk-DC4ZYMXJ.js";
+
+// src/telemetry/backup-active-store.ts
+import path from "path";
+function isCoveredDirectory(candidate, poeticBase) {
+  const resolved = path.resolve(candidate);
+  return BACKUP_DB_ROOTS.some((root) => path.resolve(poeticBase, root) === resolved);
+}
+async function inspectActiveStores(poeticBase = resolvePoeticBase(), env = process.env) {
+  const coveredLabels = [];
+  const external = [];
+  let telemetryDbDir;
+  let globalMode = false;
+  try {
+    const [{ TelemetryPathResolver }, { shouldUseGlobalTelemetry }] = await Promise.all([
+      import("./telemetry-path-resolver-7ICSG276.js"),
+      import("./data-migration-state-VJK64DLT.js")
+    ]);
+    telemetryDbDir = TelemetryPathResolver.getInstance().resolveDbDir(poeticBase);
+    globalMode = shouldUseGlobalTelemetry(poeticBase);
+  } catch {
+    return { coveredLabels, external };
+  }
+  if (isCoveredDirectory(telemetryDbDir, poeticBase)) {
+    coveredLabels.push("telemetry databases");
+  } else {
+    external.push({
+      label: "telemetry databases",
+      location: telemetryDbDir,
+      kind: "directory",
+      redirectedBy: env.POETIC_TELEMETRY_DB ? "POETIC_TELEMETRY_DB" : globalMode ? "global-telemetry mode, the default for a migrated project" : "a configured telemetry path"
+    });
+  }
+  const routingOverride = env.POETIC_ROUTING_HISTORY_DB;
+  if (routingOverride) {
+    const routingDir = path.dirname(path.resolve(routingOverride));
+    if (isCoveredDirectory(routingDir, poeticBase)) {
+      coveredLabels.push("routing history database");
+    } else {
+      external.push({
+        label: "routing history database",
+        location: path.resolve(routingOverride),
+        kind: "file",
+        redirectedBy: "POETIC_ROUTING_HISTORY_DB"
+      });
+    }
+  }
+  return { coveredLabels, external };
+}
+function formatExternalStoreWarnings(report) {
+  return report.external.map(
+    (store) => `Warning: ${store.label} resolve to ${store.location}, outside the backed-up roots (redirected by ${store.redirectedBy}). This backup does NOT contain them; back that location up separately.`
+  );
+}
+
+export {
+  inspectActiveStores,
+  formatExternalStoreWarnings
+};
+//# sourceMappingURL=chunk-O6V4PNLO.js.map

package/dist/chunk-OGMSYL6J.js

@@ -0,0 +1,227 @@
+import {
+  classifyRepoPath
+} from "./chunk-H2AYQIHW.js";
+
+// src/core/loop/simple-artifact-goal.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var SIMPLE_ARTIFACT_GOAL_BOUNDARY = /\s+(?:(?:and|then)\s+)?(?:stop when|stop as soon as|stop after|do not modify|do not edit|do not change|only modify|no other files)\b[\s\S]*$/i;
+var SIMPLE_ARTIFACT_GOAL_BOUNDARY_LOOKAHEAD = String.raw`(?=(?:\s+(?:and|then))?\s*\b(?:stop when|stop as soon as|stop after|do not modify|do not edit|do not change|only modify|no other files)\b|$)`;
+var SIMPLE_ARTIFACT_INSTRUCTION_BOUNDARY = /\.\s+(?:Use\s+(?:normal\s+)?(?:text[- ]?file\s+)?formatting(?:;\s*a\s+final\s+newline\s+is\s+acceptable)?|A\s+final\s+newline\s+is\s+acceptable)\b[\s\S]*$/i;
+var SIMPLE_ARTIFACT_SAFE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".csv",
+  ".json",
+  ".log",
+  ".md",
+  ".txt",
+  ".tsv",
+  ".yaml",
+  ".yml"
+]);
+var SIMPLE_ARTIFACT_CODE_ROOTS = /* @__PURE__ */ new Set([
+  "src",
+  "test",
+  "tests",
+  "__tests__",
+  "scripts",
+  "bin",
+  "lib",
+  "packages"
+]);
+function normalizeSimpleArtifactPath(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function classifyArtifactPath(filePath) {
+  const targetPath = normalizeSimpleArtifactPath(filePath);
+  if (targetPath.length === 0 || path.isAbsolute(targetPath) || targetPath.includes("\0") || targetPath.split("/").includes("..")) {
+    return null;
+  }
+  const pathParts = targetPath.split("/").filter(Boolean);
+  return {
+    topLevel: pathParts[0] ?? "",
+    extension: path.extname(targetPath).toLowerCase(),
+    artifactNamedPath: pathParts.some((part) => /artifacts?/i.test(part))
+  };
+}
+function isSafeArtifactRelativePath(filePath) {
+  const parts = classifyArtifactPath(filePath);
+  if (parts === null) return false;
+  return !SIMPLE_ARTIFACT_CODE_ROOTS.has(parts.topLevel) && (parts.artifactNamedPath || SIMPLE_ARTIFACT_SAFE_EXTENSIONS.has(parts.extension));
+}
+function isNonCodeArtifactDiffPath(filePath) {
+  const parts = classifyArtifactPath(filePath);
+  if (parts === null) return false;
+  return !SIMPLE_ARTIFACT_CODE_ROOTS.has(parts.topLevel) && SIMPLE_ARTIFACT_SAFE_EXTENSIONS.has(parts.extension);
+}
+var SIMPLE_ARTIFACT_QUOTE_PAIRS = [
+  ["```", "```"],
+  ["`", "`"],
+  ['"', '"'],
+  ["'", "'"]
+];
+function unwrapQuotedExactContent(value) {
+  for (const [open, close] of SIMPLE_ARTIFACT_QUOTE_PAIRS) {
+    if (value.startsWith(open) && value.endsWith(close) && value.length >= open.length + close.length) {
+      return {
+        value: value.slice(open.length, value.length - close.length),
+        wasQuoted: true
+      };
+    }
+  }
+  return { value, wasQuoted: false };
+}
+function trimQuotedExactContent(raw, options) {
+  let value = raw.replace(SIMPLE_ARTIFACT_GOAL_BOUNDARY, "").trim();
+  const quoted = unwrapQuotedExactContent(value);
+  const wasQuoted = quoted.wasQuoted;
+  value = quoted.value;
+  if (!wasQuoted) {
+    value = value.replace(SIMPLE_ARTIFACT_INSTRUCTION_BOUNDARY, "").trim();
+  }
+  if (options?.stripSentenceTerminatorBeforeBoundary === true && !wasQuoted && /[.!?]$/.test(value)) {
+    value = value.slice(0, -1).trimEnd();
+  }
+  if (!wasQuoted && /[.!?]$/.test(value) && !/\s/u.test(value.slice(0, -1))) {
+    value = value.slice(0, -1).trimEnd();
+  }
+  return value;
+}
+function hasSimpleArtifactGoalBoundary(prompt) {
+  return /\b(?:stop when|stop as soon as|stop after|do not modify|do not edit|do not change|only modify|no other files)\b/i.test(
+    prompt
+  );
+}
+function buildSimpleArtifactGoalFromMatch(match, options) {
+  const targetPath = normalizeSimpleArtifactPath(
+    options?.stripTrailingPathTerminator === true ? (match[1] ?? "").replace(/[.!?]$/, "") : match[1] ?? ""
+  );
+  if (!isNonCodeArtifactDiffPath(targetPath)) {
+    return void 0;
+  }
+  const separator = match[2] ?? "";
+  const expectedContent = trimQuotedExactContent(match[3] ?? "", {
+    stripSentenceTerminatorBeforeBoundary: options?.stripTrailingSentenceTerminator === true || !separator.includes(":")
+  });
+  if (expectedContent.length === 0) return void 0;
+  return { path: targetPath, expectedContent };
+}
+function parseCreateSimpleArtifactGoal(prompt) {
+  if (!/\b(?:create(?:\s+or\s+update)?|ensure|set|write|add)\b/i.test(prompt)) return void 0;
+  if (!/\b(?:(?:contains?|containing|with)\s+exactly)\b/i.test(prompt)) return void 0;
+  if (!hasSimpleArtifactGoalBoundary(prompt)) return void 0;
+  const repoRelative = parseRepoRelativePathSimpleArtifactGoal(prompt);
+  if (repoRelative) return repoRelative;
+  const matches = Array.from(
+    prompt.matchAll(
+      new RegExp(
+        String.raw`\b(?:create(?:\s+or\s+update)?|ensure|set|write|add)\s+(?:the\s+)?(?:file\s+)?[` + `\`'"]?([^\`'"\\s:]+)[\`'"]?` + String.raw`\s+(?:contains?\s+exactly|containing\s+exactly|with\s+exactly(?:\s+one\s+line)?)(\s*:|\s+)([\s\S]*?)` + SIMPLE_ARTIFACT_GOAL_BOUNDARY_LOOKAHEAD,
+        "gi"
+      )
+    )
+  );
+  const match = matches.at(-1);
+  if (!match) return void 0;
+  const stripTrailingSentenceTerminator = /\bwith\s+exactly\s+one\s+line\b/i.test(match[0] ?? "");
+  return buildSimpleArtifactGoalFromMatch(match, {
+    stripTrailingSentenceTerminator
+  });
+}
+function parseRepoRelativePathSimpleArtifactGoal(prompt) {
+  const matches = Array.from(
+    prompt.matchAll(
+      new RegExp(
+        String.raw`\b(?:create(?:\s+or\s+update)?|ensure|set|write|add)\s+(?:a\s+|the\s+)?file\s+at\s+the\s+repo-relative\s+path\s+[` + `\`'"]?([^\`'"\\s:]+)[\`'"]?` + String.raw`[\s\S]*?\b(?:must|should)?\s*contains?\s+exactly(\s*:|\s+)([\s\S]*?)` + SIMPLE_ARTIFACT_GOAL_BOUNDARY_LOOKAHEAD,
+        "gi"
+      )
+    )
+  );
+  const match = matches.at(-1);
+  if (!match) return void 0;
+  return buildSimpleArtifactGoalFromMatch(match, { stripTrailingPathTerminator: true });
+}
+function parseEditSimpleArtifactGoal(prompt) {
+  if (!/\bEdit only\b/i.test(prompt)) return void 0;
+  if (!/\bso it contains exactly\b/i.test(prompt)) return void 0;
+  if (!hasSimpleArtifactGoalBoundary(prompt)) return void 0;
+  const matches = Array.from(
+    prompt.matchAll(
+      new RegExp(
+        String.raw`\bEdit only\s+(?:the\s+)?(?:file\s+)?[` + `\`'"]?([^\`'"\\s:]+)[\`'"]?` + String.raw`\s+so it contains exactly(\s+)([\s\S]*?)` + SIMPLE_ARTIFACT_GOAL_BOUNDARY_LOOKAHEAD,
+        "gi"
+      )
+    )
+  );
+  const match = matches.at(-1);
+  if (!match) return void 0;
+  return buildSimpleArtifactGoalFromMatch(match);
+}
+function parseSimpleArtifactGoal(prompt) {
+  return parseCreateSimpleArtifactGoal(prompt) ?? parseEditSimpleArtifactGoal(prompt);
+}
+async function applyExactArtifactGoalSuccessGate(input) {
+  if (!input.success) {
+    return { success: false };
+  }
+  const goal = parseSimpleArtifactGoal(input.prompt);
+  if (!goal) {
+    return { success: true };
+  }
+  const satisfied = await isSimpleArtifactGoalSatisfied(input.worktreePath, goal);
+  if (satisfied) {
+    return { success: true, goal };
+  }
+  return {
+    success: false,
+    goal,
+    failureReason: `Exact artifact content mismatch for ${goal.path}`
+  };
+}
+function isValidationArtifactPath(filePath) {
+  const normalized = normalizeSimpleArtifactPath(filePath);
+  return normalized.startsWith("dogfood-validation-artifacts/") || normalized.startsWith(".poetic/validation/");
+}
+function artifactContentMatchesExpected(actualContent, expectedContent, filePath) {
+  if (actualContent === expectedContent) {
+    return true;
+  }
+  const extension = path.extname(normalizeSimpleArtifactPath(filePath)).toLowerCase();
+  if ((isValidationArtifactPath(filePath) || SIMPLE_ARTIFACT_SAFE_EXTENSIONS.has(extension)) && actualContent === `${expectedContent}
+`) {
+    return true;
+  }
+  return false;
+}
+async function isSimpleArtifactGoalSatisfied(workspaceRoot, goal) {
+  try {
+    const actualContent = await fs.readFile(path.join(workspaceRoot, goal.path), "utf8");
+    return artifactContentMatchesExpected(actualContent, goal.expectedContent, goal.path);
+  } catch {
+    return false;
+  }
+}
+function getUnexpectedSimpleArtifactTaskChanges(goal, changedFiles) {
+  return changedFiles.map(normalizeSimpleArtifactPath).filter((file) => classifyRepoPath(file) !== "runtime-artifact").filter((file) => file !== goal.path);
+}
+async function isSimpleArtifactGoalSatisfiedForChanges(workspaceRoot, goal, changedFiles) {
+  const normalizedChangedFiles = changedFiles.map(normalizeSimpleArtifactPath);
+  if (!normalizedChangedFiles.includes(goal.path)) {
+    return false;
+  }
+  if (getUnexpectedSimpleArtifactTaskChanges(goal, normalizedChangedFiles).length > 0) {
+    return false;
+  }
+  return isSimpleArtifactGoalSatisfied(workspaceRoot, goal);
+}
+
+export {
+  normalizeSimpleArtifactPath,
+  isSafeArtifactRelativePath,
+  isNonCodeArtifactDiffPath,
+  parseSimpleArtifactGoal,
+  applyExactArtifactGoalSuccessGate,
+  artifactContentMatchesExpected,
+  isSimpleArtifactGoalSatisfied,
+  getUnexpectedSimpleArtifactTaskChanges,
+  isSimpleArtifactGoalSatisfiedForChanges
+};
+//# sourceMappingURL=chunk-OGMSYL6J.js.map