pi-declaw 0.2.0

package/src/adapters/command.ts

@@ -0,0 +1,203 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { BorderedLoader } from "@earendil-works/pi-coding-agent";
+import type { StyleCatalog } from "../domain/styles.ts";
+import { abortable, ENTRY_TYPE, MAX_INPUT_CHARS, PlainError, POLICY_VERSION, REWRITE_THINKING, TIMEOUT_MS, type PlainEntry } from "../domain/rewrite.ts";
+import { completedText, latestAnswer } from "./pi.ts";
+import { executeRewrite } from "../application/rewrite.ts";
+import { chooseModel, completeRewrite, supportsLowThinking } from "./model.ts";
+import { readModelChoice, readPluginStatuses, readStyleChoice, savePluginStatuses, saveStyleChoice } from "./settings.ts";
+import { isStyleId } from "../domain/styles.ts";
+
+export interface DeclawCommandDependencies {
+  readonly pi: ExtensionAPI;
+  readonly catalog: StyleCatalog;
+  readonly settingsPath: string;
+  readonly stylePath: string;
+  readonly pluginPath: string;
+}
+
+export interface DeclawCommandController {
+  readonly command: Parameters<ExtensionAPI["registerCommand"]>[1];
+  readonly cancel: () => void;
+}
+
+type Result = { text: string } | { error: string } | { cancelled: true } | { stale: true };
+
+/** Pi command adapter. It translates UI/session effects into application ports. */
+export function createDeclawCommand({ pi, catalog, settingsPath, stylePath, pluginPath }: DeclawCommandDependencies): DeclawCommandController {
+  let active: AbortController | undefined;
+  let pluginStatuses: Record<string, "active" | "disabled"> = {};
+  let pluginStatusesLoaded = false;
+
+  const syncPluginStatuses = async (repair = false) => {
+    if (!pluginStatusesLoaded) {
+      try {
+        pluginStatuses = await readPluginStatuses(pluginPath);
+      } catch (error) {
+        if (!repair) throw error;
+        pluginStatuses = {};
+      }
+      pluginStatusesLoaded = true;
+    }
+    for (const record of catalog.listPlugins()) {
+      const status = pluginStatuses[record.plugin.id];
+      if (status && status !== record.status) catalog.setPluginStatus(record.plugin.id, status);
+    }
+  };
+
+  const cancel = () => active?.abort();
+  const command: Parameters<ExtensionAPI["registerCommand"]>[1] = {
+    description: "Rewrite the latest answer; /declaw style selects a style, /declaw model selects its model",
+    getArgumentCompletions: (prefix: string) => {
+      const items = [
+        { value: "model", label: "model", description: "Choose the rewrite model (low thinking)" },
+        { value: "style", label: "style", description: "Choose the saved rewrite style" },
+        { value: "list", label: "list", description: "List installed Declaw plugins and statuses" },
+        { value: "manage", label: "manage", description: "Enable or disable Declaw plugins" },
+        ...catalog.activeStyleIds().map((id) => ({ value: id, label: id, description: `Rewrite once with ${catalog.get(id)!.style.name}` })),
+      ].filter((item) => item.value.startsWith(prefix));
+      return items.length ? items : null;
+    },
+    handler: async (args, ctx) => {
+      if (ctx.mode !== "tui") {
+        if (ctx.hasUI) ctx.ui.notify("/declaw currently requires Pi's terminal UI.", "warning");
+        return;
+      }
+      const command = args.trim();
+      if (command && command !== "model" && command !== "style" && command !== "list" && command !== "manage" && !isStyleId(command)) {
+        ctx.ui.notify("Use /declaw to rewrite, /declaw style, /declaw model, /declaw list, or /declaw manage.", "info");
+        return;
+      }
+      if (active || !ctx.isIdle()) {
+        ctx.ui.notify("Wait for the current request to finish, then use /declaw.", "info");
+        return;
+      }
+      const controller = new AbortController();
+      active = controller;
+      const sessionId = ctx.sessionManager.getSessionId();
+      let timedOut = false;
+      let timeout: ReturnType<typeof setTimeout> | undefined;
+      try {
+        await syncPluginStatuses(command === "manage");
+        if (command === "model") {
+          await chooseModel(ctx, settingsPath, controller.signal);
+          return;
+        }
+        if (command === "list") {
+          const lines = catalog.listPlugins().map(({ plugin, status }) => {
+            const styles = plugin.styles.map((style) => `${style.name} (${style.id})`).join(", ");
+            return `${plugin.name} [${plugin.id}] · ${status} · ${styles}`;
+          });
+          ctx.ui.notify(lines.join("\n") || "No Declaw plugins are installed.", "info");
+          return;
+        }
+        if (command === "manage") {
+          const leafId = ctx.sessionManager.getLeafId();
+          const plugins = catalog.listPlugins();
+          const labels = plugins.map(({ plugin, status }) => `${plugin.name} (${plugin.id}) · ${status}`);
+          const selection = await ctx.ui.select("Declaw plugins", labels, { signal: controller.signal });
+          if (!selection || controller.signal.aborted || !ctx.isIdle() ||
+              ctx.sessionManager.getSessionId() !== sessionId || ctx.sessionManager.getLeafId() !== leafId) return;
+          const selected = plugins[labels.indexOf(selection)];
+          if (!selected) return;
+          const status = selected.status === "active" ? "disabled" : "active";
+          catalog.setPluginStatus(selected.plugin.id, status);
+          pluginStatuses[selected.plugin.id] = status;
+          await savePluginStatuses(pluginPath, pluginStatuses);
+          if (!controller.signal.aborted) ctx.ui.notify(`${selected.plugin.name} is now ${status}.`, "info");
+          return;
+        }
+        if (command === "style") {
+          const leafId = ctx.sessionManager.getLeafId();
+          const current = await readStyleChoice(stylePath, catalog).catch(() => undefined);
+          if (controller.signal.aborted) return;
+          const styleIds = catalog.activeStyleIds();
+          const labels = styleIds.map((id) => `${catalog.get(id)!.style.name} (${id})${id === current ? "  (current)" : ""}`);
+          const selection = await ctx.ui.select("Declaw rewrite style", labels, { signal: controller.signal });
+          if (!selection || controller.signal.aborted || !ctx.isIdle() ||
+              ctx.sessionManager.getSessionId() !== sessionId || ctx.sessionManager.getLeafId() !== leafId) return;
+          const style = styleIds[labels.indexOf(selection)];
+          if (!style) return;
+          await saveStyleChoice(stylePath, style, catalog);
+          if (!controller.signal.aborted) ctx.ui.notify(`/declaw now uses ${catalog.get(style)!.style.name}. Model settings are unchanged.`, "info");
+          return;
+        }
+        const source = latestAnswer(ctx.sessionManager.getBranch());
+        if (!source) {
+          ctx.ui.notify("No completed assistant answer is available to rewrite.", "warning");
+          return;
+        }
+        if (source.text.length > MAX_INPUT_CHARS) {
+          ctx.ui.notify("This answer is too long for /declaw (32,000 characters maximum).", "warning");
+          return;
+        }
+        const style = isStyleId(command) && command ? command : await readStyleChoice(stylePath, catalog);
+        const styleRecord = catalog.get(style);
+        if (!styleRecord) {
+          ctx.ui.notify(`The Declaw style ${style} is unavailable or disabled. Run /declaw style or /declaw manage.`, "warning");
+          return;
+        }
+        const choice = await readModelChoice(settingsPath);
+        if (controller.signal.aborted) return;
+        const model = ctx.modelRegistry.find(choice.provider, choice.modelId);
+        if (!model) {
+          ctx.ui.notify(`The /declaw model ${choice.provider}/${choice.modelId} is unavailable. Run /declaw model to choose another.`, "warning");
+          return;
+        }
+        if (!ctx.modelRegistry.hasConfiguredAuth(model)) {
+          ctx.ui.notify("Sign in to the selected provider with /login, or choose another model with /declaw model.", "warning");
+          return;
+        }
+        if (!supportsLowThinking(model)) {
+          ctx.ui.notify("The selected model lacks low thinking support. Run /declaw model to choose another.", "warning");
+          return;
+        }
+        timeout = setTimeout(() => { timedOut = true; controller.abort(); }, TIMEOUT_MS);
+        const result = await ctx.ui.custom<Result | undefined>((tui, theme, _keys, done) => {
+          const loader = new BorderedLoader(tui, theme, `Rewriting with ${styleRecord.style.name} · ${model.id} · ${REWRITE_THINKING} thinking…`);
+          loader.onAbort = () => controller.abort();
+          const work = executeRewrite(source, controller.signal, {
+            complete: async (masked, requestSignal) => {
+              requestSignal.throwIfAborted();
+              const response = await completeRewrite(ctx.modelRegistry, model, masked, requestSignal, style, catalog);
+              const text = completedText(response);
+              if (text === undefined) throw new PlainError("The model did not return a complete rewrite. The original is unchanged.");
+              return text;
+            },
+            isCurrent: (candidate) => ctx.sessionManager.getSessionId() === sessionId && ctx.isIdle() &&
+              latestAnswer(ctx.sessionManager.getBranch())?.id === candidate.id,
+            publish: ({ sourceEntryId, text }) => pi.appendEntry<PlainEntry>(ENTRY_TYPE, {
+              version: POLICY_VERSION, sourceEntryId, text,
+              model: `${model.provider}/${model.id}`, thinkingLevel: REWRITE_THINKING,
+              style, styleName: styleRecord.style.name, stylePlugin: styleRecord.pluginId,
+              styleVersion: styleRecord.pluginVersion,
+            }),
+          });
+          void abortable(work, controller.signal).then(
+            (accepted) => done(accepted.kind === "accepted" ? { text: accepted.text } : { stale: true }),
+            (error: unknown) => done(controller.signal.aborted ? { cancelled: true } :
+              { error: error instanceof PlainError ? error.message : "The rewrite failed. The original is unchanged." }),
+          );
+          return loader;
+        });
+        if (controller.signal.aborted || !result || "cancelled" in result || "stale" in result) {
+          if (active === controller && !controller.signal.aborted) controller.abort();
+          if (timedOut) ctx.ui.notify("The rewrite timed out after 60 seconds. The original is unchanged.", "warning");
+          return;
+        }
+        if ("error" in result) {
+          ctx.ui.notify(result.error, "warning");
+          return;
+        }
+      } catch (error) {
+        if (!controller.signal.aborted) ctx.ui.notify(error instanceof PlainError ? error.message : "The /declaw request failed. The original is unchanged.", "warning");
+      } finally {
+        clearTimeout(timeout);
+        controller.abort();
+        if (active === controller) active = undefined;
+      }
+    },
+  };
+
+  return { command, cancel };
+}

package/src/adapters/model.ts

@@ -0,0 +1,53 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { PlainError } from "../domain/rewrite.ts";
+import { isolatedRequest } from "./pi.ts";
+import { readModelChoice, saveModelChoice } from "./settings.ts";
+import type { StyleCatalog, StyleId } from "../domain/styles.ts";
+
+/** Exclude non-reasoning models and explicit remappings away from low. */
+export function supportsLowThinking(model: Model<Api>): boolean {
+  return model.reasoning && (model.thinkingLevelMap?.low === undefined || model.thinkingLevelMap.low === "low");
+}
+
+export async function chooseModel(ctx: ExtensionCommandContext, settingsPath: string, signal: AbortSignal): Promise<void> {
+  const models = ctx.modelRegistry.getAvailable()
+    .filter((model) => supportsLowThinking(model) && ctx.modelRegistry.hasConfiguredAuth(model))
+    .sort((a, b) => `${a.provider}/${a.id}`.localeCompare(`${b.provider}/${b.id}`));
+  if (models.length === 0) {
+    ctx.ui.notify("No authenticated models with low thinking support are available. Use /login or refresh the model catalog.", "warning");
+    return;
+  }
+  // The picker must also be usable to repair an invalid settings file.
+  const current = await readModelChoice(settingsPath).catch(() => undefined);
+  if (signal.aborted) return;
+  const labels = models.map((model) => `${model.provider}/${model.id}` +
+    (model.provider === current?.provider && model.id === current.modelId ? "  (current)" : ""));
+  const selection = await ctx.ui.select("Plain rewrite model · low thinking", labels, { signal });
+  if (!selection || signal.aborted) return;
+  const model = models[labels.indexOf(selection)];
+  if (!model) return;
+  await saveModelChoice(settingsPath, { provider: model.provider, modelId: model.id });
+  if (!signal.aborted) ctx.ui.notify(`/declaw now uses ${model.provider}/${model.id} with low thinking. Main agent settings are unchanged.`, "info");
+}
+
+/** Use Pi's provider-neutral low-thinking conversion without borrowing main-agent context. */
+export async function completeRewrite(
+  registry: ExtensionContext["modelRegistry"], model: Model<Api>, masked: string, signal: AbortSignal,
+  style?: StyleId, catalog?: StyleCatalog,
+) {
+  signal.throwIfAborted();
+  const provider = registry.getProvider(model.provider);
+  if (!provider) throw new PlainError("The selected provider is unavailable. Run /declaw model to choose another.");
+  // Resolves Pi's existing auth, including OAuth refresh, model headers, base URL and ambient env.
+  const auth = await registry.getApiKeyAndHeaders(model);
+  signal.throwIfAborted();
+  if (!auth.ok) throw new PlainError("Authentication for the /declaw model failed. Check /login or choose another model with /declaw model.");
+  const { context, options } = isolatedRequest(masked, model, signal, style, catalog);
+  return provider.streamSimple(auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model, context, {
+    ...options,
+    apiKey: auth.apiKey,
+    headers: auth.headers,
+    env: auth.env,
+  }).result();
+}

package/src/adapters/pi.ts

@@ -0,0 +1,56 @@
+import { randomUUID } from "node:crypto";
+import type { Api, AssistantMessage, Context, Model, SimpleStreamOptions } from "@earendil-works/pi-ai";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import { buildStyleRequest, DEFAULT_STYLE_ID, type StyleCatalog, type StyleId } from "../domain/styles.ts";
+import { BUILTIN_CATALOG } from "../plugins/built-in/catalog.ts";
+
+/** Composed default prompt exposed for integration diagnostics and compatibility. */
+export const SYSTEM_PROMPT = buildStyleRequest("", DEFAULT_STYLE_ID, BUILTIN_CATALOG).system;
+
+/** Pi's message shape is normalized at the adapter edge. */
+export function completedText(message: AssistantMessage): string | undefined {
+  if (message.stopReason !== "stop" || message.errorMessage ||
+      message.content.some((part) => part.type === "toolCall")) return undefined;
+  const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n\n");
+  return text.trim() ? text : undefined;
+}
+
+/** Reads only the latest assistant message; a failed latest answer is authoritative. */
+export function latestAnswer(branch: readonly SessionEntry[]): { id: string; text: string } | undefined {
+  for (let i = branch.length - 1; i >= 0; i--) {
+    const entry = branch[i];
+    if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+    const text = completedText(entry.message);
+    return text === undefined ? undefined : { id: entry.id, text };
+  }
+  return undefined;
+}
+
+/** Converts the domain rewrite request into Pi's isolated, tool-free provider context. */
+export function isolatedRequest(
+  maskedAnswer: string,
+  model: Model<Api>,
+  signal: AbortSignal,
+  style: StyleId = DEFAULT_STYLE_ID,
+  catalog: StyleCatalog = BUILTIN_CATALOG,
+): { context: Context; options: SimpleStreamOptions } {
+  const request = buildStyleRequest(maskedAnswer, style, catalog);
+  const context: Context = {
+    systemPrompt: request.system,
+    messages: [{ role: "user", content: request.user, timestamp: Date.now() }],
+    tools: [],
+  };
+  return {
+    context,
+    options: {
+      signal,
+      sessionId: randomUUID(),
+      cacheRetention: "none" as const,
+      reasoning: "low",
+      maxRetries: 0,
+      transport: "sse",
+      timeoutMs: 60_000,
+      maxTokens: Math.min(16_384, model.maxTokens),
+    },
+  };
+}

package/src/adapters/settings.ts

@@ -0,0 +1,117 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { PlainError, REWRITE_MODEL, REWRITE_PROVIDER } from "../domain/rewrite.ts";
+import { DEFAULT_STYLE_ID, isStyleId, type PluginStatus, type StyleCatalog, type StyleId } from "../domain/styles.ts";
+import { BUILTIN_CATALOG } from "../plugins/built-in/catalog.ts";
+
+export interface ModelChoice {
+  provider: string;
+  modelId: string;
+}
+
+export const DEFAULT_MODEL: ModelChoice = { provider: REWRITE_PROVIDER, modelId: REWRITE_MODEL };
+
+export async function readModelChoice(path: string): Promise<ModelChoice> {
+  let contents: string;
+  try {
+    contents = await readFile(path, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return { ...DEFAULT_MODEL };
+    throw new PlainError("Could not read /declaw settings. Check the permissions on its settings file.");
+  }
+  try {
+    const value = JSON.parse(contents);
+    if (value?.version !== 1 || typeof value.provider !== "string" || !value.provider.trim() ||
+        typeof value.modelId !== "string" || !value.modelId.trim()) throw new Error("invalid-settings");
+    return { provider: value.provider, modelId: value.modelId };
+  } catch {
+    throw new PlainError("The /declaw settings file is invalid. Run /declaw model to choose and save a model again.");
+  }
+}
+
+export async function readStyleChoice(path: string, catalog: StyleCatalog = BUILTIN_CATALOG): Promise<StyleId> {
+  let contents: string;
+  try {
+    contents = await readFile(path, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return DEFAULT_STYLE_ID;
+    throw new PlainError("Could not read /declaw style settings. Check the permissions on its style file.");
+  }
+  try {
+    const value = JSON.parse(contents);
+    if (value?.version !== 1 || typeof value.style !== "string" || !isStyleId(value.style) ||
+        !catalog.has(value.style, { includeDisabled: true })) {
+      throw new Error("invalid-style");
+    }
+    return value.style;
+  } catch {
+    throw new PlainError("The /declaw style settings file is invalid. Run /declaw style to choose and save a style again.");
+  }
+}
+
+export async function saveStyleChoice(path: string, style: StyleId, catalog: StyleCatalog = BUILTIN_CATALOG): Promise<void> {
+  if (!isStyleId(style) || !catalog.has(style, { includeDisabled: true })) throw new PlainError("Unknown /declaw style. Run /declaw style to choose an available style.");
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(temporary, JSON.stringify({ version: 1, style }, null, 2) + "\n", { mode: 0o600, flag: "wx" });
+    await rename(temporary, path);
+  } catch {
+    throw new PlainError("Could not save the /declaw style choice. Check the permissions on its settings directory.");
+  } finally {
+    await rm(temporary, { force: true }).catch(() => {});
+  }
+}
+
+export type PluginStatuses = Record<string, PluginStatus>;
+
+export async function readPluginStatuses(path: string): Promise<PluginStatuses> {
+  let contents: string;
+  try {
+    contents = await readFile(path, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw new PlainError("Could not read /declaw plugin settings. Check the permissions on its settings file.");
+  }
+  try {
+    const value = JSON.parse(contents);
+    if (value?.version !== 1 || value.plugins === null || typeof value.plugins !== "object" || Array.isArray(value.plugins)) {
+      throw new Error("invalid-plugin-settings");
+    }
+    const statuses: PluginStatuses = {};
+    for (const [id, status] of Object.entries(value.plugins)) {
+      if (!isStyleId(id) || (status !== "active" && status !== "disabled")) throw new Error("invalid-plugin-settings");
+      statuses[id] = status as PluginStatus;
+    }
+    return statuses;
+  } catch {
+    throw new PlainError("The /declaw plugin settings file is invalid. Run /declaw manage to repair it.");
+  }
+}
+
+export async function savePluginStatuses(path: string, statuses: PluginStatuses): Promise<void> {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(temporary, JSON.stringify({ version: 1, plugins: statuses }, null, 2) + "\n", { mode: 0o600, flag: "wx" });
+    await rename(temporary, path);
+  } catch {
+    throw new PlainError("Could not save the /declaw plugin settings. Check the permissions on its settings directory.");
+  } finally {
+    await rm(temporary, { force: true }).catch(() => {});
+  }
+}
+
+export async function saveModelChoice(path: string, choice: ModelChoice): Promise<void> {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(temporary, JSON.stringify({ version: 1, ...choice }, null, 2) + "\n", { mode: 0o600, flag: "wx" });
+    await rename(temporary, path);
+  } catch {
+    throw new PlainError("Could not save the /declaw model choice. Check the permissions on its settings directory.");
+  } finally {
+    await rm(temporary, { force: true }).catch(() => {});
+  }
+}

package/src/application/rewrite.ts

@@ -0,0 +1,39 @@
+import { rewriteAnswer } from "../domain/rewrite.ts";
+
+export interface SourceAnswer {
+  readonly id: string;
+  readonly text: string;
+}
+
+export interface PublishedRewrite {
+  readonly sourceEntryId: string;
+  readonly text: string;
+}
+
+export interface RewriteExecutionPorts {
+  /** Model adapter. It receives masked text and must honor cancellation. */
+  complete: (maskedAnswer: string, signal: AbortSignal) => Promise<string>;
+  /** Application adapter decides whether the source is still publishable. */
+  isCurrent: (source: SourceAnswer) => boolean;
+  /** Display/session adapter persists an accepted display projection. */
+  publish: (rewrite: PublishedRewrite) => void;
+}
+
+export type RewriteExecutionResult =
+  | { kind: "accepted"; sourceEntryId: string; text: string }
+  | { kind: "stale" };
+
+/**
+ * Application use case for the effectful rewrite boundary.
+ * Validation happens before publication; stale work is discarded without a write.
+ */
+export async function executeRewrite(
+  source: SourceAnswer,
+  signal: AbortSignal,
+  ports: RewriteExecutionPorts,
+): Promise<RewriteExecutionResult> {
+  const text = await rewriteAnswer(source.text, (maskedAnswer) => ports.complete(maskedAnswer, signal));
+  if (signal.aborted || !ports.isCurrent(source)) return { kind: "stale" };
+  ports.publish({ sourceEntryId: source.id, text });
+  return { kind: "accepted", sourceEntryId: source.id, text };
+}

package/src/domain/preservation.ts

@@ -0,0 +1,62 @@
+// Adapted from scowalt/paseo-plain, commit 35e63ee2e5f17a5bad40a8772c84fa5f21a8678f.
+// Copyright 2026 scowalt. Apache-2.0: src/plugins/built-in/paseo-plain/upstream/LICENSE; notices: upstream/NOTICE.
+// Local change: distinguish English make/go prose from standalone or explicitly run commands.
+// One pass over prose: never run these expressions over generated placeholders.
+const technical = /(`+)[^\n]*?\1|(?:^|(?<=\s))(?:sudo\s+)?(?:npm|npx|pnpm|bunx?|yarn|git|gh|curl|wget|ssh|docker|kubectl|paseo|systemctl|apt|brew|python3?|node|bash|pwsh|pip3?|cargo|dotnet)\s+[^\n]+|(?:^ {0,3}(?:\$ )?|(?<=\b[Rr]an )|(?<=\b[Rr]un )|(?<=\b[Ee]xecute )|(?<=\b[Ee]xecuted ))(?:make|go)\s+[^\n]+|^\s*(?:Error|TypeError|ReferenceError|SyntaxError|fatal):[^\n]+|\[[^\]\n]*\]\([^\n)]*\)|https?:\/\/[^\s<>]+|(?:[A-Za-z]:[\\/]|~\/|\.{1,2}\/|\/)[^\s<>"'`]+|\b(?:[\w.@-]+[\/\\])+[\w.@/-]+|\b[\w.-]+\.(?:json|ya?ml|toml|tsx?|jsx?|py|md|sh|ps1|go|rs|log|txt|sql|css|html)\b|"[^"\n]+"|“[^”\n]+”|(?<!\w)'[^'\n]+'(?!\w)|(?<!\w)[+-]?\d+(?:[.,:]\d+)*(?:%|\b)/gm;
+
+/** Copy protected spans exactly; reject damaged, duplicated, or reordered placeholders. */
+export async function rewriteText(original: string, complete: (masked: string) => Promise<string>): Promise<string> {
+  const parts: string[] = [];
+  const tokens: string[] = [];
+  // Deterministic, source-derived tokens keep this policy core free of randomness.
+  // Avoid a literal collision if the source already contains a KEEP-shaped token.
+  let nonce = [...original].reduce((hash, character) =>
+    ((hash * 31) + character.codePointAt(0)!) >>> 0, 0);
+  const protect = (text: string) => {
+    parts.push(text);
+    let token: string;
+    do { token = `⟦KEEP_${nonce.toString(36)}_${tokens.length}⟧`; nonce = (nonce + 1) >>> 0; }
+    while (original.includes(token));
+    tokens.push(token);
+    return token;
+  };
+  const lines = original.split(/(?<=\n)/);
+  let prose = '', masked = '';
+  const maskProse = (text: string) => text.split(/(?<=\n)/).map(line => {
+    // Markdown list markers are structure. Leave them editable so a model can
+    // reflow or renumber a list without moving a protected factual number.
+    const marker = /^ {0,3}\d+[.)][ \t]+/.exec(line);
+    if (!marker) return line.replace(technical, protect);
+    return marker[0] + line.slice(marker[0].length).replace(technical, protect);
+  }).join('');
+  const flush = () => { masked += maskProse(prose); prose = ''; };
+  for (let i = 0; i < lines.length; i++) {
+    const opening = /^ {0,3}(`{3,}|~{3,})/.exec(lines[i]);
+    if (!opening) { prose += lines[i]; continue; }
+    flush();
+    const fence = opening[1];
+    const closing = new RegExp(`^ {0,3}${fence[0]}{${fence.length},}[ \\t]*(?:\\r?\\n)?$`);
+    let block = lines[i];
+    while (++i < lines.length) {
+      block += lines[i];
+      if (closing.test(lines[i])) break;
+    }
+    // Keep the final line break outside the placeholder, preserving paragraph structure.
+    const newline = block.endsWith('\n') ? '\n' : '';
+    masked += protect(newline ? block.slice(0, -1) : block) + newline;
+  }
+  flush();
+  const rewritten = await complete(masked);
+  if (!rewritten.trim() || rewritten.length > 64000) throw new Error('empty-or-oversize');
+  const found = rewritten.match(/⟦KEEP_[^⟧]+⟧/g) ?? [];
+  if (JSON.stringify(found) !== JSON.stringify(tokens)) throw new Error('preservation');
+  // Ordered Markdown markers are structure, not numeric content. Models may
+  // reflow prose into a list; factual numbers remain protected and checked.
+  const proseOnly = rewritten.replace(/⟦KEEP_[^⟧]+⟧/g, 'protected');
+  const withoutListMarkers = proseOnly.replace(/^ {0,3}\d+[.)][ \t]+/gm, '');
+  if (new RegExp(technical.source, technical.flags).test(withoutListMarkers) || /^ {0,3}(`{3,}|~{3,})/m.test(proseOnly)) throw new Error('preservation');
+  let result = rewritten;
+  for (let i = 0; i < tokens.length; i++) result = result.replace(tokens[i], () => parts[i]);
+  if (/⟦KEEP_[^⟧]+⟧/.test(result)) throw new Error('preservation');
+  return result;
+}

package/src/domain/rewrite.ts

@@ -0,0 +1,55 @@
+import { rewriteText } from "./preservation.ts";
+import { REWRITE_POLICY_VERSION } from "./styles.ts";
+
+export const ENTRY_TYPE = "plain-rewrite";
+export const POLICY_VERSION = REWRITE_POLICY_VERSION;
+export const REWRITE_PROVIDER = "openai-codex";
+export const REWRITE_MODEL = "gpt-5.6-luna";
+export const REWRITE_THINKING = "low" as const;
+export const MAX_INPUT_CHARS = 32_000;
+export const TIMEOUT_MS = 60_000;
+
+export interface PlainEntry {
+  version: typeof POLICY_VERSION;
+  sourceEntryId: string;
+  text: string;
+  model: string;
+  thinkingLevel?: typeof REWRITE_THINKING;
+  style?: string;
+  /** Snapshot metadata keeps historical entries readable after plugin removal. */
+  styleName?: string;
+  stylePlugin?: string;
+  styleVersion?: string;
+}
+
+export class PlainError extends Error {}
+
+/** Pure application operation: the model gateway returns text, not a Pi message. */
+export async function rewriteAnswer(text: string, complete: (masked: string) => Promise<string>): Promise<string> {
+  if (text.length > MAX_INPUT_CHARS) {
+    throw new PlainError("This answer is too long for /declaw (32,000 characters maximum).");
+  }
+  try {
+    const rewritten = await rewriteText(text, complete);
+    if (rewritten.trim() === text.trim()) {
+      throw new PlainError("The model returned unchanged text, so no duplicate was added. Try /declaw again if you want another attempt.");
+    }
+    return rewritten;
+  } catch (error) {
+    if (error instanceof PlainError) throw error;
+    if (error instanceof Error && ["preservation", "empty-or-oversize"].includes(error.message)) {
+      throw new PlainError("The rewrite failed the exact-text checks and was discarded. The original is unchanged.");
+    }
+    throw new PlainError("The rewrite request failed. Check /login or choose another model with /declaw model.");
+  }
+}
+
+/** Stop waiting even if a provider ignores cancellation; still observe any late rejection. */
+export function abortable<T>(work: Promise<T>, signal: AbortSignal): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const cancel = () => reject(signal.reason ?? new Error("Cancelled"));
+    if (signal.aborted) cancel();
+    else signal.addEventListener("abort", cancel, { once: true });
+    work.then(resolve, reject).finally(() => signal.removeEventListener("abort", cancel));
+  });
+}