@poetic-ai/poetic 1.42.0

package/dist/chunk-4HN6DF7V.js

@@ -0,0 +1,1027 @@
+import {
+  getArtifactDir
+} from "./chunk-CQM3A35X.js";
+import {
+  resolveContainedPath
+} from "./chunk-WMPU2UOV.js";
+import {
+  atomicWriteJson,
+  atomicWriteText
+} from "./chunk-A3YGID55.js";
+import {
+  emitCustomWarning
+} from "./chunk-EJGCZGUF.js";
+import {
+  PROVIDER_SECRET_PATTERNS
+} from "./chunk-LPITVM7M.js";
+
+// src/automation/flywheel-security.ts
+var PROVIDER_REPLACEMENT_BY_ID = {
+  "anthropic-api-key": "[REDACTED_API_KEY]",
+  "openai-project-api-key": "[REDACTED_API_KEY]",
+  "openai-service-account-key": "[REDACTED_API_KEY]",
+  "openai-admin-api-key": "[REDACTED_API_KEY]",
+  "openrouter-api-key": "[REDACTED_API_KEY]",
+  "google-api-key": "[REDACTED_API_KEY]",
+  "xai-api-key": "[REDACTED_API_KEY]",
+  "slack-token": "[REDACTED_SLACK_TOKEN]"
+};
+var REDACTION_RULES = [
+  // Shared F1–F5 provider-prefix inventory (same sources/min lengths as error-sanitizer).
+  ...PROVIDER_SECRET_PATTERNS.map((pattern) => ({
+    source: pattern.source,
+    replacement: PROVIDER_REPLACEMENT_BY_ID[pattern.id],
+    name: pattern.id
+  })),
+  // Broader / flywheel-local API key forms (not part of the shared inventory).
+  {
+    source: "sk-[a-zA-Z0-9]{32,}",
+    replacement: "[REDACTED_API_KEY]",
+    name: "openai-api-key"
+  },
+  {
+    source: "ya29\\.[a-zA-Z0-9._-]+",
+    replacement: "[REDACTED_OAUTH_TOKEN]",
+    name: "google-oauth-token"
+  },
+  {
+    source: "ghp_[a-zA-Z0-9]{36}",
+    replacement: "[REDACTED_GITHUB_TOKEN]",
+    name: "github-pat"
+  },
+  {
+    source: "gho_[a-zA-Z0-9]{36}",
+    replacement: "[REDACTED_GITHUB_TOKEN]",
+    name: "github-oauth"
+  },
+  {
+    source: "AKIA[0-9A-Z]{16}",
+    replacement: "[REDACTED_AWS_KEY]",
+    name: "aws-access-key"
+  },
+  // Credentials in assignments/configurations
+  // Use negative lookahead (?!\[) to avoid matching our own [REDACTED] placeholders
+  {
+    source: 'password["\\s:=]+(?!\\[)[^\\s"]+',
+    replacement: "password=[REDACTED]",
+    name: "password"
+  },
+  {
+    source: 'token["\\s:=]+(?!\\[)[^\\s"]+',
+    replacement: "token=[REDACTED]",
+    name: "token"
+  },
+  {
+    source: 'secret["\\s:=]+(?!\\[)[^\\s"]+',
+    replacement: "secret=[REDACTED]",
+    name: "secret"
+  },
+  {
+    source: 'api[_-]?key["\\s:=]+(?!\\[)[^\\s"]+',
+    replacement: "api_key=[REDACTED]",
+    name: "api-key"
+  },
+  // Authorization headers
+  {
+    source: "Bearer\\s+[a-zA-Z0-9\\-._~+/]+=*",
+    replacement: "Bearer [REDACTED]",
+    name: "bearer-token"
+  },
+  {
+    source: "Authorization:\\s*[^\\n]+",
+    replacement: "Authorization: [REDACTED]",
+    name: "auth-header"
+  },
+  // PII patterns
+  {
+    source: "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b",
+    replacement: "[REDACTED_EMAIL]",
+    name: "email"
+  },
+  {
+    source: "\\b\\d{3}-\\d{2}-\\d{4}\\b",
+    replacement: "[REDACTED_SSN]",
+    name: "ssn"
+  },
+  {
+    source: "\\b\\d{4}[- ]?\\d{4}[- ]?\\d{4}[- ]?\\d{4}\\b",
+    replacement: "[REDACTED_CARD]",
+    name: "credit-card"
+  },
+  // Database connection strings
+  {
+    source: 'postgres:\\/\\/[^@]+@[^\\s"]+',
+    replacement: "postgres://[REDACTED]@[REDACTED]",
+    name: "postgres-url"
+  },
+  {
+    source: 'mongodb(\\+srv)?:\\/\\/[^@]+@[^\\s"]+',
+    replacement: "mongodb://[REDACTED]",
+    name: "mongo-url"
+  },
+  {
+    source: 'mysql:\\/\\/[^@]+@[^\\s"]+',
+    replacement: "mysql://[REDACTED]",
+    name: "mysql-url"
+  },
+  // Private keys (PEM format)
+  {
+    source: "-----BEGIN [A-Z ]+-----[\\s\\S]*?-----END [A-Z ]+-----",
+    replacement: "[REDACTED_PRIVATE_KEY]",
+    name: "private-key"
+  },
+  // JWT tokens
+  {
+    source: "eyJ[a-zA-Z0-9_-]{10,}\\.eyJ[a-zA-Z0-9_-]{10,}\\.[a-zA-Z0-9_-]{10,}",
+    replacement: "[REDACTED_JWT]",
+    name: "jwt-token"
+  },
+  // Azure patterns
+  {
+    source: "AccountKey=[a-zA-Z0-9+/=]{32,}",
+    replacement: "AccountKey=[REDACTED]",
+    name: "azure-account-key"
+  },
+  // IP addresses — note: this pattern also matches 4-segment version strings (e.g. "1.2.3.4").
+  // A boundary-only fix risks masking real IPs that appear in version-like contexts, so the
+  // tradeoff is accepted: redact conservatively and let callers strip [REDACTED_IP] from
+  // non-sensitive outputs if needed.
+  {
+    source: "\\b(?:\\d{1,3}\\.){3}\\d{1,3}(?::\\d+)?\\b",
+    replacement: "[REDACTED_IP]",
+    name: "ip-address"
+  }
+];
+function emitRedactionDiagnostic(ruleName, count) {
+  emitCustomWarning(
+    "INFO" /* INFO */,
+    "validation" /* VALIDATION */,
+    "Sensitive content was redacted before prompt use",
+    { subsystem: "flywheel-security", executionPhase: "validation" },
+    {
+      metadata: { ruleName, count },
+      skipConsole: true
+    }
+  );
+}
+function emitHighSensitiveContentDiagnostic(entry) {
+  emitCustomWarning(
+    "WARN" /* WARN */,
+    "validation" /* VALIDATION */,
+    "High sensitive content volume detected during prompt sanitization",
+    {
+      subsystem: "flywheel-security",
+      executionPhase: "validation"
+    },
+    {
+      metadata: {
+        workflowId: entry.workflowId,
+        source: entry.source,
+        stageId: entry.stageId,
+        patternsFound: entry.patternsFound
+      },
+      skipConsole: true
+    }
+  );
+}
+var Redactor = class {
+  lastRedactionCount = 0;
+  lastRedactedPatterns = [];
+  /**
+   * Redact sensitive patterns from text
+   *
+   * @param text - Text to redact
+   * @returns Redacted text
+   */
+  redactSensitive(text) {
+    let redacted = text;
+    this.lastRedactionCount = 0;
+    this.lastRedactedPatterns = [];
+    for (const rule of REDACTION_RULES) {
+      const pattern = new RegExp(rule.source, "gi");
+      const matches = redacted.match(pattern);
+      if (matches) {
+        this.lastRedactionCount += matches.length;
+        this.lastRedactedPatterns.push(rule.name);
+        emitRedactionDiagnostic(rule.name, matches.length);
+      }
+      redacted = redacted.replace(pattern, rule.replacement);
+    }
+    return redacted;
+  }
+  /**
+   * Check if text contains sensitive patterns
+   *
+   * Excludes already-redacted placeholders from detection to avoid
+   * false positives after redaction has been applied.
+   *
+   * @param text - Text to check
+   * @returns True if sensitive patterns found (excluding redacted placeholders)
+   */
+  containsSensitivePatterns(text) {
+    const textWithoutPlaceholders = text.replace(/\[REDACTED(?:_[A-Z_]+)?\]/gi, "");
+    for (const rule of REDACTION_RULES) {
+      const pattern = new RegExp(rule.source, "gi");
+      if (pattern.test(textWithoutPlaceholders)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get count of patterns redacted in last call
+   */
+  getLastRedactionCount() {
+    return this.lastRedactionCount;
+  }
+  /**
+   * Get names of patterns redacted in last call
+   */
+  getLastRedactedPatterns() {
+    return [...this.lastRedactedPatterns];
+  }
+};
+var SecurityBoundary = class {
+  redactor;
+  auditLog = [];
+  workflowId;
+  constructor(workflowId) {
+    this.redactor = new Redactor();
+    this.workflowId = workflowId;
+  }
+  /**
+   * Sanitize text before prompt injection
+   *
+   * **CRITICAL**: This MUST be called for ALL text entering prompts,
+   * regardless of source. Even "already processed" text must be re-redacted
+   * because it might have been modified or contain reflected secrets.
+   *
+   * @param text - Text to sanitize
+   * @param source - Where the text came from (for audit)
+   * @param stageId - Current stage ID (for audit)
+   * @returns Sanitized text
+   * @throws Error if redaction fails (text still contains sensitive patterns)
+   */
+  async sanitizeForPromptInjection(text, source, stageId) {
+    const redacted = this.redactor.redactSensitive(text);
+    const entry = {
+      timestamp: /* @__PURE__ */ new Date(),
+      source,
+      originalLength: text.length,
+      redactedLength: redacted.length,
+      patternsFound: this.redactor.getLastRedactionCount(),
+      workflowId: this.workflowId,
+      stageId
+    };
+    this.auditLog.push(entry);
+    if (entry.patternsFound > 5) {
+      emitHighSensitiveContentDiagnostic(entry);
+    }
+    if (this.redactor.containsSensitivePatterns(redacted)) {
+      throw new Error(
+        `Redaction verification failed for ${source}: sensitive content remains after redaction`
+      );
+    }
+    return redacted;
+  }
+  /**
+   * Build retry prompt with mandatory re-redaction
+   *
+   * Constructs a retry prompt that includes judge feedback and context,
+   * with all components sanitized through the security boundary.
+   *
+   * @param stage - Stage configuration
+   * @param failure - Validation failure details
+   * @param context - Additional context to include
+   * @returns Sanitized retry prompt
+   */
+  async buildRetryPrompt(stage, failure, context) {
+    const safeJudgeFeedback = await this.sanitizeForPromptInjection(
+      failure.judgeFeedback,
+      "judge-feedback",
+      stage.id
+    );
+    let safeContext = "";
+    if (context) {
+      safeContext = await this.sanitizeForPromptInjection(context, "context-retrieval", stage.id);
+    }
+    const parts = [
+      stage.prompt ?? "",
+      "",
+      `Previous attempt scored ${failure.score}% (threshold: ${failure.threshold}%).`,
+      "",
+      "Issues to address:",
+      safeJudgeFeedback
+    ];
+    if (safeContext) {
+      parts.push("", "Relevant context:", safeContext);
+    }
+    const retryPrompt = parts.join("\n").trim();
+    return this.sanitizeForPromptInjection(retryPrompt, "retry-prompt", stage.id);
+  }
+  /**
+   * Sanitize stage output before storing or forwarding
+   *
+   * @param output - Stage output content
+   * @param stageId - Stage that produced the output
+   * @returns Sanitized output
+   */
+  async sanitizeStageOutput(output, stageId) {
+    return this.sanitizeForPromptInjection(output, "stage-output", stageId);
+  }
+  /**
+   * Sanitize template variable before interpolation
+   *
+   * @param value - Variable value
+   * @param stageId - Stage using the variable
+   * @returns Sanitized value
+   */
+  async sanitizeTemplateVariable(value, stageId) {
+    return this.sanitizeForPromptInjection(value, "template-variable", stageId);
+  }
+  /**
+   * Get audit log for security review
+   */
+  getAuditLog() {
+    return [...this.auditLog];
+  }
+  /**
+   * Get summary statistics from audit log
+   */
+  getAuditSummary() {
+    const bySource = {
+      "user-input": 0,
+      "judge-feedback": 0,
+      "context-retrieval": 0,
+      "stage-output": 0,
+      "template-variable": 0,
+      "retry-prompt": 0
+    };
+    let totalRedactions = 0;
+    let highRiskEvents = 0;
+    for (const entry of this.auditLog) {
+      totalRedactions += entry.patternsFound;
+      bySource[entry.source] += entry.patternsFound;
+      if (entry.patternsFound > 5) {
+        highRiskEvents++;
+      }
+    }
+    return {
+      totalRedactions,
+      bySource,
+      highRiskEvents
+    };
+  }
+  /**
+   * Clear audit log (for testing or after review)
+   */
+  clearAuditLog() {
+    this.auditLog = [];
+  }
+};
+function createSecurityBoundary(workflowId) {
+  return new SecurityBoundary(workflowId);
+}
+
+// src/automation/flywheel-artifact-store.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import lockfile from "proper-lockfile";
+var ArtifactNotFoundError = class extends Error {
+  constructor(ref, stageId, reason) {
+    super(
+      `Stage '${stageId}' references missing artifact '${ref}'. ${reason}
+Hint: Ensure the dependency stage completed successfully and produced the expected output.`
+    );
+    this.ref = ref;
+    this.stageId = stageId;
+    this.reason = reason;
+    this.name = "ArtifactNotFoundError";
+  }
+  ref;
+  stageId;
+  reason;
+};
+var ArtifactValidationError = class extends Error {
+  constructor(ref, reason) {
+    super(`Invalid artifact '${ref}': ${reason}`);
+    this.ref = ref;
+    this.reason = reason;
+    this.name = "ArtifactValidationError";
+  }
+  ref;
+  reason;
+};
+var ArtifactPathEscapeError = class extends Error {
+  constructor(stageId, outputName, reason) {
+    super(
+      `Refusing to write artifact '${stageId}.${outputName}': ${reason}. Stage ids and output names must match ^[A-Za-z0-9_-]+$ and resolve inside the artifact store.`
+    );
+    this.stageId = stageId;
+    this.outputName = outputName;
+    this.name = "ArtifactPathEscapeError";
+  }
+  stageId;
+  outputName;
+};
+var ARTIFACT_EXTENSIONS = {
+  text: "txt",
+  json: "json",
+  diff: "diff",
+  files: "txt",
+  // List of files as text
+  testResults: "json"
+  // Test results as structured JSON
+};
+var VALID_ARTIFACT_TYPES = new Set(Object.keys(ARTIFACT_EXTENSIONS));
+function isStageOutputType(value) {
+  return typeof value === "string" && VALID_ARTIFACT_TYPES.has(value);
+}
+function parseStoredTimestamp(value) {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? void 0 : value;
+  }
+  if (typeof value !== "string" && typeof value !== "number") {
+    return void 0;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? void 0 : parsed;
+}
+var METADATA_LOCK_DISABLE_ENV = "POETIC_FLYWHEEL_ARTIFACT_METADATA_LOCK_DISABLE";
+function isMetadataFileLockDisabled() {
+  const raw = process.env[METADATA_LOCK_DISABLE_ENV]?.trim().toLowerCase() ?? "";
+  return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
+}
+async function writeFileWithParentRetry(filePath, content) {
+  await atomicWriteText(filePath, content, { ensureDir: true });
+}
+function findPathComponentViolation(value) {
+  if (value.length === 0) return "component is empty";
+  if (value.includes("\0")) return "component contains a null byte";
+  if (value.includes("/") || value.includes("\\")) {
+    return "component contains a path separator";
+  }
+  if (value === "." || value === "..") return "component is a relative path segment";
+  if (path.isAbsolute(value)) return "component is an absolute path";
+  if (path.basename(value) !== value) return "component is not a single path component";
+  return void 0;
+}
+function resolveArtifactWritePath(basePath, stageId, name, filename) {
+  const stageIdViolation = findPathComponentViolation(stageId);
+  if (stageIdViolation) {
+    throw new ArtifactPathEscapeError(stageId, name, `stage id ${stageIdViolation}`);
+  }
+  const nameViolation = findPathComponentViolation(name);
+  if (nameViolation) {
+    throw new ArtifactPathEscapeError(stageId, name, `output name ${nameViolation}`);
+  }
+  const stageDir = path.join(basePath, stageId);
+  const artifactPath = path.join(stageDir, filename);
+  const contained = resolveContainedPath(basePath, containmentCandidate(basePath, artifactPath));
+  if (!contained.contained) {
+    throw new ArtifactPathEscapeError(
+      stageId,
+      name,
+      `resolved path escapes the artifact store (${contained.reason})`
+    );
+  }
+  return { stageDir, artifactPath };
+}
+function validateArtifactIdentity(entry) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return void 0;
+  const { stageId, name, type, size, createdAt } = entry;
+  if (typeof stageId !== "string" || findPathComponentViolation(stageId)) return void 0;
+  if (typeof name !== "string" || findPathComponentViolation(name)) return void 0;
+  if (!isStageOutputType(type)) return void 0;
+  if (typeof size !== "number" || !Number.isFinite(size) || size < 0) return void 0;
+  const created = parseStoredTimestamp(createdAt);
+  if (!created) return void 0;
+  return { stageId, name, type, size, createdAt: created };
+}
+function parsePersistedMetadata(content, basePath) {
+  const parsed = JSON.parse(content);
+  if (!Array.isArray(parsed)) {
+    throw new Error("artifact metadata is not an array");
+  }
+  const entries = /* @__PURE__ */ new Map();
+  let malformed = 0;
+  let uncontained = 0;
+  for (const raw of parsed) {
+    const identity = validateArtifactIdentity(raw);
+    if (!identity) {
+      malformed += 1;
+      continue;
+    }
+    let artifactPath;
+    try {
+      artifactPath = resolveArtifactWritePath(
+        basePath,
+        identity.stageId,
+        identity.name,
+        `${identity.name}.${ARTIFACT_EXTENSIONS[identity.type]}`
+      ).artifactPath;
+    } catch {
+      uncontained += 1;
+      continue;
+    }
+    entries.set(`${identity.stageId}.${identity.name}`, {
+      stageId: identity.stageId,
+      name: identity.name,
+      type: identity.type,
+      path: artifactPath,
+      size: identity.size,
+      createdAt: identity.createdAt
+    });
+  }
+  return { entries, malformed, uncontained };
+}
+function containmentCandidate(root, candidate) {
+  const relative2 = path.relative(root, candidate);
+  if (relative2 === "" || relative2.startsWith("..") || path.isAbsolute(relative2)) {
+    return candidate;
+  }
+  return relative2;
+}
+async function acquireMetadataFileLock(lockTargetPath) {
+  if (isMetadataFileLockDisabled()) {
+    return async () => {
+    };
+  }
+  await fs.mkdir(path.dirname(lockTargetPath), { recursive: true });
+  try {
+    const handle = await fs.open(lockTargetPath, "a");
+    await handle.close();
+  } catch {
+  }
+  return lockfile.lock(lockTargetPath, {
+    stale: 3e4,
+    realpath: false,
+    retries: { retries: 200, minTimeout: 25, maxTimeout: 250, factor: 1.5 }
+  });
+}
+function parseArtifactRef(ref) {
+  const dotIndex = ref.indexOf(".");
+  if (dotIndex === -1 || dotIndex === 0 || dotIndex === ref.length - 1) {
+    throw new Error(
+      `Invalid artifact reference format: '${ref}'. Expected 'stageId.outputName' (e.g., 'p1-scan.assignment')`
+    );
+  }
+  return {
+    stageId: ref.slice(0, dotIndex),
+    outputName: ref.slice(dotIndex + 1)
+  };
+}
+var ArtifactStore = class {
+  workflowId;
+  basePath;
+  metadataPath;
+  metadata = /* @__PURE__ */ new Map();
+  initialized = false;
+  /**
+   * In-process promise-chain lock. Serialises concurrent save() calls on this
+   * instance so they do not race inside saveMetadata().
+   */
+  metadataWriteLock = Promise.resolve();
+  constructor(workflowId) {
+    this.workflowId = workflowId;
+    this.basePath = path.join(getArtifactDir(workflowId), "artifacts");
+    this.metadataPath = path.join(this.basePath, "_metadata.json");
+  }
+  /**
+   * Initialize the artifact store
+   *
+   * Creates the artifacts directory and loads existing metadata if present.
+   * Must be called before any save/load operations.
+   *
+   * Persisted metadata is treated as untrusted input: each entry's shape is
+   * validated and its filesystem path is re-derived from `stageId`/`name`/`type`
+   * against this store's current base path. A `path` field written into
+   * `_metadata.json` by anything other than this store is ignored, so it cannot
+   * redirect a later `load()` at a file outside the workflow. Entries whose
+   * re-derived file no longer exists simply fail `load()` through the existing
+   * ArtifactNotFoundError path.
+   */
+  async initialize() {
+    if (this.initialized) return;
+    await fs.mkdir(this.basePath, { recursive: true });
+    try {
+      const metadataContent = await fs.readFile(this.metadataPath, "utf-8");
+      const { entries, malformed, uncontained } = parsePersistedMetadata(
+        metadataContent,
+        this.basePath
+      );
+      for (const [key, artifact] of entries) {
+        this.metadata.set(key, artifact);
+      }
+      if (malformed > 0) {
+        console.warn(`Warning: Skipped ${malformed} malformed artifact metadata entries`);
+      }
+      if (uncontained > 0) {
+        console.warn(
+          `Warning: Skipped ${uncontained} artifact metadata entries that resolve outside the artifact store`
+        );
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        console.warn(`Warning: Failed to load artifact metadata: ${error}`);
+      }
+    }
+    this.initialized = true;
+  }
+  /**
+   * Save an artifact to the store
+   *
+   * @param stageId - ID of the stage producing the artifact
+   * @param name - Output name (from stage.outputs configuration)
+   * @param type - Artifact type (determines file extension and validation)
+   * @param content - Artifact content (string or object for JSON types)
+   * @returns Stored artifact metadata
+   */
+  async save(stageId, name, type, content) {
+    this.ensureInitialized();
+    const extension = ARTIFACT_EXTENSIONS[type];
+    const filename = `${name}.${extension}`;
+    const { stageDir, artifactPath } = resolveArtifactWritePath(
+      this.basePath,
+      stageId,
+      name,
+      filename
+    );
+    await fs.mkdir(stageDir, { recursive: true });
+    let serializedContent;
+    if (type === "json" || type === "testResults") {
+      serializedContent = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+      try {
+        JSON.parse(serializedContent);
+      } catch {
+        throw new ArtifactValidationError(
+          `${stageId}.${name}`,
+          `Content is not valid JSON: ${serializedContent.slice(0, 100)}...`
+        );
+      }
+    } else {
+      serializedContent = typeof content === "string" ? content : JSON.stringify(content);
+    }
+    await writeFileWithParentRetry(artifactPath, serializedContent);
+    const artifact = {
+      stageId,
+      name,
+      type,
+      path: artifactPath,
+      size: Buffer.byteLength(serializedContent, "utf-8"),
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    const key = `${stageId}.${name}`;
+    this.metadata.set(key, artifact);
+    await this.saveMetadata(key, artifact);
+    return artifact;
+  }
+  /**
+   * Load an artifact from the store
+   *
+   * @param ref - Artifact reference in format 'stageId.outputName'
+   * @param requestingStageId - ID of the stage requesting the artifact (for error messages)
+   * @returns Artifact content as string
+   * @throws ArtifactNotFoundError if artifact doesn't exist or escapes the store root
+   */
+  async load(ref, requestingStageId) {
+    this.ensureInitialized();
+    const { stageId, outputName } = parseArtifactRef(ref);
+    const key = `${stageId}.${outputName}`;
+    const artifact = this.metadata.get(key);
+    if (!artifact) {
+      throw new ArtifactNotFoundError(
+        ref,
+        requestingStageId ?? "unknown",
+        `No artifact found for reference '${ref}'. Available artifacts: [${Array.from(this.metadata.keys()).join(", ") || "none"}]`
+      );
+    }
+    const containment = resolveContainedPath(
+      this.basePath,
+      containmentCandidate(this.basePath, artifact.path)
+    );
+    if (!containment.contained) {
+      throw new ArtifactNotFoundError(
+        ref,
+        requestingStageId ?? "unknown",
+        `Artifact path escapes the workflow artifact directory (${containment.reason}).`
+      );
+    }
+    try {
+      return await fs.readFile(containment.canonicalPath, "utf-8");
+    } catch (_error) {
+      throw new ArtifactNotFoundError(
+        ref,
+        requestingStageId ?? "unknown",
+        `Artifact file not found at '${artifact.path}'. The file may have been deleted.`
+      );
+    }
+  }
+  /**
+   * Load an artifact and parse as JSON
+   *
+   * @param ref - Artifact reference
+   * @param requestingStageId - ID of the stage requesting the artifact
+   * @returns Parsed JSON content
+   */
+  async loadJson(ref, requestingStageId) {
+    const content = await this.load(ref, requestingStageId);
+    try {
+      return JSON.parse(content);
+    } catch {
+      throw new ArtifactValidationError(ref, "Artifact content is not valid JSON");
+    }
+  }
+  /**
+   * Check if an artifact exists
+   *
+   * @param ref - Artifact reference
+   * @returns true if artifact exists
+   */
+  has(ref) {
+    this.ensureInitialized();
+    const { stageId, outputName } = parseArtifactRef(ref);
+    return this.metadata.has(`${stageId}.${outputName}`);
+  }
+  /**
+   * Get metadata for an artifact
+   *
+   * @param ref - Artifact reference
+   * @returns Artifact metadata or undefined if not found
+   */
+  getMetadata(ref) {
+    this.ensureInitialized();
+    const { stageId, outputName } = parseArtifactRef(ref);
+    return this.metadata.get(`${stageId}.${outputName}`);
+  }
+  /**
+   * List all artifacts in the store
+   *
+   * @returns Array of all stored artifact metadata
+   */
+  list() {
+    this.ensureInitialized();
+    return Array.from(this.metadata.values());
+  }
+  /**
+   * List artifacts for a specific stage
+   *
+   * @param stageId - Stage ID to filter by
+   * @returns Array of artifacts from the specified stage
+   */
+  listByStage(stageId) {
+    this.ensureInitialized();
+    return Array.from(this.metadata.values()).filter((a) => a.stageId === stageId);
+  }
+  /**
+   * Resolve multiple artifact inputs and format for prompt injection
+   *
+   * @param inputs - Array of artifact references
+   * @param requestingStageId - ID of the stage requesting the artifacts
+   * @returns Formatted string with all artifact contents
+   */
+  async resolveInputs(inputs, requestingStageId) {
+    if (!inputs || inputs.length === 0) {
+      return "";
+    }
+    const resolvedArtifacts = [];
+    for (const ref of inputs) {
+      const content = await this.load(ref, requestingStageId);
+      const metadata = this.getMetadata(ref);
+      const header = `--- Artifact: ${ref} (${metadata?.type ?? "unknown"}) ---`;
+      resolvedArtifacts.push(`${header}
+${content}
+`);
+    }
+    return resolvedArtifacts.join("\n");
+  }
+  /**
+   * Get the base path for this store
+   */
+  getBasePath() {
+    return this.basePath;
+  }
+  /**
+   * Get the workflow ID
+   */
+  getWorkflowId() {
+    return this.workflowId;
+  }
+  /**
+   * Ensure store is initialized
+   */
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("ArtifactStore not initialized. Call initialize() before using the store.");
+    }
+  }
+  /**
+   * Persist a single new or updated artifact entry to _metadata.json.
+   *
+   * Correctness guarantees:
+   *  1. In-process serialisation: chained onto metadataWriteLock so rapid
+   *     concurrent save() calls on this instance are sequenced.
+   *  2. Cross-process serialisation: acquires a proper-lockfile exclusive lock
+   *     on the metadata file before performing the read-merge-write cycle so
+   *     concurrent saves from parallel stages in the same or separate processes
+   *     cannot overwrite each other's entries.
+   *  3. Read-merge-write under lock: re-reads _metadata.json from disk while
+   *     holding the lock, merges the new entry into the on-disk state, then
+   *     writes back. This prevents the snapshot-then-write problem where a
+   *     concurrent writer's entries are clobbered by an older in-memory snapshot.
+   *  4. Crash safety: uses atomicWriteJson (temp + rename) so a mid-write crash
+   *     cannot leave a partially-written metadata file.
+   *
+   * @param newKey - The metadata map key for the entry just written (stageId.name)
+   * @param newArtifact - The artifact metadata to persist
+   */
+  saveMetadata(newKey, newArtifact) {
+    this.metadataWriteLock = this.metadataWriteLock.catch(() => {
+    }).then(async () => {
+      let releaseFileLock;
+      try {
+        releaseFileLock = await acquireMetadataFileLock(this.metadataPath);
+        let onDisk = /* @__PURE__ */ new Map();
+        try {
+          const raw = await fs.readFile(this.metadataPath, "utf-8");
+          onDisk = parsePersistedMetadata(raw, this.basePath).entries;
+        } catch (err) {
+          if (err.code !== "ENOENT") {
+          }
+        }
+        const merged = new Map(onDisk);
+        for (const [k, v] of this.metadata) {
+          merged.set(k, v);
+        }
+        merged.set(newKey, newArtifact);
+        for (const [k, v] of merged) {
+          this.metadata.set(k, v);
+        }
+        await atomicWriteJson(this.metadataPath, Array.from(merged.values()));
+      } finally {
+        if (releaseFileLock) {
+          try {
+            await releaseFileLock();
+          } catch {
+          }
+        }
+      }
+    });
+    return this.metadataWriteLock;
+  }
+};
+async function resolvePromptArtifacts(prompt, inputs, store, stageId, securityBoundary) {
+  const boundary = securityBoundary ?? createSecurityBoundary(store.getWorkflowId());
+  let resolvedPrompt = prompt;
+  const placeholderPattern = /\{\{artifact:([^}]+)\}\}/g;
+  const matches = [...prompt.matchAll(placeholderPattern)];
+  for (const match of matches) {
+    const ref = match[1] ?? "";
+    let content = await store.load(ref, stageId);
+    content = await boundary.sanitizeForPromptInjection(content, "stage-output", stageId);
+    resolvedPrompt = resolvedPrompt.split(match[0]).join(content);
+  }
+  if (inputs && inputs.length > 0) {
+    let inputsContext = await store.resolveInputs(inputs, stageId);
+    if (inputsContext) {
+      inputsContext = await boundary.sanitizeForPromptInjection(
+        inputsContext,
+        "stage-output",
+        stageId
+      );
+    }
+    if (inputsContext) {
+      resolvedPrompt = `## Input Artifacts
+
+${inputsContext}
+
+## Task
+
+${resolvedPrompt}`;
+    }
+  }
+  return resolvedPrompt;
+}
+
+// src/automation/flywheel-types.ts
+function normalizeWorkflowJudgeTypeToken(token) {
+  const normalized = token.trim().toLowerCase();
+  if (normalized === "ai") return "ai";
+  if (normalized === "multi-lens" || normalized === "hybrid") return "multi-lens";
+  if (normalized === "multi-agent" || normalized === "agentic") return "multi-agent";
+  return null;
+}
+function deriveAiJudgeInvocationArgs(judgeConfig) {
+  if (judgeConfig?.judgeRun !== void 0) {
+    const runSet = dedupeWorkflowJudgeRunSet(judgeConfig.judgeRun);
+    const aiJudgePrimary2 = judgeConfig.judgePrimary ? normalizeWorkflowJudgeTypeToken(judgeConfig.judgePrimary) ?? runSet[0] ?? "ai" : runSet[0] ?? "ai";
+    const aiJudgeRun2 = runSet.join(",");
+    return { aiJudgeRun: aiJudgeRun2, aiJudgePrimary: aiJudgePrimary2, judgeRunRequested: runSet };
+  }
+  const judgeType = judgeConfig?.type ?? "ai";
+  const runComparison = judgeConfig?.runComparison === true;
+  const aiJudgeRun = runComparison ? judgeType === "ai" ? "ai,multi-lens" : "multi-lens" : void 0;
+  const aiJudgePrimary = !runComparison ? judgeType : judgeType === "multi-lens" ? "multi-lens" : "ai";
+  const judgeRunRequested = aiJudgeRun ? aiJudgeRun.split(",") : void 0;
+  return { aiJudgeRun, aiJudgePrimary, judgeRunRequested };
+}
+function dedupeWorkflowJudgeRunSet(judgeRun) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const entry of judgeRun) {
+    const normalized = normalizeWorkflowJudgeTypeToken(entry);
+    if (normalized && !seen.has(normalized)) {
+      seen.add(normalized);
+      result.push(normalized);
+    }
+  }
+  return result;
+}
+function validateCompetitionJudgeConfig(stageId, judgeConfig) {
+  if (!judgeConfig) {
+    return { valid: true };
+  }
+  const errors = [];
+  if (judgeConfig.matrixAuthority !== void 0) {
+    if (judgeConfig.matrixAuthority !== "automatic" && judgeConfig.matrixAuthority !== "off" && judgeConfig.matrixAuthority !== "advisory") {
+      errors.push(
+        `Stage '${stageId}' competition.judgeConfig.matrixAuthority must be 'automatic', 'off', or 'advisory' (got '${String(judgeConfig.matrixAuthority)}')`
+      );
+    }
+  }
+  if (judgeConfig.judgeRun !== void 0) {
+    if (!Array.isArray(judgeConfig.judgeRun) || judgeConfig.judgeRun.length === 0) {
+      errors.push(
+        `Stage '${stageId}' competition.judgeConfig.judgeRun must be a non-empty string[]`
+      );
+    } else {
+      for (const [idx, entry] of judgeConfig.judgeRun.entries()) {
+        if (typeof entry !== "string" || entry.trim().length === 0) {
+          errors.push(
+            `Stage '${stageId}' competition.judgeConfig.judgeRun[${idx}] must be a non-empty string`
+          );
+          continue;
+        }
+        if (normalizeWorkflowJudgeTypeToken(entry) === null) {
+          errors.push(
+            `Stage '${stageId}' competition.judgeConfig.judgeRun[${idx}] has unknown judge id '${entry}'. Valid ids: ai, multi-lens, multi-agent (aliases: hybrid, agentic)`
+          );
+        }
+      }
+    }
+    if (judgeConfig.runComparison !== void 0) {
+      errors.push(
+        `Stage '${stageId}' competition.judgeConfig cannot set both judgeRun and runComparison; remove runComparison when judgeRun is present`
+      );
+    }
+    const normalizedRunSet = dedupeWorkflowJudgeRunSet(judgeConfig.judgeRun ?? []);
+    if (judgeConfig.judgePrimary !== void 0) {
+      if (typeof judgeConfig.judgePrimary !== "string" || judgeConfig.judgePrimary.trim().length === 0) {
+        errors.push(
+          `Stage '${stageId}' competition.judgeConfig.judgePrimary must be a non-empty string when provided`
+        );
+      } else if (normalizeWorkflowJudgeTypeToken(judgeConfig.judgePrimary) === null) {
+        errors.push(
+          `Stage '${stageId}' competition.judgeConfig.judgePrimary has unknown judge id '${judgeConfig.judgePrimary}'. Valid ids: ai, multi-lens, multi-agent (aliases: hybrid, agentic)`
+        );
+      } else {
+        const normalizedPrimary = normalizeWorkflowJudgeTypeToken(judgeConfig.judgePrimary);
+        if (!normalizedRunSet.includes(normalizedPrimary)) {
+          errors.push(
+            `Stage '${stageId}' competition.judgeConfig.judgePrimary '${judgeConfig.judgePrimary}' must be a member of judgeRun [${normalizedRunSet.join(", ")}]`
+          );
+        }
+      }
+    }
+  } else if (judgeConfig.judgePrimary !== void 0) {
+    errors.push(
+      `Stage '${stageId}' competition.judgeConfig.judgePrimary requires judgeRun to be set`
+    );
+  }
+  if (errors.length > 0) {
+    return { valid: false, error: errors.join("; ") };
+  }
+  return { valid: true };
+}
+function hasStageType(result, stageType) {
+  return result.stageType === stageType;
+}
+function isVerifyStageResult(result) {
+  return hasStageType(result, "verify");
+}
+function isCompetitionStageResult(result) {
+  return hasStageType(result, "competition");
+}
+
+export {
+  createSecurityBoundary,
+  ArtifactNotFoundError,
+  parseArtifactRef,
+  ArtifactStore,
+  resolvePromptArtifacts,
+  deriveAiJudgeInvocationArgs,
+  validateCompetitionJudgeConfig,
+  isVerifyStageResult,
+  isCompetitionStageResult
+};
+//# sourceMappingURL=chunk-4HN6DF7V.js.map