@poetic-ai/poetic 1.42.0

package/dist/chunk-GSGD5E4C.js

@@ -0,0 +1,30 @@
+// src/utils/poetic-package-root.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function findPoeticPackageRoot(startFile = fileURLToPath(import.meta.url), deps = {}) {
+  const exists = deps.existsSync ?? existsSync;
+  const read = deps.readFileSync ?? readFileSync;
+  let current = path.dirname(startFile);
+  for (let depth = 0; depth < 8; depth += 1) {
+    const packageJson = path.join(current, "package.json");
+    if (exists(packageJson)) {
+      try {
+        const parsed = JSON.parse(read(packageJson, "utf8"));
+        if (parsed.name === "@poetic-ai/poetic") {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+}
+
+export {
+  findPoeticPackageRoot
+};
+//# sourceMappingURL=chunk-GSGD5E4C.js.map

package/dist/chunk-GSUQJJXQ.js

@@ -0,0 +1,331 @@
+import {
+  ExitCodeError
+} from "./chunk-FUVP64ER.js";
+import {
+  listRegisteredVariantStrategies,
+  validateStrategy
+} from "./chunk-LWTN3WRV.js";
+import {
+  registry
+} from "./chunk-Z2KYOFHS.js";
+import {
+  validateModel
+} from "./chunk-V53UG2OT.js";
+import {
+  resolveConfig
+} from "./chunk-XPU2XADL.js";
+import {
+  clearActiveProfile,
+  createProfile,
+  deleteProfile,
+  listProfiles,
+  readActiveProfileName,
+  readProfile,
+  setActiveProfile
+} from "./chunk-SZ7DL357.js";
+
+// src/cli/commands/profile.ts
+import { Command } from "commander";
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+var MODEL_VALIDATABLE_PROVIDERS = /* @__PURE__ */ new Set([
+  "codex",
+  "cursor",
+  "copilot",
+  "claude",
+  "gemini",
+  "openai"
+]);
+function validateProfileProvider(provider) {
+  if (registry.has(provider)) {
+    return;
+  }
+  const available = registry.getAllIds().join(", ");
+  console.error(`Error: Unknown provider "${provider}".`);
+  console.error(`Valid providers: ${available}`);
+  throw new ExitCodeError(1);
+}
+function resolveProviderContextForModelValidation(provider, fromProfile) {
+  if (provider) {
+    return provider;
+  }
+  if (!fromProfile) {
+    return void 0;
+  }
+  try {
+    return readProfile(fromProfile).defaults?.provider;
+  } catch {
+    return void 0;
+  }
+}
+function validateProfileModel(provider, model) {
+  if (!model) {
+    return;
+  }
+  if (!provider) {
+    console.error("Error: --model requires --provider (or --from a profile with a provider).");
+    throw new ExitCodeError(1);
+  }
+  validateProfileProvider(provider);
+  if (!MODEL_VALIDATABLE_PROVIDERS.has(provider)) {
+    return;
+  }
+  const result = validateModel({ provider, model });
+  if (result.valid) {
+    return;
+  }
+  const detail = result.warnings.join(" ");
+  console.error(`Error: Invalid model "${model}" for provider "${provider}".`);
+  if (detail) {
+    console.error(detail);
+  }
+  if (result.suggestion) {
+    console.error(`Did you mean "${result.suggestion}"?`);
+  }
+  console.error(
+    "Run `poetic provider show <id> --json` or `poetic provider refresh <id> --models` to inspect available model data."
+  );
+  throw new ExitCodeError(1);
+}
+function validateProfileStrategy(strategy) {
+  if (!strategy) {
+    return;
+  }
+  try {
+    validateStrategy(strategy, "fail");
+  } catch (error) {
+    const registered = listRegisteredVariantStrategies().join(", ");
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: Invalid strategy "${strategy}".`);
+    console.error(message);
+    console.error(`Valid strategies: ${registered}`);
+    throw new ExitCodeError(1);
+  }
+}
+function formatProfile(data, active) {
+  const lines = [];
+  lines.push(`name: ${data.name}${active ? " (active)" : ""}`);
+  if (data.description) lines.push(`description: ${data.description}`);
+  lines.push(`created: ${data.createdAt}`);
+  lines.push(`updated: ${data.updatedAt}`);
+  if (data.defaults && Object.keys(data.defaults).length > 0) {
+    lines.push("defaults:");
+    const d = data.defaults;
+    if (d.provider) lines.push(`  provider: ${d.provider}`);
+    if (d.model) lines.push(`  model: ${d.model}`);
+    if (d.strategy) lines.push(`  strategy: ${d.strategy}`);
+    if (d.routingPolicy) lines.push(`  routingPolicy: ${d.routingPolicy}`);
+    if (d.judge?.type) lines.push(`  judge.type: ${d.judge.type}`);
+    if (d.judge?.provider) lines.push(`  judge.provider: ${d.judge.provider}`);
+    if (d.judge?.model) lines.push(`  judge.model: ${d.judge.model}`);
+    if (d.synthesis?.provider) lines.push(`  synthesis.provider: ${d.synthesis.provider}`);
+    if (d.synthesis?.model) lines.push(`  synthesis.model: ${d.synthesis.model}`);
+    if (d.providers && Object.keys(d.providers).length > 0) {
+      lines.push("  providers:");
+      for (const [prov, cfg] of Object.entries(d.providers)) {
+        if (cfg?.model) lines.push(`    ${prov}.model: ${cfg.model}`);
+        if (cfg?.strategy) lines.push(`    ${prov}.strategy: ${cfg.strategy}`);
+      }
+    }
+  }
+  if (data.telemetry && Object.keys(data.telemetry).length > 0) {
+    lines.push("telemetry:");
+    if (data.telemetry.enabled !== void 0) lines.push(`  enabled: ${data.telemetry.enabled}`);
+    if (data.telemetry.silent !== void 0) lines.push(`  silent: ${data.telemetry.silent}`);
+  }
+  return lines.join("\n");
+}
+function createListSubcommand() {
+  return new Command("list").description("List all profiles").option("--json", "Output as JSON").action((opts) => {
+    const profiles = listProfiles();
+    if (opts.json) {
+      printJson(profiles);
+      return;
+    }
+    if (profiles.length === 0) {
+      console.log("No profiles found.");
+      return;
+    }
+    for (const p of profiles) {
+      const activeMarker = p.active ? " *" : "  ";
+      const desc = p.description ? `  ${p.description}` : "";
+      console.log(`${activeMarker} ${p.name}${desc}`);
+    }
+  });
+}
+function createUseSubcommand() {
+  return new Command("use").description("Set the active profile").argument("<name>", "Profile name to activate").action((name) => {
+    setActiveProfile(name);
+    console.log(`Active profile: ${name}`);
+  });
+}
+function createShowSubcommand() {
+  return new Command("show").description("Show profile contents (defaults to active profile)").argument("[name]", "Profile name (defaults to active)").option("--json", "Output as JSON").action((name, opts) => {
+    const activeName = readActiveProfileName();
+    const profileName = name ?? activeName;
+    if (!profileName) {
+      console.error(
+        "Error: No active profile. Specify a profile name or set one with: poetic profile use <name>"
+      );
+      throw new ExitCodeError(1);
+    }
+    const data = readProfile(profileName);
+    const isActive = profileName === activeName;
+    if (opts.json) {
+      printJson({ ...data, active: isActive });
+      return;
+    }
+    console.log(formatProfile(data, isActive));
+  });
+}
+function createCreateSubcommand() {
+  return new Command("create").description("Create a new profile").argument("<name>", "Profile name").option("--from <other>", "Clone settings from another profile").option("--description <text>", "Profile description").option("--provider <id>", "Default provider for this profile").option("--model <id>", "Default model for this profile").option("--strategy <name>", "Default strategy for this profile").option("--json", "Output as JSON").action(
+    (name, opts) => {
+      if (opts.provider) {
+        validateProfileProvider(opts.provider);
+      }
+      const providerForModel = resolveProviderContextForModelValidation(opts.provider, opts.from);
+      validateProfileModel(providerForModel, opts.model);
+      validateProfileStrategy(opts.strategy);
+      const defaults = opts.provider || opts.model || opts.strategy ? {
+        provider: opts.provider,
+        model: opts.model,
+        strategy: opts.strategy
+      } : void 0;
+      const profile = createProfile(name, {
+        fromProfile: opts.from,
+        description: opts.description,
+        defaults
+      });
+      if (opts.json) {
+        printJson(profile);
+        return;
+      }
+      const fromNote = opts.from ? ` (cloned from ${opts.from})` : "";
+      console.log(`Created profile: ${name}${fromNote}`);
+      if (opts.description) console.log(`  description: ${opts.description}`);
+      if (profile.defaults?.provider) console.log(`  provider: ${profile.defaults.provider}`);
+      if (profile.defaults?.model) console.log(`  model: ${profile.defaults.model}`);
+      if (profile.defaults?.strategy) console.log(`  strategy: ${profile.defaults.strategy}`);
+    }
+  );
+}
+function createDeleteSubcommand() {
+  return new Command("delete").description("Delete a profile").argument("<name>", "Profile name").option("--force", "Force delete even if this is the active profile").option("--json", "Output as JSON").action((name, opts) => {
+    deleteProfile(name, opts.force);
+    if (opts.json) {
+      printJson({ deleted: name });
+      return;
+    }
+    console.log(`Deleted profile: ${name}`);
+  });
+}
+function createExplainSubcommand() {
+  return new Command("explain").description("Show the active profile and how it interacts with configuration resolution").option("--json", "Output as JSON").action((opts) => {
+    const activeName = readActiveProfileName();
+    const profiles = listProfiles();
+    let activeProfileData = null;
+    if (activeName) {
+      try {
+        activeProfileData = readProfile(activeName);
+      } catch {
+      }
+    }
+    const resolved = resolveConfig();
+    if (opts.json) {
+      printJson({
+        activeProfile: activeName ?? null,
+        profileData: activeProfileData,
+        availableProfiles: profiles.map((p) => p.name),
+        resolution: {
+          provider: {
+            value: resolved.defaultProvider.value,
+            source: resolved.defaultProvider.source
+          },
+          model: {
+            value: resolved.defaultModel.value,
+            source: resolved.defaultModel.source
+          },
+          strategy: {
+            value: resolved.defaultStrategy.value,
+            source: resolved.defaultStrategy.source
+          },
+          judgeType: {
+            value: resolved.judge.type.value,
+            source: resolved.judge.type.source
+          }
+        }
+      });
+      return;
+    }
+    console.log("Profile resolution:");
+    console.log("");
+    if (activeName && activeProfileData) {
+      console.log(`Active profile: ${activeName}`);
+      if (activeProfileData.description) {
+        console.log(`  ${activeProfileData.description}`);
+      }
+    } else if (activeName) {
+      console.log(`Active profile: ${activeName} (missing \u2014 file not found)`);
+    } else {
+      console.log("Active profile: none");
+    }
+    console.log("");
+    console.log("Precedence order (highest to lowest):");
+    console.log("  1. CLI flags");
+    console.log("  2. Env vars (POETIC_DEFAULT_PROVIDER, POETIC_ACTIVE_PROFILE, ...)");
+    console.log(`  3. Active profile  ${activeName ? `[${activeName}]` : "[none set]"}`);
+    console.log("  4. Project config  (.poetic/config/poetic.config.jsonc)");
+    console.log("  5. User config     (~/.config/poetic/poetic.config.jsonc)");
+    console.log("  6. Registry defaults");
+    console.log("  7. Hardcoded fallback");
+    console.log("");
+    console.log("Effective values:");
+    console.log(
+      `  provider: ${resolved.defaultProvider.value}  [from: ${resolved.defaultProvider.source}]`
+    );
+    console.log(
+      `  model:    ${resolved.defaultModel.value}  [from: ${resolved.defaultModel.source}]`
+    );
+    console.log(
+      `  strategy: ${resolved.defaultStrategy.value}  [from: ${resolved.defaultStrategy.source}]`
+    );
+    console.log(
+      `  judge:    ${resolved.judge.type.value}  [from: ${resolved.judge.type.source}]`
+    );
+    if (profiles.length > 1) {
+      console.log("");
+      console.log("Available profiles:");
+      for (const p of profiles) {
+        console.log(`  ${p.active ? "*" : " "} ${p.name}`);
+      }
+    }
+  });
+}
+function createClearSubcommand() {
+  return new Command("clear").description("Clear the active profile (use system defaults)").option("--json", "Output as JSON").action((opts) => {
+    clearActiveProfile();
+    if (opts.json) {
+      printJson({ activeProfile: null });
+      return;
+    }
+    console.log("Active profile cleared.");
+  });
+}
+function createProfileCommand() {
+  const cmd = new Command("profile").description("Manage named user-level configuration profiles");
+  cmd.addCommand(createListSubcommand());
+  cmd.addCommand(createUseSubcommand());
+  cmd.addCommand(createShowSubcommand());
+  cmd.addCommand(createCreateSubcommand());
+  cmd.addCommand(createDeleteSubcommand());
+  cmd.addCommand(createExplainSubcommand());
+  cmd.addCommand(createClearSubcommand());
+  return cmd;
+}
+
+export {
+  createProfileCommand
+};
+//# sourceMappingURL=chunk-GSUQJJXQ.js.map

package/dist/chunk-GSV226X6.js

@@ -0,0 +1,110 @@
+import {
+  formatVariantIdentifier
+} from "./chunk-CP7H3HSP.js";
+import {
+  assertSafePathComponent
+} from "./chunk-S2VQCZO4.js";
+import {
+  redactPersistedTestsExecuted
+} from "./chunk-6Y5U7UFY.js";
+import {
+  ProviderExecutionError
+} from "./chunk-LUVKFFWR.js";
+import {
+  LabPathResolver
+} from "./chunk-7GDRQBQC.js";
+import {
+  resolvePoeticRoot
+} from "./chunk-LEIIWPWQ.js";
+import {
+  sanitizeString
+} from "./chunk-LPITVM7M.js";
+
+// src/orchestrator/artifacts/provider-output-artifact-store.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var PROVIDER_OUTPUT_ARTIFACT_SCHEMA_VERSION = 1;
+var PROVIDER_OUTPUT_ARTIFACT_FILENAME = "provider-output.json";
+function shouldPersistProviderOutputArtifact(variant) {
+  return variant.isCompetition !== true && variant.isBasicCompetition !== true;
+}
+function sanitizeVerification(verification) {
+  if (!verification) {
+    return verification;
+  }
+  return {
+    ...verification,
+    findings: verification.findings.map((finding) => ({
+      ...finding,
+      ...typeof finding.outputTail === "string" ? { outputTail: sanitizeString(finding.outputTail) } : {},
+      ...Array.isArray(finding.failingTests) ? { failingTests: finding.failingTests.map((test) => sanitizeString(test)) } : {}
+    }))
+  };
+}
+function buildProviderOutputArtifact(input) {
+  const providerResult = input.result.result;
+  const providerError = input.result.error instanceof ProviderExecutionError ? input.result.error : void 0;
+  const stdout = (typeof providerResult?.stdout === "string" ? providerResult.stdout : void 0) ?? providerError?.stdout ?? "";
+  const stderr = (typeof providerResult?.stderr === "string" ? providerResult.stderr : void 0) ?? providerError?.stderr ?? "";
+  const exitCode = typeof providerResult?.exitCode === "number" ? providerResult.exitCode : providerError?.exitCode;
+  const profile = input.variant.executionProfile;
+  const finishedAt = input.finishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const hostVerification = input.result.testStatus || input.result.testsExecuted || input.result.testMetrics || input.result.verification || input.result.worktreeSummary?.statusLines?.length ? {
+    testStatus: input.result.testStatus,
+    testsExecuted: redactPersistedTestsExecuted(input.result.testsExecuted),
+    testMetrics: input.result.testMetrics,
+    verification: sanitizeVerification(input.result.verification),
+    changedFiles: input.result.worktreeSummary?.statusLines?.filter((line) => typeof line === "string" && line.length >= 4).map((line) => line.slice(3).trim()).filter(Boolean)
+  } : void 0;
+  return {
+    schemaVersion: PROVIDER_OUTPUT_ARTIFACT_SCHEMA_VERSION,
+    taskId: input.taskId,
+    provider: input.result.provider ?? input.variant.provider,
+    model: input.result.resolvedModel ?? input.result.model ?? input.variant.model,
+    variant: input.result.variant || formatVariantIdentifier(input.variant),
+    executionProfileId: profile,
+    profile,
+    success: input.result.success,
+    exitCode,
+    stdout: sanitizeString(stdout),
+    stderr: sanitizeString(stderr),
+    errorMessage: typeof input.result.error?.message === "string" ? sanitizeString(input.result.error.message) : void 0,
+    ...hostVerification ? { hostVerification } : {},
+    startedAt: input.startedAt,
+    finishedAt,
+    observedAt: finishedAt
+  };
+}
+function resolveProviderOutputArtifactRoot(cwd) {
+  return cwd ?? resolvePoeticRoot();
+}
+function providerOutputArtifactPath(taskId, cwd) {
+  const root = resolveProviderOutputArtifactRoot(cwd);
+  const poeticDir = path.join(root, ".poetic");
+  const artifactBase = LabPathResolver.getInstance().getArtifactDir(poeticDir);
+  const safeTaskId = assertSafePathComponent(taskId, "taskId");
+  return path.join(artifactBase, safeTaskId, PROVIDER_OUTPUT_ARTIFACT_FILENAME);
+}
+async function persistProviderOutputArtifact(input) {
+  const artifact = buildProviderOutputArtifact(input);
+  const artifactPath = providerOutputArtifactPath(input.taskId, input.cwd);
+  const artifactDir = path.dirname(artifactPath);
+  await fs.mkdir(artifactDir, { recursive: true });
+  const tempPath = path.join(
+    artifactDir,
+    `.${PROVIDER_OUTPUT_ARTIFACT_FILENAME}.${process.pid}.${Date.now()}.tmp`
+  );
+  await fs.writeFile(tempPath, `${JSON.stringify(artifact, null, 2)}
+`, "utf-8");
+  await fs.rename(tempPath, artifactPath);
+  return artifactPath;
+}
+
+export {
+  PROVIDER_OUTPUT_ARTIFACT_FILENAME,
+  shouldPersistProviderOutputArtifact,
+  resolveProviderOutputArtifactRoot,
+  providerOutputArtifactPath,
+  persistProviderOutputArtifact
+};
+//# sourceMappingURL=chunk-GSV226X6.js.map

package/dist/chunk-H2AYQIHW.js

@@ -0,0 +1,224 @@
+// src/core/utils/repo-path-classifier.ts
+import path from "path";
+var SYSTEM_WRITE_PATH_PREFIXES = [
+  "task/",
+  "sprint/",
+  "backlog/",
+  "tech-debt/",
+  "parking-lot/",
+  "finding/",
+  "issue/",
+  "suppression/",
+  ".poetic/task/",
+  ".poetic/sprint/",
+  ".poetic/backlog/",
+  ".poetic/tech-debt/",
+  ".poetic/parking-lot/",
+  ".poetic/finding/",
+  ".poetic/issue/",
+  ".poetic/suppression/",
+  ".poetic/codex-home/",
+  ".poetic/lifecycle/",
+  ".poetic/plans/",
+  ".poetic/planning/"
+];
+var RUNTIME_ARTIFACT_PATH_PREFIXES = [
+  ".gemini/",
+  ".cursor/",
+  ".vscode/",
+  ".git/",
+  ".poetic/.artifacts/",
+  ".poetic/.cache/",
+  ".poetic/artifacts/",
+  ".poetic/autoloop/",
+  ".poetic/blocker-answers/",
+  ".poetic/cache/",
+  ".poetic/labs/",
+  ".poetic/merge-apply/",
+  ".poetic/provenance/",
+  ".poetic/registry/",
+  ".poetic/repair-patches/",
+  ".poetic/reviews/",
+  ".poetic/runs/",
+  ".poetic/state/",
+  ".poetic/temp/",
+  ".poetic/tmp/",
+  ".poetic/tmp",
+  ".poetic/validation/",
+  ".poetic/xdg-state/",
+  ".poetic/cursor/",
+  ".poetic/copilot/",
+  ".poetic/edits",
+  ".poetic/edits.jsonl",
+  ".poetic/implementations/",
+  ".poetic/lifecycle/",
+  ".poetic/provider-history/",
+  ".poetic/memory/",
+  ".poetic/telemetry/",
+  ".poetic/worktrees/"
+];
+var RUNTIME_ARTIFACT_PATHS = [
+  ".poetic",
+  ".poetic/",
+  ".poetic/config/project-context.json"
+];
+var GENERATED_ARTIFACT_PATH_PREFIXES = [
+  "node_modules/",
+  "node_modules",
+  "dist/",
+  "dist",
+  "coverage/",
+  "coverage",
+  "build/",
+  "build",
+  // Rust/Cargo and other build systems use root target/ for generated output.
+  "target/",
+  "vendor/",
+  "vendor",
+  "tmp/",
+  "tmp",
+  ".tmp/",
+  ".tmp",
+  ".vite-cache/",
+  ".vite-cache",
+  ".poetic-tasks/temp/",
+  // Generated provider artifacts: canonical .poetic/providers/ plus the
+  // legacy root-level paths kept for classifying pre-consolidation diffs.
+  ".poetic/providers/",
+  "providers/pricing.json",
+  "providers/registry.json"
+];
+var EXCLUDED_REPO_PATH_PREFIXES = [
+  ...RUNTIME_ARTIFACT_PATH_PREFIXES,
+  ...GENERATED_ARTIFACT_PATH_PREFIXES,
+  // Repository-local hooks execute outside the provider sandbox on a later Git
+  // operation, so provider-authored edits must never be applied or committed.
+  ".githooks/",
+  ".poetic/codex-home/",
+  ".poetic/plans/",
+  ".poetic/planning/"
+];
+var PROVIDER_REGISTRY_CONFIG_PATHS = [
+  ".poetic/config/providers.yaml",
+  ".poetic/config/provider-registry.yaml.v1.backup"
+];
+var EXCLUDED_REPO_PATHS = [
+  ...RUNTIME_ARTIFACT_PATHS,
+  ...PROVIDER_REGISTRY_CONFIG_PATHS
+];
+var EXCLUDED_REPO_FILENAMES = [
+  ".git",
+  ".poetic-run.json",
+  ".claudeignore",
+  ".geminiignore",
+  ".cursorignore",
+  "GEMINI.md",
+  "CURSOR.md"
+];
+function normalizeRepoPath(filePath) {
+  const normalizedSlashes = filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+  return path.posix.normalize(normalizedSlashes);
+}
+function matchesRepoPathPrefix(filePath, prefix) {
+  if (prefix.endsWith("/")) {
+    return filePath.startsWith(prefix);
+  }
+  return filePath === prefix || filePath.startsWith(`${prefix}/`);
+}
+function startsWithAny(filePath, prefixes) {
+  return prefixes.some((prefix) => matchesRepoPathPrefix(filePath, prefix));
+}
+function hasTraversalSegment(filePath) {
+  return filePath.replace(/\\/g, "/").split("/").some((segment) => segment === "..");
+}
+function escapesRepoRoot(filePath) {
+  return path.posix.isAbsolute(filePath) || filePath === ".." || filePath.startsWith("../") || filePath.includes("/../");
+}
+function isPoeticRuntimeLockPath(filePath) {
+  return filePath.startsWith(".poetic/") && filePath.endsWith(".lock");
+}
+function isPlanningTempArtifact(filePath) {
+  return filePath.startsWith("planning/.tmp.");
+}
+function classifyRepoPath(filePath) {
+  if (hasTraversalSegment(filePath)) {
+    return "repo-content";
+  }
+  const normalized = normalizeRepoPath(filePath);
+  if (escapesRepoRoot(normalized)) {
+    return "repo-content";
+  }
+  if (startsWithAny(normalized, [
+    "task/",
+    "sprint/",
+    "backlog/",
+    "tech-debt/",
+    "parking-lot/",
+    "finding/",
+    "issue/",
+    "suppression/",
+    ".poetic/task/",
+    ".poetic/sprint/",
+    ".poetic/backlog/",
+    ".poetic/tech-debt/",
+    ".poetic/parking-lot/",
+    ".poetic/finding/",
+    ".poetic/issue/",
+    ".poetic/suppression/"
+  ])) {
+    return "managed-metadata";
+  }
+  if (startsWithAny(normalized, [".poetic/plans/", ".poetic/planning/"])) {
+    return "planning-artifact";
+  }
+  if (isPlanningTempArtifact(normalized)) {
+    return "runtime-artifact";
+  }
+  if (RUNTIME_ARTIFACT_PATHS.includes(normalized) || isPoeticRuntimeLockPath(normalized) || normalized.startsWith(".poetic/codex-home/") || startsWithAny(normalized, RUNTIME_ARTIFACT_PATH_PREFIXES)) {
+    return "runtime-artifact";
+  }
+  if (startsWithAny(normalized, GENERATED_ARTIFACT_PATH_PREFIXES) || EXCLUDED_REPO_FILENAMES.includes(path.basename(normalized))) {
+    return "generated-artifact";
+  }
+  return "repo-content";
+}
+function isSystemWritePath(filePath) {
+  const kind = classifyRepoPath(filePath);
+  return kind === "managed-metadata" || kind === "planning-artifact" || kind === "runtime-artifact";
+}
+function isHarmlessRepoPath(filePath) {
+  return classifyRepoPath(filePath) !== "repo-content";
+}
+function shouldIgnoreRepoPath(filePath) {
+  if (hasTraversalSegment(filePath)) {
+    return false;
+  }
+  const normalized = normalizeRepoPath(filePath);
+  if (escapesRepoRoot(normalized)) {
+    return false;
+  }
+  return isPoeticRuntimeLockPath(normalized) || isPlanningTempArtifact(normalized) || EXCLUDED_REPO_PATHS.includes(normalized) || startsWithAny(normalized, EXCLUDED_REPO_PATH_PREFIXES) || EXCLUDED_REPO_FILENAMES.includes(path.basename(normalized));
+}
+function summarizeRepoPaths(filePaths) {
+  const normalizedPaths = filePaths.map(normalizeRepoPath);
+  const kinds = normalizedPaths.map(classifyRepoPath);
+  return {
+    kinds,
+    systemWriteOnly: normalizedPaths.length > 0 && normalizedPaths.every((filePath) => isSystemWritePath(filePath)),
+    harmlessOnly: normalizedPaths.length > 0 && normalizedPaths.every((filePath) => isHarmlessRepoPath(filePath)),
+    categories: Array.from(new Set(kinds))
+  };
+}
+
+export {
+  SYSTEM_WRITE_PATH_PREFIXES,
+  EXCLUDED_REPO_PATH_PREFIXES,
+  EXCLUDED_REPO_PATHS,
+  EXCLUDED_REPO_FILENAMES,
+  normalizeRepoPath,
+  classifyRepoPath,
+  isSystemWritePath,
+  shouldIgnoreRepoPath,
+  summarizeRepoPaths
+};
+//# sourceMappingURL=chunk-H2AYQIHW.js.map