@mrclrchtr/supi-code-intelligence 4.10.0 → 6.0.0

package/src/tool/code_orientation/result.ts

@@ -0,0 +1,248 @@
+import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
+import type { EvidenceListMetadata } from "../../analysis/evidence.ts";
+import type { ReadNextItem } from "../../analysis/read-next.ts";
+import type {
+  OrientationCandidate,
+  OrientationItem,
+  OrientationResultData,
+  OrientationSectionData,
+} from "../../session/orientation-types.ts";
+import type { TargetStoreEntry } from "../../session/target-store.ts";
+import {
+  assembledNextQueries,
+  assembledReadNext,
+  assembleToolResult,
+  type ResultSection,
+  type ToolResultAssembly,
+} from "../result/assembly.ts";
+import { createToolDisplaySection } from "../result/display.ts";
+import type {
+  ContextDetails,
+  OrientationSectionDetails,
+  ToolDisplaySection,
+} from "../result/types.ts";
+
+export interface OrientationDetailsInput {
+  readonly confidence: ConfidenceMode;
+  readonly task?: string | null;
+  readonly focusTarget?: string | null;
+  readonly requestedSections?: readonly string[];
+  readonly renderedSections?: readonly string[];
+  readonly omittedCount?: number;
+  readonly evidenceLists?: readonly EvidenceListMetadata[];
+  readonly sections?: readonly OrientationSectionData[];
+  readonly nextQueries: readonly string[];
+  readonly readNext?: readonly ReadNextItem[];
+  readonly target?: Readonly<TargetStoreEntry>;
+  readonly candidates?: readonly OrientationCandidate[];
+  readonly instructions?: OrientationResultData["instructions"];
+}
+
+export interface OrientationResultAssembly {
+  readonly assembled: ToolResultAssembly<OrientationResultData>;
+  readonly details: ContextDetails;
+  readonly displaySections: readonly ToolDisplaySection[];
+}
+
+/** Build structured candidate rows for an unresolved Orientation target. */
+export function orientationCandidateDisplaySections(
+  candidates: readonly OrientationCandidate[],
+  omittedCount = 0,
+): readonly ToolDisplaySection[] {
+  return [
+    createToolDisplaySection({
+      key: "orientation.candidates",
+      title: "Candidates",
+      items: candidates,
+      totalCount: candidates.length + omittedCount,
+      omittedCount,
+      format: (candidate) =>
+        `${candidate.rank}. ${candidate.name} (${candidate.kind ?? "unknown"}) — ${candidate.file}:${candidate.line}:${candidate.character} [${candidate.targetId}]`,
+    }),
+  ];
+}
+
+/** Assemble Orientation facts and shared result policy before rendering. */
+export function assembleOrientationResult(data: OrientationResultData): OrientationResultAssembly {
+  const sections = data.sections.map(toResultSection);
+  const evidenceLists = data.sections.flatMap((section) => section.evidenceLists);
+  const assembled = assembleToolResult({
+    data,
+    sections,
+    evidenceLists,
+    nextQueries: data.nextQueries,
+    readNext: data.readNext,
+    confidence: data.confidence,
+    provenance: uniqueProvenance(data.sections),
+  });
+  const details = assembleOrientationDetails({
+    confidence: assembled.confidence,
+    focusTarget: assembled.data.focusTarget,
+    requestedSections: assembled.data.requestedSections,
+    renderedSections: assembled.data.renderedSections,
+    omittedCount: assembled.totals.omittedCount,
+    evidenceLists: assembled.evidenceLists,
+    sections: assembled.data.sections,
+    nextQueries: assembledNextQueries(assembled),
+    readNext: assembledReadNext(assembled),
+    target: assembled.data.target,
+    instructions: assembled.data.instructions,
+  });
+
+  return {
+    assembled,
+    details,
+    displaySections: assembled.data.sections.map(orientationDisplaySection),
+  };
+}
+
+/** Project canonical Orientation facts into structured Tool details. */
+export function assembleOrientationDetails(input: OrientationDetailsInput): ContextDetails {
+  return {
+    confidence: input.confidence,
+    task: input.task ?? null,
+    focusTarget: input.focusTarget ?? null,
+    requestedSections: [...(input.requestedSections ?? [])],
+    renderedSections: [...(input.renderedSections ?? [])],
+    omittedCount: input.omittedCount ?? 0,
+    evidenceLists: input.evidenceLists ? [...input.evidenceLists] : undefined,
+    sections: input.sections?.map(toDetailsSection),
+    nextQueries: [...input.nextQueries],
+    readNext: input.readNext ? [...input.readNext] : undefined,
+    target: input.target ? { ...input.target } : undefined,
+    instructions: input.instructions,
+    candidates: input.candidates?.map((candidate) => ({
+      targetId: candidate.targetId,
+      name: candidate.name,
+      kind: candidate.kind,
+      container: candidate.container,
+      file: candidate.file,
+      line: candidate.line,
+      character: candidate.character,
+      rank: candidate.rank,
+    })),
+  };
+}
+
+function orientationDisplaySection(section: OrientationSectionData): ToolDisplaySection {
+  const items = section.items.filter((item) => item.kind !== "blank");
+  return createToolDisplaySection({
+    key: `orientation.${section.key}`,
+    title: section.title,
+    items,
+    totalCount: items.length,
+    omittedCount: 0,
+    partialReason:
+      section.reason ??
+      section.evidenceLists.find((evidence) => evidence.partialReason)?.partialReason,
+    format: formatOrientationItem,
+  });
+}
+
+function formatOrientationItem(item: OrientationItem): string {
+  switch (item.kind) {
+    case "paragraph":
+    case "list-item":
+    case "subheading":
+      return item.text;
+    case "code":
+      return item.lines.join(" ");
+    case "blank":
+      return "";
+  }
+}
+
+function toResultSection(section: OrientationSectionData): ResultSection {
+  return {
+    key: section.key,
+    title: section.title,
+    status: section.status,
+    items: [section.key],
+    confidence: section.confidence,
+    provenance: section.provenance,
+  };
+}
+
+function toDetailsSection(section: OrientationSectionData): OrientationSectionDetails {
+  return {
+    key: section.key,
+    title: section.title,
+    status: section.status,
+    reason: section.reason,
+    confidence: section.confidence,
+    provenance: section.provenance.map((provenance) => ({ ...provenance })),
+    evidenceLists: section.evidenceLists.map((evidence) => ({ ...evidence })),
+  };
+}
+
+function uniqueProvenance(sections: readonly OrientationSectionData[]) {
+  const seen = new Set<string>();
+  return sections.flatMap((section) =>
+    section.provenance.filter((provenance) => {
+      const key = `${provenance.source}:${provenance.capability ?? ""}:${provenance.detail ?? ""}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    }),
+  );
+}
+
+import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
+import { contextErrorResult } from "../result/errors.ts";
+import { renderOrientationResult } from "./markdown.ts";
+
+type OrientationOutcome = Awaited<ReturnType<CodeIntelToolExecCtx["session"]["orient"]>>;
+
+/** Assemble the final model-visible code_orientation result for one workflow outcome. */
+export function finishOrientationResult(outcome: OrientationOutcome): CodeIntelResult {
+  if (outcome.kind === "unavailable") throw new Error(outcome.reason);
+  if (outcome.kind === "invalid-input") {
+    return contextErrorResult(`**Error:** ${outcome.message}`, {
+      nextQueries: ["Choose an existing path, module, or precise target"],
+      message: outcome.message,
+    });
+  }
+  if (outcome.kind === "disambiguation" || outcome.kind === "kind-mismatch") {
+    const candidates = outcome.candidates ?? [];
+    const lines = [
+      outcome.kind === "kind-mismatch"
+        ? `# No Orientation target matched provider kind \`${outcome.requestedKind}\``
+        : "# Multiple Orientation targets",
+      "",
+    ];
+    for (const candidate of candidates) {
+      lines.push(
+        `${candidate.rank}. **${candidate.name}** (\`${candidate.kind ?? "unknown"}\`) — \`${candidate.file}\`:${candidate.line}:${candidate.character} — \`${candidate.targetId}\``,
+      );
+    }
+    const nextQueries =
+      outcome.kind === "kind-mismatch"
+        ? ["Retry without symbolKind, use an observed provider kind, or focus one handle"]
+        : ["Use one candidate handle as focus.target.handle"];
+    const details = assembleOrientationDetails({
+      confidence: "semantic",
+      omittedCount: outcome.omittedCount,
+      candidates,
+      nextQueries,
+    });
+    return {
+      content: lines.join("\n"),
+      details: {
+        type: "context",
+        data: details,
+        status: "completed",
+        displaySections: orientationCandidateDisplaySections(candidates, outcome.omittedCount),
+      },
+    };
+  }
+  const assembly = assembleOrientationResult(outcome.data);
+  return {
+    content: renderOrientationResult(assembly),
+    details: {
+      type: "context",
+      data: assembly.details,
+      status: "completed",
+      displaySections: assembly.displaySections,
+    },
+  };
+}

package/src/tool/code_orientation/spec.ts

@@ -0,0 +1,25 @@
+import { Type } from "typebox";
+import type { CodeIntelToolExecCtx } from "../../types/index.ts";
+import { MaxResultsParam, OrientationFocusParam } from "../schemas.ts";
+import { executeOrientationTool } from "./execute.ts";
+import { renderOrientationCall, renderOrientationResult } from "./tui.ts";
+
+export const CODE_ORIENTATION_TOOL_NAME = "code_orientation";
+export const CODE_ORIENTATION_TOOL_LABEL = "Code Orientation";
+
+/** Canonical provider-facing metadata for the code_orientation tool. */
+export const codeOrientationSpec = {
+  name: CODE_ORIENTATION_TOOL_NAME,
+  label: CODE_ORIENTATION_TOOL_LABEL,
+  parameters: Type.Object(
+    {
+      focus: Type.Optional(OrientationFocusParam),
+      maxResults: Type.Optional(MaxResultsParam),
+    },
+    { additionalProperties: false },
+  ),
+  run: (params: unknown, ctx: CodeIntelToolExecCtx) =>
+    executeOrientationTool(params as Parameters<typeof executeOrientationTool>[0], ctx),
+  renderCall: renderOrientationCall,
+  renderResult: renderOrientationResult,
+} as const;

package/src/tool/{orientation → code_orientation}/tui.ts

@@ -1,63 +1,79 @@
+/** TUI renderer for code_orientation. */
 import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import {
   type EvidenceEntry,
+  formatCallPath,
+  formatCallValue,
   formatEvidenceEntry,
   type ResultOptios,
   readEvidenceEntries,
+  renderDomainError,
+  renderDomainResult,
+  renderExecutionError,
   renderPartial,
+  renderStructuredDetailBody,
+  renderToolDisplaySections,
+  renderTruncationDisclosure,
+  type ToolRendererContext,
   type ToolResult,
 } from "../../ui/tui/common.ts";
 import type { CodeOrientationToolParams } from "./execute.ts";
 
-/** ── renderCall ────────────────────────────────────────────────── */
-
-export function renderOrientationCall(args: unknown, theme: Theme, _context: unknown): Text {
-  const params = (args ?? {}) as CodeOrientationToolParams;
-
+/** Render the compact code_orientation call header. */
+export function renderOrientationCall(
+  args: unknown,
+  theme: Theme,
+  _context: ToolRendererContext | undefined,
+): Text {
+  const params = (args ?? {}) as Partial<CodeOrientationToolParams>;
   let content = theme.fg("toolTitle", "code_orientation");
+  const focus = params.focus;
 
-  if (!params.focus) {
+  if (!focus || typeof focus !== "object") {
     content += ` ${theme.fg("muted", "workspace")}`;
-  } else if ("path" in params.focus) {
-    const focus = params.focus.path.split("/").pop() ?? params.focus.path;
-    content += ` ${theme.fg("accent", focus)}`;
-  } else if ("module" in params.focus) {
-    content += ` ${theme.fg("accent", params.focus.module)}`;
-  } else {
+  } else if ("path" in focus) {
+    const path = formatCallPath(focus.path);
+    content += ` ${theme.fg("accent", path ?? "path?")}`;
+  } else if ("module" in focus) {
+    content += ` ${theme.fg("accent", formatCallValue(focus.module) ?? "module?")}`;
+  } else if ("target" in focus) {
     content += ` ${theme.fg("accent", "target")}`;
   }
 
   return new Text(content, 0, 0);
 }
 
-/** ── renderResult ──────────────────────────────────────────────── */
-
+/** Render code_orientation progress, status, and structured result details. */
 export function renderOrientationResult(
   result: ToolResult,
   options: ResultOptios,
   theme: Theme,
-  _context: unknown,
+  context: ToolRendererContext | undefined,
 ): Container | Text {
-  if (options.isPartial) {
-    return renderPartial("Orienting…", theme);
-  }
+  if (options.isPartial) return renderPartial("Orienting…", theme);
 
-  const container = new Container();
   const data =
     result.details?.type === "context" ? (result.details.data as Record<string, unknown>) : null;
   const markdownText = result.content.find((c) => c.type === "text")?.text ?? "";
 
-  if (result.isError) {
-    container.addChild(new Text(theme.fg("error", "code_orientation failed"), 0, 0));
-    return container;
-  }
+  const executionError = renderExecutionError(context, "code_orientation failed", theme);
+  if (executionError) return executionError;
+  const domainError = renderDomainError(result, theme);
+  if (domainError) return renderDomainResult(result, options, theme, domainError);
 
   if (!options.expanded) {
-    container.addChild(buildCompactSummary(data, theme));
-    return container;
+    const compact = buildCompactSummary(data, theme);
+    const truncation = renderTruncationDisclosure(result, theme);
+    if (!truncation) return compact;
+    const compactContainer = new Container();
+    compactContainer.addChild(compact);
+    compactContainer.addChild(new Spacer(1));
+    compactContainer.addChild(truncation);
+    return compactContainer;
   }
 
+  const container = new Container();
   container.addChild(buildHeader(data, theme));
 
   const target = data?.target as Record<string, unknown> | undefined;
@@ -67,7 +83,7 @@ export function renderOrientationResult(
       new Text(
         theme.fg(
           "muted",
-          `${String(target.name ?? "symbol")} — ${String(target.file ?? "")}:${String(target.displayLine ?? "")}`,
+          `${formatCallValue(target.name) ?? "symbol"} — ${formatCallPath(target.file) ?? ""}:${String(target.displayLine ?? "")}`,
         ),
         0,
         0,
@@ -75,10 +91,13 @@ export function renderOrientationResult(
     );
   }
 
-  const sections = (data?.renderedSections as string[] | undefined) ?? [];
-  if (sections.length > 0) {
+  renderToolDisplaySections(container, result.details?.displaySections, theme);
+  renderStructuredDetailBody(container, data ?? undefined, theme);
+
+  const truncation = renderTruncationDisclosure(result, theme);
+  if (truncation) {
     container.addChild(new Spacer(1));
-    container.addChild(new Text(theme.fg("dim", `Sections: ${sections.join(", ")}`), 0, 0));
+    container.addChild(truncation);
   }
 
   if (markdownText) {
@@ -90,8 +109,6 @@ export function renderOrientationResult(
   return container;
 }
 
-/** ── Helpers ───────────────────────────────────────────────────── */
-
 function buildCompactSummary(data: Record<string, unknown> | null, theme: Theme): Text {
   if (!data) return new Text(theme.fg("dim", "No orientation"), 0, 0);
 
@@ -112,9 +129,7 @@ function summarySegments(
 ): string[] {
   const segments: string[] = [];
   const evidence = orientationEvidence(data);
-  if (evidence) {
-    segments.push(theme.fg(badgeColor, theme.bold(formatEvidenceEntry(evidence))));
-  }
+  if (evidence) segments.push(theme.fg(badgeColor, theme.bold(formatEvidenceEntry(evidence))));
 
   const confidence = typeof data.confidence === "string" ? data.confidence : "";
   if (confidence && confidence !== "unavailable") {
@@ -122,7 +137,8 @@ function summarySegments(
   }
 
   const target = data.target as Record<string, unknown> | undefined;
-  if (target?.name) segments.push(theme.fg("muted", String(target.name)));
+  const targetName = formatCallValue(target?.name);
+  if (targetName) segments.push(theme.fg("muted", targetName));
 
   return segments;
 }

package/src/tool/code_refactor_apply/execute.ts

@@ -0,0 +1,17 @@
+/** Thin Pi adapter for session-owned refactor application. */
+
+import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
+import { toWorkflowControl } from "../infra/workflow-control.ts";
+import { finishRefactorApplyResult } from "./result.ts";
+
+export interface CodeRefactorApplyToolParams {
+  planId: string;
+}
+
+export async function executeRefactorApplyTool(
+  params: CodeRefactorApplyToolParams,
+  ctx: CodeIntelToolExecCtx,
+): Promise<CodeIntelResult> {
+  const outcome = await ctx.session.applyRefactor(params, toWorkflowControl(ctx));
+  return finishRefactorApplyResult(outcome);
+}

package/src/tool/code_refactor_apply/guidance.ts

@@ -0,0 +1,5 @@
+export const toolDescription = "Apply one stored refactor plan by planId.";
+
+export const promptSnippet = "apply a fresh stored refactor plan";
+
+export const promptGuidelines: string[] = [];

package/src/tool/{refactor-apply/execute.ts → code_refactor_apply/result.ts}

@@ -1,24 +1,19 @@
-/** Thin Pi adapter for session-owned refactor application. */
+/** Result assembly for code_refactor_apply. */
 
 import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
-import { toWorkflowControl } from "../infra/workflow-control.ts";
-import { renderRefactorApplyResult } from "../refactor-plan/markdown.ts";
+import { renderRefactorApplyResult } from "../refactor-markdown.ts";
 import { searchErrorResult } from "../result/errors.ts";
 import { assembleRefactorApplyDetails } from "../result/refactor.ts";
 
-export interface CodeRefactorApplyToolParams {
-  planId: string;
-}
+type RefactorApplyOutcome = Awaited<ReturnType<CodeIntelToolExecCtx["session"]["applyRefactor"]>>;
 
-export async function executeRefactorApplyTool(
-  params: CodeRefactorApplyToolParams,
-  ctx: CodeIntelToolExecCtx,
-): Promise<CodeIntelResult> {
-  const outcome = await ctx.session.applyRefactor(params, toWorkflowControl(ctx));
+/** Assemble the final model-visible code_refactor_apply result for one workflow outcome. */
+export function finishRefactorApplyResult(outcome: RefactorApplyOutcome): CodeIntelResult {
   if (outcome.kind === "unavailable") throw new Error(outcome.reason);
   if (outcome.kind === "invalid-input") {
     return searchErrorResult(`**Error:** ${outcome.message}`, {
       nextQueries: ["Generate a fresh plan with code_refactor_plan"],
+      message: outcome.message,
     });
   }
 
@@ -28,6 +23,8 @@ export async function executeRefactorApplyTool(
     details: {
       type: "search",
       data: assembly.details,
+      status: "completed",
+      displaySections: assembly.displaySections,
     },
   };
 }

package/src/tool/code_refactor_apply/spec.ts

@@ -0,0 +1,26 @@
+import { Type } from "typebox";
+import type { CodeIntelToolExecCtx } from "../../types/index.ts";
+import { executeRefactorApplyTool } from "./execute.ts";
+import { renderRefactorApplyCall, renderRefactorApplyResult } from "./tui.ts";
+
+export const CODE_REFACTOR_APPLY_TOOL_NAME = "code_refactor_apply";
+export const CODE_REFACTOR_APPLY_TOOL_LABEL = "Code Refactor Apply";
+
+/** Canonical provider-facing metadata for the code_refactor_apply tool. */
+export const codeRefactorApplySpec = {
+  name: CODE_REFACTOR_APPLY_TOOL_NAME,
+  label: CODE_REFACTOR_APPLY_TOOL_LABEL,
+  parameters: Type.Object(
+    {
+      planId: Type.String({
+        description: "planId returned by code_refactor_plan.",
+        minLength: 1,
+      }),
+    },
+    { additionalProperties: false },
+  ),
+  run: (params: unknown, ctx: CodeIntelToolExecCtx) =>
+    executeRefactorApplyTool(params as Parameters<typeof executeRefactorApplyTool>[0], ctx),
+  renderCall: renderRefactorApplyCall,
+  renderResult: renderRefactorApplyResult,
+} as const;

package/src/tool/code_refactor_apply/tui.ts

@@ -0,0 +1,73 @@
+/** TUI renderer for code_refactor_apply. */
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import {
+  formatCallValue,
+  type ResultOptios,
+  renderDomainError,
+  renderDomainResult,
+  renderExecutionError,
+  renderMarkdownDetail,
+  renderPartial,
+  renderToolDisplaySections,
+  renderTruncationDisclosure,
+  type ToolRendererContext,
+  type ToolResult,
+} from "../../ui/tui/common.ts";
+
+/** Render the compact code_refactor_apply call header. */
+export function renderRefactorApplyCall(
+  args: unknown,
+  theme: Theme,
+  _context: ToolRendererContext | undefined,
+): Text {
+  const params = (args ?? {}) as { planId?: unknown };
+  const planId = formatCallValue(params.planId);
+  const suffix = planId ? ` ${theme.fg("accent", planId)}` : "";
+  return new Text(`${theme.fg("toolTitle", "code_refactor_apply")}${suffix}`, 0, 0);
+}
+
+/** Render code_refactor_apply progress, status, and structured result details. */
+export function renderRefactorApplyResult(
+  result: ToolResult,
+  options: ResultOptios,
+  theme: Theme,
+  context: ToolRendererContext | undefined,
+): Container | Text {
+  if (options.isPartial) return renderPartial("Applying…", theme);
+
+  const executionError = renderExecutionError(context, "code_refactor_apply failed", theme);
+  if (executionError) return executionError;
+  const domainError = renderDomainError(result, theme);
+  if (domainError) return renderDomainResult(result, options, theme, domainError);
+
+  if (!options.expanded) {
+    const applied =
+      result.details?.status === "completed" ||
+      (result.details?.status === undefined && result.details?.data?.confidence === "semantic");
+    const status = new Text(
+      applied
+        ? theme.fg("success", theme.bold("Plan applied"))
+        : theme.fg("error", "Refactor apply failed"),
+      0,
+      0,
+    );
+    const truncation = renderTruncationDisclosure(result, theme);
+    if (!truncation) return status;
+    const container = new Container();
+    container.addChild(status);
+    container.addChild(new Spacer(1));
+    container.addChild(truncation);
+    return container;
+  }
+
+  const container = new Container();
+  renderToolDisplaySections(container, result.details?.displaySections, theme);
+  const truncation = renderTruncationDisclosure(result, theme);
+  if (truncation) {
+    container.addChild(new Spacer(1));
+    container.addChild(truncation);
+  }
+  renderMarkdownDetail(container, result, theme);
+  return container;
+}

package/src/tool/code_refactor_plan/execute.ts

@@ -0,0 +1,27 @@
+/** Thin Pi adapter for session-owned refactor planning. */
+
+import type {
+  RefactorOperationInput,
+  RefactorPlanWorkflowInput,
+} from "../../session/refactor-types.ts";
+import type { RefactorTargetInput } from "../../session/target-input.ts";
+import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
+import { toWorkflowControl } from "../infra/workflow-control.ts";
+import { finishRefactorPlanResult } from "./result.ts";
+
+export interface CodeRefactorPlanToolParams {
+  target: RefactorTargetInput;
+  operation: RefactorOperationInput;
+}
+
+export async function executeRefactorPlanTool(
+  params: CodeRefactorPlanToolParams,
+  ctx: CodeIntelToolExecCtx,
+  _invokedAs: "code_refactor_plan" = "code_refactor_plan",
+): Promise<CodeIntelResult> {
+  const outcome = await ctx.session.planRefactor(
+    params as RefactorPlanWorkflowInput,
+    toWorkflowControl(ctx),
+  );
+  return finishRefactorPlanResult(outcome, ctx.cwd);
+}

package/src/tool/code_refactor_plan/guidance.ts

@@ -0,0 +1,8 @@
+export const toolDescription =
+  "Preview one semantic rename or extraction and return a planId without mutating files.";
+
+export const promptSnippet = "preview a precise semantic refactor";
+
+export const promptGuidelines = [
+  "Use code_refactor_plan for preview only, then call code_refactor_apply with its planId.",
+];