@poetic-ai/poetic 1.42.0

package/dist/chunk-LIVJ6266.js

@@ -0,0 +1,438 @@
+import {
+  classifyIntent,
+  inferActivity
+} from "./chunk-4RCCF5BR.js";
+import {
+  extractExplicitFileTargets
+} from "./chunk-VX3UMWB7.js";
+import {
+  getProjectReferencePathExtensions,
+  isProjectSourcePath,
+  isProjectTestPath
+} from "./chunk-UDMS5AD3.js";
+
+// src/planning/enhancement-template-data.ts
+var ENHANCEMENT_TEMPLATES = {
+  scope: {
+    title: "Define scope and touchpoints",
+    why: "Scope boundaries reduce drift and keep solutions comparable.",
+    hint: "Add a short Scope section (in scope / out of scope) to reduce drift.",
+    copyPaste: `Affects: CLI argument parsing, backlog file I/O
+
+In scope:
+- ...
+
+Out of scope:
+- ...`
+  },
+  acceptance: {
+    title: "Define done-when criteria",
+    why: "Clear exit criteria prevent scope creep and clarify success.",
+    hint: 'Consider adding a short "Done when\u2026" checklist to define completion.',
+    copyPaste: `Done when:
+- [ ] Primary requirement met
+- [ ] Tests pass
+- [ ] No regressions`
+  },
+  reproducibility: {
+    title: "Make the bug reproducible",
+    why: "Steps to reproduce cut debugging time by 50%.",
+    hint: "Consider adding steps to reproduce plus expected vs actual behavior.",
+    copyPaste: `## Reproduction
+Steps:
+1.
+
+Expected:
+Actual:`
+  },
+  research: {
+    title: "Frame the research questions",
+    why: "Specific questions converge faster than open exploration.",
+    hint: "Consider adding 1\u20133 research questions and the expected deliverable format.",
+    copyPaste: `Questions to answer:
+- What approaches exist?
+- What are the trade-offs?
+
+Deliverable: Comparison table or recommendation`
+  },
+  adr: {
+    title: "Structure as an ADR",
+    why: "ADR format ensures all stakeholder concerns are addressed.",
+    hint: "Consider structuring this as an ADR (Context/Decision/Alternatives/Consequences).",
+    copyPaste: `## Context
+...
+
+## Decision
+...
+
+## Alternatives Considered
+...
+
+## Consequences
+...`
+  },
+  audience: {
+    title: "Define your audience",
+    why: "Knowing the reader shapes tone, depth, and structure.",
+    hint: "Consider defining the intended audience and assumed prior knowledge.",
+    copyPaste: `Audience: [developers/users/architects]
+Prior knowledge assumed: [...]`
+  },
+  testing: {
+    title: "Outline the test plan",
+    why: "A test plan upfront ensures comprehensive coverage.",
+    hint: "Consider outlining the test plan (unit/integration/edge cases).",
+    copyPaste: `Test coverage:
+- [ ] Unit tests for core logic
+- [ ] Integration tests for boundaries
+- [ ] Edge cases: [...]`
+  },
+  constraints: {
+    title: "Set explicit constraints",
+    why: "Constraints prevent over-engineering and scope creep.",
+    hint: 'Consider adding explicit constraints (in-scope/out-of-scope) to reduce drift. Use "Out of scope:" (not FILE:) for exclusions.',
+    copyPaste: `Constraints:
+- Do not introduce regressions outside the areas this item explicitly targets
+- Out of scope: (specify directories or concerns not to touch)`
+  }
+};
+
+// src/planning/task-body-parser.ts
+function parseTaskBody(body) {
+  const result = {
+    description: "",
+    subtasks: [],
+    notes: "",
+    fileMarkers: [],
+    rawBody: body
+  };
+  const descriptionLines = [];
+  const subtaskLines = [];
+  const notesLines = [];
+  let currentSection = "ignored";
+  let sawCanonicalSection = false;
+  const classifyCanonicalHeading = (heading) => {
+    const normalized = heading.toLowerCase().trim();
+    if (normalized.startsWith("description")) return "description";
+    if (normalized.startsWith("subtasks") || normalized.startsWith("checklist")) return "subtasks";
+    if (normalized.startsWith("notes")) return "notes";
+    if (normalized.startsWith("activity")) return "ignored";
+    return null;
+  };
+  for (const line of body.split("\n")) {
+    const headingMatch = line.match(/^##\s+(.+)$/);
+    if (headingMatch) {
+      const nextSection = classifyCanonicalHeading(headingMatch[1] ?? "");
+      if (nextSection) {
+        sawCanonicalSection = true;
+        currentSection = nextSection;
+        continue;
+      }
+      if (currentSection === "description") {
+        descriptionLines.push(line);
+        continue;
+      }
+    }
+    if (currentSection === "description") {
+      descriptionLines.push(line);
+    } else if (currentSection === "subtasks") {
+      subtaskLines.push(line);
+    } else if (currentSection === "notes") {
+      notesLines.push(line);
+    }
+  }
+  result.description = descriptionLines.join("\n").trim();
+  result.notes = notesLines.join("\n").trim();
+  if (!result.description && !sawCanonicalSection) {
+    result.description = extractUnstructuredDescription(body);
+  }
+  const subtaskContent = subtaskLines.join("\n").trim();
+  const bullets = subtaskContent.match(/^[-*]\s+\[?[x ]?\]?\s*(.+)$/gm);
+  if (bullets) {
+    result.subtasks = bullets.map((b) => b.replace(/^[-*]\s+\[?[x ]?\]?\s*/, "").trim());
+  }
+  result.fileMarkers = [...new Set(extractFileMarkers(body))];
+  return result;
+}
+function isMetadataLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return false;
+  if (/^#\s+Task:/i.test(trimmed)) return true;
+  if (/^\*\*(?:Sprint|Status|Estimated|Plan Artifact|Plan Stage)\*\*:/i.test(trimmed)) {
+    return true;
+  }
+  if (/^(?:Sprint|Status|Estimated|Priority|Assignee|Plan Artifact|Plan Stage):\s*/i.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+function extractUnstructuredDescription(body) {
+  const lines = body.split("\n");
+  const descriptionLines = [];
+  for (const line of lines) {
+    if (isMetadataLine(line)) continue;
+    descriptionLines.push(line);
+  }
+  return descriptionLines.join("\n").trim();
+}
+function buildPromptFromTask(task, body) {
+  const description = body.description || "No description provided.";
+  const fileMarkers = Array.isArray(body.fileMarkers) ? body.fileMarkers : [];
+  const fileBlock = fileMarkers.length > 0 ? `
+
+${fileMarkers.map((file) => `FILE: ${file}`).join("\n")}` : "";
+  const subtasks = Array.isArray(task.subtasks) ? task.subtasks : [];
+  const checklist = subtasks.length > 0 ? subtasks.map((st) => `- [ ] ${st.text}`).join("\n") : "(No subtasks defined)";
+  return `# Task: ${task.title}
+
+${description}
+${fileBlock}
+
+## Checklist
+${checklist}
+`;
+}
+function extractFileMarkers(description) {
+  return extractExplicitFileTargets(description);
+}
+
+// src/planning/task-creation-nudges.ts
+function getEnhancementPriorities(category, activity) {
+  if (activity === "debugging") {
+    return ["reproducibility", "scope", "acceptance"];
+  }
+  if (activity === "planning") {
+    return ["constraints", "acceptance", "scope"];
+  }
+  if (activity === "architecture") {
+    return ["adr", "constraints", "scope"];
+  }
+  if (activity === "research") {
+    return ["research", "constraints", "acceptance"];
+  }
+  if (category === "analyze") {
+    return ["acceptance", "constraints", "scope"];
+  }
+  if (activity === "design") {
+    return ["constraints", "scope", "acceptance"];
+  }
+  if (category === "document") {
+    return ["audience", "scope", "acceptance"];
+  }
+  if (category === "test") {
+    return ["testing", "scope", "acceptance"];
+  }
+  return ["scope", "acceptance", "testing"];
+}
+var PATH_REFERENCE_EXTENSION_ALTERNATION = getProjectReferencePathExtensions().map((ext) => ext.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+var FILE_PATH_LIKE = new RegExp(
+  String.raw`\b(?:[./~]|[a-zA-Z0-9_-]+\/)[a-zA-Z0-9_./-]+\.(?:${PATH_REFERENCE_EXTENSION_ALTERNATION})(?![\w-])`
+);
+function mentionsTestFileReference(text) {
+  const pathTokens = (text.match(/[\w./+-]+/g) ?? []).map((token) => token.replace(/[.,]+$/, "")).filter((token) => token.includes("."));
+  return pathTokens.some((token) => isProjectTestPath(token) && isProjectSourcePath(token));
+}
+function hasAcceptanceCriteria(text) {
+  if (/- \[[ xX]\]/.test(text)) return true;
+  if (/^\s*acceptance\s*:/im.test(text)) return true;
+  if (/^\s*#{1,6}\s*acceptance\b/im.test(text)) return true;
+  if (/(acceptance\s+criteria|done\s+when|definition\s+of\s+done)\b/i.test(text)) return true;
+  if (/\b(must|should)\b/i.test(text) && /\n/.test(text)) return true;
+  if (/\btests?\s+pass\b/i.test(text) || /\b(no|without)\s+regressions?\b/i.test(text)) return true;
+  return false;
+}
+var SCOPE_LANGUAGE = /\b(?:in\s+scope|out\s+of\s+scope|scope\b|touchpoints?|affected\s+(?:areas?|components?)|components?|modules?|services?)\b/i;
+function hasScopeSignal(text) {
+  if (extractFileMarkers(text).length > 0) return true;
+  if (FILE_PATH_LIKE.test(text)) return true;
+  if (SCOPE_LANGUAGE.test(text)) return true;
+  return false;
+}
+function looksMultiConcern(title) {
+  const normalized = title.trim();
+  if (normalized.length < 18) return false;
+  if (/\s+\+\s+/.test(normalized)) return true;
+  if (/\s+and\s+/i.test(normalized)) return true;
+  if (/,/.test(normalized)) return true;
+  return false;
+}
+function hasResearchFraming(text) {
+  if (/\b(output|deliverable|format|return)\b\s*:/i.test(text)) return true;
+  if (/\?/.test(text)) return true;
+  if (/^\s*[-*]\s*(what|why|how)\b/im.test(text)) return true;
+  return false;
+}
+function applyMultiConcernBias(title, priorities) {
+  if (!looksMultiConcern(title)) return priorities;
+  if (priorities.includes("constraints")) return priorities;
+  const next = [...priorities];
+  if (next.length > 0) next[next.length - 1] = "constraints";
+  return next;
+}
+function hasReproducibility(text) {
+  if (/\b(reproduction|repro(?:duce)?|steps?\s+to\s+reproduce)\b/i.test(text)) return true;
+  if (/\b(expected|actual)\s*:/i.test(text)) return true;
+  if (/^\s*\d+\.\s+.*\b(then|next|after|result(?:ing|s)?)\b/im.test(text)) return true;
+  return false;
+}
+function hasAdrStructure(text) {
+  const adrSections = ["context", "decision", "alternatives", "consequences", "status"];
+  let canonicalCount = 0;
+  for (const section of adrSections) {
+    if (new RegExp(`^##?\\s*${section}\\b`, "im").test(text)) {
+      canonicalCount++;
+    }
+  }
+  if (canonicalCount >= 2) return true;
+  const hasContextOrRationale = /^##?\s*(context|rationale|motivation|background|why)\b/im.test(
+    text
+  );
+  const hasDecisionOrGoal = /^##?\s*(decision|goal|objective|summary|proposal)\b/im.test(text);
+  const hasTradeoffSignal = /^##?\s*(alternatives|consequences|trade-?offs?|risks?|out\s+of\s+scope)\b/im.test(text) || /\b(alternatives?\s+considered|pros?\s+(?:and|&)\s+cons?)\b/i.test(text);
+  return hasContextOrRationale && hasDecisionOrGoal && hasTradeoffSignal;
+}
+function hasAudienceDefinition(text) {
+  if (/\b(audience|reader|user|developer|target)\s*:/i.test(text)) return true;
+  if (/\b(intended\s+for|written\s+for|aimed\s+at)\b/i.test(text)) return true;
+  return false;
+}
+var AUTOMATED_TEST_VOCABULARY = /\b(?:tests?\s+cover(?:ing)?|unit|integration|e2e|vitest|jest|playwright|cypress|npm\s+run\s+test|npx\s+vitest|pytest|go\s+test|cargo\s+test|rspec|xctest|junit|phpunit|gradle\s+test|mvn\s+test|dotnet\s+test)\b/i;
+function hasTestPlan(text) {
+  if (/\b(test\s+plan|test\s+coverage|coverage\s+plan)\b/i.test(text)) return true;
+  if (/\b(unit|integration|e2e)\s+test/i.test(text) && /- \[[ xX]?\]/.test(text)) return true;
+  if (/^\s*#{1,6}\s*how\s+to\s+verify\b/im.test(text) && AUTOMATED_TEST_VOCABULARY.test(text)) {
+    return true;
+  }
+  if (/\btests?\s+cover(?:ing)?\b/i.test(text)) return true;
+  if (mentionsTestFileReference(text)) return true;
+  return false;
+}
+function hasConstraints(text) {
+  if (/\b(constraint|out\s+of\s+scope|scope\s*:|boundary|limitation)\b/i.test(text)) return true;
+  if (/\b(must\s+not|should\s+not|won't|will\s+not)\b/i.test(text)) return true;
+  return false;
+}
+function hasSignalForEnhancement(text, kind) {
+  switch (kind) {
+    case "scope":
+      return hasScopeSignal(text);
+    case "acceptance":
+      return hasAcceptanceCriteria(text);
+    case "reproducibility":
+      return hasReproducibility(text);
+    case "research":
+      return hasResearchFraming(text);
+    case "adr":
+      return hasAdrStructure(text);
+    case "audience":
+      return hasAudienceDefinition(text);
+    case "testing":
+      return hasTestPlan(text);
+    case "constraints":
+      return hasConstraints(text);
+    default:
+      return false;
+  }
+}
+function buildEnhancement(kind) {
+  const template = ENHANCEMENT_TEMPLATES[kind];
+  return {
+    kind,
+    title: template.title,
+    why: template.why,
+    copyPaste: template.copyPaste
+  };
+}
+function suggestNextCommands(input) {
+  const commands = [];
+  if (input.itemKind === "backlog") {
+    commands.push(`poetic backlog review ${input.id}`);
+    commands.push(`poetic sprint add-task <sprint-id> ${input.id} --estimate <hours>`);
+    return commands;
+  }
+  commands.push(`poetic task start ${input.id}`);
+  if (typeof input.sprintId === "string" && input.sprintId.length > 0) {
+    commands.push(`poetic task list ${input.sprintId}`);
+  }
+  if (input.category === "test") {
+    commands.push(`poetic run ${input.id}`);
+  }
+  return commands;
+}
+function buildQuickReply(enhancements) {
+  if (enhancements.length === 0) return "";
+  const blocks = enhancements.map((e) => e.copyPaste.trim()).filter((b) => b.length > 0);
+  if (blocks.length === 0) return "";
+  return `Spec enhancement set (optional):
+
+${blocks.join("\n\n")}`.trim();
+}
+function generateEnhancements(input) {
+  const title = input.title.trim();
+  const description = (input.description ?? "").trim();
+  const prompt = description.length > 0 ? `${title}
+
+${description}` : title;
+  const classification = classifyIntent(prompt);
+  const activity = inferActivity(prompt, classification.category);
+  const priorities = applyMultiConcernBias(
+    title,
+    getEnhancementPriorities(classification.category, activity)
+  );
+  const enhancements = [];
+  for (const kind of priorities) {
+    if (enhancements.length >= 3) break;
+    if (!hasSignalForEnhancement(prompt, kind)) {
+      enhancements.push(buildEnhancement(kind));
+    }
+  }
+  const id = input.id ?? "<item-id>";
+  const itemKind = input.itemKind ?? "backlog";
+  const nextCommands = suggestNextCommands({
+    itemKind,
+    id,
+    category: classification.category,
+    sprintId: input.sprintId
+  });
+  const quickReply = buildQuickReply(enhancements);
+  const intent = {
+    category: classification.category,
+    activity,
+    confidence: classification.confidence
+  };
+  return { intent, enhancements, quickReply, nextCommands };
+}
+function toPersistedFormat(enhancements) {
+  return enhancements.map((enhancement) => ({
+    kind: enhancement.kind,
+    snippet: enhancement.copyPaste
+  }));
+}
+function toEnhancementSet(guidance) {
+  return {
+    version: 1,
+    intent: guidance.intent,
+    enhancements: toPersistedFormat(guidance.enhancements)
+  };
+}
+function fromPersistedFormat(persisted) {
+  return persisted.filter((p) => p.kind in ENHANCEMENT_TEMPLATES).map((p) => ({
+    ...buildEnhancement(p.kind),
+    copyPaste: p.snippet
+    // Use persisted snippet (may have been customized)
+  }));
+}
+function hintsFromEnhancements(enhancements) {
+  return enhancements.map((enhancement) => ENHANCEMENT_TEMPLATES[enhancement.kind]?.hint).filter((hint) => Boolean(hint));
+}
+
+export {
+  parseTaskBody,
+  buildPromptFromTask,
+  generateEnhancements,
+  toPersistedFormat,
+  toEnhancementSet,
+  fromPersistedFormat,
+  hintsFromEnhancements
+};
+//# sourceMappingURL=chunk-LIVJ6266.js.map

package/dist/chunk-LKRAR3IH.js

@@ -0,0 +1,276 @@
+import {
+  TelemetryLogger
+} from "./chunk-CKNX3TTP.js";
+import {
+  debugLog
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/providers/claude/execution/environment.ts
+import { randomBytes } from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+var cachedRestrictedEnvCheck = null;
+var cachedRestrictedEnvCheckTimestamp = null;
+var RESTRICTED_ENV_CACHE_TTL_MS = 3e5;
+function _resetRestrictedEnvCache() {
+  cachedRestrictedEnvCheck = null;
+  cachedRestrictedEnvCheckTimestamp = null;
+}
+function isRestrictedEnvironment() {
+  const now = Date.now();
+  if (cachedRestrictedEnvCheck !== null && cachedRestrictedEnvCheckTimestamp !== null && now - cachedRestrictedEnvCheckTimestamp < RESTRICTED_ENV_CACHE_TTL_MS) {
+    return cachedRestrictedEnvCheck;
+  }
+  const homeDir = os.homedir();
+  const claudeDir = path.join(homeDir, ".claude");
+  try {
+    if (fs.existsSync(claudeDir)) {
+      const testFile = path.join(claudeDir, `.poetic-write-test-${process.pid}`);
+      try {
+        fs.writeFileSync(testFile, "", { mode: 384 });
+        fs.unlinkSync(testFile);
+        cachedRestrictedEnvCheck = false;
+        cachedRestrictedEnvCheckTimestamp = now;
+        return false;
+      } catch {
+        cachedRestrictedEnvCheck = true;
+        cachedRestrictedEnvCheckTimestamp = now;
+        return true;
+      }
+    }
+    try {
+      fs.accessSync(homeDir, fs.constants.W_OK);
+      cachedRestrictedEnvCheck = false;
+      cachedRestrictedEnvCheckTimestamp = now;
+      return false;
+    } catch {
+      cachedRestrictedEnvCheck = true;
+      cachedRestrictedEnvCheckTimestamp = now;
+      return true;
+    }
+  } catch {
+    cachedRestrictedEnvCheck = true;
+    cachedRestrictedEnvCheckTimestamp = now;
+    return true;
+  }
+}
+var cachedFallbackConfigDir = null;
+var cachedFallbackConfigDirIdentity = null;
+var fallbackConfigDirTeardown = null;
+var FALLBACK_CREDENTIAL_FILES = [".claude.json", "credentials.json", ".credentials.json"];
+var FALLBACK_SETTINGS_FILES = ["settings.json", "settings.local.json"];
+function _resetClaudeFallbackConfigDir() {
+  cachedFallbackConfigDir = null;
+  cachedFallbackConfigDirIdentity = null;
+  if (fallbackConfigDirTeardown !== null) {
+    process.removeListener("exit", fallbackConfigDirTeardown);
+    fallbackConfigDirTeardown = null;
+  }
+}
+function getClaudeFallbackConfigDir() {
+  if (cachedFallbackConfigDir !== null) {
+    if (isUsableFallbackConfigDir(cachedFallbackConfigDir)) {
+      return cachedFallbackConfigDir;
+    }
+    discardFallbackConfigDirCopies(cachedFallbackConfigDir);
+  }
+  const created = fs.mkdtempSync(path.join(os.tmpdir(), "poetic-claude-config-"));
+  fs.chmodSync(created, 448);
+  const createdStats = fs.lstatSync(created);
+  cachedFallbackConfigDir = created;
+  cachedFallbackConfigDirIdentity = { dev: createdStats.dev, ino: createdStats.ino };
+  scheduleFallbackConfigDirRemoval();
+  return created;
+}
+function isCreatedFallbackConfigDir(dir) {
+  const identity = cachedFallbackConfigDirIdentity;
+  if (identity === null) {
+    return false;
+  }
+  try {
+    const stats = fs.lstatSync(dir);
+    return stats.isDirectory() && stats.dev === identity.dev && stats.ino === identity.ino;
+  } catch {
+    return false;
+  }
+}
+function isUsableFallbackConfigDir(dir) {
+  if (!isCreatedFallbackConfigDir(dir)) {
+    return false;
+  }
+  try {
+    return (fs.lstatSync(dir).mode & 511) === 448;
+  } catch {
+    return false;
+  }
+}
+function scheduleFallbackConfigDirRemoval() {
+  if (fallbackConfigDirTeardown !== null) {
+    return;
+  }
+  const teardown = () => {
+    if (cachedFallbackConfigDir !== null) {
+      discardFallbackConfigDirCopies(cachedFallbackConfigDir);
+    }
+  };
+  fallbackConfigDirTeardown = teardown;
+  process.once("exit", teardown);
+}
+function discardFallbackConfigDirCopies(dir) {
+  if (!isCreatedFallbackConfigDir(dir)) {
+    return;
+  }
+  for (const file of [...FALLBACK_CREDENTIAL_FILES, ...FALLBACK_SETTINGS_FILES]) {
+    try {
+      fs.unlinkSync(path.join(dir, file));
+    } catch {
+    }
+  }
+  try {
+    fs.rmdirSync(dir);
+  } catch {
+  }
+}
+function copyClaudeCredentials(fallbackDir) {
+  const homeDir = os.homedir();
+  const claudeDir = path.join(homeDir, ".claude");
+  function verifyCopiedFilePermissions(fileLabel, destPath, warnOnMismatch) {
+    try {
+      const stats = fs.statSync(destPath);
+      const actualMode = stats.mode & 511;
+      if (actualMode !== 384) {
+        const message = `[Claude] ${fileLabel} has permissions ${actualMode.toString(8)} (expected 0600)`;
+        if (warnOnMismatch) {
+          console.warn(`${message}. This may be a security risk.`);
+        } else {
+          debugLog(message);
+        }
+      } else {
+        debugLog(`[Claude] ${fileLabel} synced (permissions verified: 0600)`);
+      }
+    } catch (verifyErr) {
+      if (warnOnMismatch) {
+        console.warn(
+          `[Claude] Warning: Could not verify permissions for ${fileLabel}: ${verifyErr}`
+        );
+      }
+    }
+  }
+  function shouldSyncSourceToFallback(srcPath, destPath) {
+    if (!fs.existsSync(srcPath)) {
+      return false;
+    }
+    if (!fs.existsSync(destPath)) {
+      return true;
+    }
+    try {
+      const srcStat = fs.statSync(srcPath);
+      const destStat = fs.statSync(destPath);
+      return srcStat.mtimeMs > destStat.mtimeMs || srcStat.size !== destStat.size;
+    } catch {
+      return true;
+    }
+  }
+  function syncFileToFallback(file, opts) {
+    const srcPath = path.join(claudeDir, file);
+    const destPath = path.join(fallbackDir, file);
+    if (!shouldSyncSourceToFallback(srcPath, destPath)) {
+      return;
+    }
+    const existedBefore = fs.existsSync(destPath);
+    const tmpSuffix = randomBytes(6).toString("hex");
+    const tmpPath = `${destPath}.tmp-${process.pid}-${tmpSuffix}`;
+    try {
+      const content = fs.readFileSync(srcPath, "utf-8");
+      fs.writeFileSync(tmpPath, content, { mode: 384 });
+      fs.renameSync(tmpPath, destPath);
+      verifyCopiedFilePermissions(file, destPath, opts.warnOnPermissionMismatch);
+      debugLog(`[Claude] ${existedBefore ? "Updated" : "Copied"} ${opts.logLabel}: ${file}`);
+    } catch (err) {
+      debugLog(`[Claude] Could not sync ${file}: ${err}`);
+      try {
+        if (fs.existsSync(tmpPath)) {
+          fs.unlinkSync(tmpPath);
+        }
+      } catch {
+      }
+    }
+  }
+  for (const file of FALLBACK_CREDENTIAL_FILES) {
+    syncFileToFallback(file, {
+      warnOnPermissionMismatch: true,
+      logLabel: "credentials"
+    });
+  }
+  for (const file of FALLBACK_SETTINGS_FILES) {
+    syncFileToFallback(file, {
+      warnOnPermissionMismatch: false,
+      logLabel: "settings"
+    });
+  }
+}
+function ensureClaudeConfigDir(env) {
+  if (process.env.CLAUDE_CONFIG_DIR || env.CLAUDE_CONFIG_DIR) {
+    return env;
+  }
+  if (!isRestrictedEnvironment()) {
+    return env;
+  }
+  let fallbackDir;
+  try {
+    fallbackDir = getClaudeFallbackConfigDir();
+  } catch (err) {
+    console.warn(
+      `[Claude] Warning: Cannot create fallback config dir under ${os.tmpdir()}: ${err}`
+    );
+    return env;
+  }
+  try {
+    copyClaudeCredentials(fallbackDir);
+  } catch (err) {
+    debugLog(`[Claude] Warning: Could not copy credentials: ${err}`);
+  }
+  console.warn(
+    `[Claude] Detected restricted environment (cannot write to ~/.claude). Using fallback config dir: ${fallbackDir}`
+  );
+  try {
+    TelemetryLogger.getInstance().logEvent("claude_config_dir_fallback", {
+      fallbackDir,
+      reason: "restricted_environment"
+    });
+  } catch {
+  }
+  return {
+    ...env,
+    CLAUDE_CONFIG_DIR: fallbackDir
+  };
+}
+var CLAUDE_READ_ONLY_CHAT_DISALLOWED_TOOLS = [
+  "Write",
+  "Edit",
+  "MultiEdit",
+  "NotebookEdit",
+  "Bash"
+];
+function applyClaudeReadOnlyChatEnv(env) {
+  return {
+    ...env,
+    POETIC_FEATURE_ENABLE_CLAUDE_ENHANCED: "1",
+    POETIC_CLAUDE_ENHANCED_TOOLS_PROFILE: "readonly",
+    POETIC_CLAUDE_ENHANCED_PERMISSION_MODE: env?.POETIC_CLAUDE_ENHANCED_PERMISSION_MODE ?? "dontAsk",
+    POETIC_CLAUDE_ENHANCED_RESTRICT_TOOLS: "1",
+    POETIC_CLAUDE_ENHANCED_USE_SUBAGENTS: "0",
+    POETIC_CLAUDE_ENHANCED_DISALLOWED_TOOLS: CLAUDE_READ_ONLY_CHAT_DISALLOWED_TOOLS.join(","),
+    POETIC_CLAUDE_SANDBOX_READONLY_WORKING_DIR: "1"
+  };
+}
+
+export {
+  _resetRestrictedEnvCache,
+  isRestrictedEnvironment,
+  _resetClaudeFallbackConfigDir,
+  ensureClaudeConfigDir,
+  applyClaudeReadOnlyChatEnv
+};
+//# sourceMappingURL=chunk-LKRAR3IH.js.map