@anthusai/papyrus 0.0.0 → 1.0.0-next.10

package/amplify/functions/shared/model-payloads.ts

@@ -0,0 +1,186 @@
+import { createHash } from "node:crypto";
+import { GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+
+type DataClient = {
+  models: {
+    ModelAttachment: {
+      get(input: { id: string }): Promise<{ data?: any | null; errors?: unknown }>;
+      create(input: Record<string, unknown>): Promise<{ data?: any | null; errors?: unknown }>;
+      update(input: Record<string, unknown>): Promise<{ data?: any | null; errors?: unknown }>;
+    };
+  };
+};
+
+const s3 = new S3Client({});
+
+export type ModelPayloadOwner = {
+  ownerKind: string;
+  ownerId: string;
+  ownerLineageId?: string | null;
+  ownerVersionNumber?: number | null;
+  ownerVersionKey?: string | null;
+  importRunId?: string | null;
+};
+
+export async function putJsonModelPayload(
+  client: DataClient,
+  owner: ModelPayloadOwner,
+  role: string,
+  sortKey: string,
+  payload: unknown,
+  options: { filename?: string; now?: string; status?: string } = {},
+) {
+  const body = `${JSON.stringify(payload ?? {}, null, 2)}\n`;
+  return putModelPayload(client, owner, role, sortKey, body, {
+    filename: options.filename ?? `${safeId(sortKey || role)}.json`,
+    mediaType: "application/json",
+    now: options.now,
+    status: options.status,
+  });
+}
+
+export async function putTextModelPayload(
+  client: DataClient,
+  owner: ModelPayloadOwner,
+  role: string,
+  sortKey: string,
+  body: string,
+  options: { filename?: string; mediaType?: string; now?: string; status?: string } = {},
+) {
+  return putModelPayload(client, owner, role, sortKey, body, {
+    filename: options.filename ?? `${safeId(sortKey || role)}.txt`,
+    mediaType: options.mediaType ?? "text/plain",
+    now: options.now,
+    status: options.status,
+  });
+}
+
+export async function putModelPayload(
+  client: DataClient,
+  owner: ModelPayloadOwner,
+  role: string,
+  sortKey: string,
+  body: string,
+  options: { filename: string; mediaType: string; now?: string; status?: string },
+) {
+  const now = options.now ?? new Date().toISOString();
+  const storagePath = modelPayloadStoragePath(owner.ownerKind, owner.ownerId, role, options.filename);
+  const buffer = Buffer.from(body, "utf8");
+  const sha256 = createHash("sha256").update(buffer).digest("hex");
+  await s3.send(new PutObjectCommand({
+    Bucket: payloadBucketName(),
+    Key: storagePath,
+    Body: buffer,
+    ContentType: options.mediaType,
+  }));
+
+  const id = modelAttachmentId(owner.ownerKind, owner.ownerId, role, sortKey);
+  const input = {
+    id,
+    ownerKind: owner.ownerKind,
+    ownerId: owner.ownerId,
+    ownerLineageId: owner.ownerLineageId ?? null,
+    ownerVersionNumber: owner.ownerVersionNumber ?? null,
+    ownerVersionKey: owner.ownerVersionKey ?? null,
+    role,
+    sortKey,
+    storagePath,
+    filename: options.filename,
+    mediaType: options.mediaType,
+    byteSize: buffer.length,
+    sha256,
+    etag: null,
+    importRunId: owner.importRunId ?? null,
+    createdAt: now,
+    updatedAt: now,
+    status: options.status ?? "active",
+  };
+  const current = await client.models.ModelAttachment.get({ id });
+  assertNoDataErrors(current.errors, "get ModelAttachment");
+  if (current.data) {
+    await requireDataResult(client.models.ModelAttachment.update({ ...input, createdAt: current.data.createdAt ?? now }), "update ModelAttachment");
+  } else {
+    await requireDataResult(client.models.ModelAttachment.create(input), "create ModelAttachment");
+  }
+  return input;
+}
+
+export async function readJsonModelPayload(
+  client: DataClient,
+  ownerKind: string,
+  ownerId: string,
+  role: string,
+  sortKey = role,
+) {
+  const result = await client.models.ModelAttachment.get({ id: modelAttachmentId(ownerKind, ownerId, role, sortKey) });
+  assertNoDataErrors(result.errors, "get ModelAttachment");
+  const attachment = result.data;
+  if (!attachment?.storagePath) return null;
+  const text = await readTextFromStorage(attachment.storagePath);
+  if (!text) return null;
+  const parsed = JSON.parse(text);
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : null;
+}
+
+async function readTextFromStorage(storagePath: string): Promise<string> {
+  try {
+    const result = await s3.send(new GetObjectCommand({
+      Bucket: payloadBucketName(),
+      Key: storagePath,
+    }));
+    return result.Body?.transformToString("utf8") ?? "";
+  } catch (error) {
+    if (isMissingStorageKeyError(error)) return "";
+    throw error;
+  }
+}
+
+function isMissingStorageKeyError(error: unknown): boolean {
+  if (!error || typeof error !== "object") return false;
+  const record = error as Record<string, unknown>;
+  if (record.name === "NoSuchKey" || record.Code === "NoSuchKey") return true;
+  const message = typeof record.message === "string" ? record.message : "";
+  return message.toLowerCase().includes("the specified key does not exist");
+}
+
+function payloadBucketName(): string {
+  const bucket = process.env.papyrusMedia_BUCKET_NAME
+    ?? process.env.PAPYRUS_MEDIA_BUCKET_NAME
+    ?? process.env.STORAGE_BUCKET_NAME
+    ?? process.env.AMPLIFY_STORAGE_BUCKET_NAME;
+  if (!bucket) throw new Error("Missing Papyrus storage bucket environment variable for model payload attachments.");
+  return bucket;
+}
+
+function modelPayloadStoragePath(ownerKind: string, ownerId: string, role: string, filename: string): string {
+  const rootPrefix = ownerKind === "publishedItem" ? "media/payloads" : "newsroom/payloads";
+  return `${rootPrefix}/${safeId(ownerKind)}/${safeId(ownerId)}/${safeId(role)}/${filename}`;
+}
+
+function modelAttachmentId(ownerKind: string, ownerId: string, role: string, sortKey: string): string {
+  return `model-attachment-${safeId(ownerKind)}-${safeId(ownerId)}-${safeId(role)}-${safeId(sortKey)}`;
+}
+
+function safeId(value: unknown): string {
+  const raw = String(value ?? "payload").trim();
+  const normalized = raw
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "payload";
+  if (normalized.length <= 80) return normalized;
+  const digest = createHash("sha256").update(raw).digest("hex").slice(0, 12);
+  return `${normalized.slice(0, 67).replace(/-+$/g, "")}-${digest}`;
+}
+
+async function requireDataResult<T>(promise: Promise<{ data?: T | null; errors?: unknown }>, context: string): Promise<T | null | undefined> {
+  const result = await promise;
+  assertNoDataErrors(result.errors, context);
+  return result.data;
+}
+
+function assertNoDataErrors(errors: unknown, context: string): void {
+  if (Array.isArray(errors) && errors.length) {
+    throw new Error(`${context}: ${errors.map((error) => typeof error === "string" ? error : JSON.stringify(error)).join("; ")}`);
+  }
+}

package/amplify/functions/shared/python-bundle.js

@@ -0,0 +1,130 @@
+import { AssetHashType, DockerImage } from "aws-cdk-lib";
+import { Code, Runtime } from "aws-cdk-lib/aws-lambda";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Python Lambda bundling that works both in a Papyrus checkout and when
+ * `@anthusai/papyrus` is installed from npm into a publication repo.
+ *
+ * - Checkout mode (`src/` exists next to `amplify/`, default in the Papyrus
+ *   repo): copy `src/<module>` into the asset, as before.
+ * - Package mode (no `src/`, or PAPYRUS_BUNDLE_FROM_PIP=1): the asset is
+ *   `pip install papyrus-newsroom==<this package's version>` plus the
+ *   function's requirements, targeted at the Lambda platform (linux aarch64,
+ *   CPython 3.12, binary wheels only); the handler is copied from this package.
+ *
+ * PAPYRUS_PIP_EXTRA_ARGS lets a site point pip at a private index or a local
+ * wheel directory (e.g. `--find-links ./vendor`).
+ */
+const here = path.dirname(fileURLToPath(import.meta.url));
+export const packageRoot = path.resolve(here, "../../..");
+export function isPackageMode() {
+    if (process.env.PAPYRUS_BUNDLE_FROM_PIP === "1")
+        return true;
+    return !fs.existsSync(path.join(packageRoot, "src", "papyrus_content"));
+}
+/** Lockstep version: the npm package's own version is the Python pin. */
+export function papyrusVersion() {
+    const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+    return pkg.version;
+}
+/**
+ * semver -> PEP 440. `1.2.0-next.3` is not a valid Python version; Semantic
+ * Release prereleases (`-next.N`) map to dev releases (`1.2.0.dev3`), which sort
+ * before the final release exactly like semver prereleases do.
+ */
+export function toPep440(version) {
+    const m = /^(\d+\.\d+\.\d+)(?:-[0-9A-Za-z-]+\.(\d+))?$/.exec(version);
+    if (!m)
+        throw new Error(`Cannot map ${version} to a PEP 440 version`);
+    return m[2] === undefined ? m[1] : `${m[1]}.dev${m[2]}`;
+}
+function pipSpec() {
+    return (process.env.PAPYRUS_PIP_SPEC ?? "").trim() || `papyrus-newsroom==${toPep440(papyrusVersion())}`;
+}
+function bundleFromPip(outputDir, options) {
+    const extra = (process.env.PAPYRUS_PIP_EXTRA_ARGS ?? "").trim().split(/\s+/).filter(Boolean);
+    const python = (process.env.PAPYRUS_PIP_PYTHON ?? "python3").trim();
+    execFileSync(python, [
+        "-m", "pip", "install",
+        "--target", outputDir,
+        "--no-cache-dir",
+        "--platform", "manylinux2014_aarch64",
+        "--implementation", "cp",
+        "--python-version", "3.12",
+        "--only-binary=:all:",
+        // Older pip (e.g. a Python 3.9 build image) checks Requires-Python against the host interpreter, not --python-version.
+        "--ignore-requires-python",
+        ...extra,
+        ...(options.noDeps ? [] : [pipSpec()]),
+        ...(options.requirements ?? []),
+    ], { stdio: "inherit" });
+    if (options.noDeps) {
+        execFileSync(python, [
+            "-m", "pip", "install",
+            "--target", outputDir,
+            "--no-cache-dir",
+            "--no-deps",
+            "--platform", "manylinux2014_aarch64",
+            "--implementation", "cp",
+            "--python-version", "3.12",
+            "--only-binary=:all:",
+            "--ignore-requires-python",
+            ...extra,
+            pipSpec(),
+        ], { stdio: "inherit" });
+    }
+    fs.copyFileSync(path.join(packageRoot, "amplify/functions", options.functionDir, "handler.py"), path.join(outputDir, "handler.py"));
+    if (options.corpora) {
+        const corporaDir = path.join(outputDir, "corpora");
+        fs.mkdirSync(corporaDir, { recursive: true });
+        const sourceDir = path.join(process.cwd(), "corpora");
+        if (fs.existsSync(sourceDir)) {
+            for (const entry of fs.readdirSync(sourceDir)) {
+                if (entry.endsWith(".yml"))
+                    fs.copyFileSync(path.join(sourceDir, entry), path.join(corporaDir, entry));
+            }
+        }
+    }
+}
+export function bundleFromCheckout(outputDir, options) {
+    fs.copyFileSync(path.join(packageRoot, "amplify/functions", options.functionDir, "handler.py"), path.join(outputDir, "handler.py"));
+    for (const module of options.modules) {
+        fs.mkdirSync(path.join(outputDir, module), { recursive: true });
+        fs.cpSync(path.join(packageRoot, "src", module), path.join(outputDir, module), { recursive: true });
+    }
+    options.checkoutExtras?.(outputDir);
+}
+/**
+ * CDK Code for a Python Lambda. In package mode the asset hash is derived
+ * from the pinned version and pip spec instead of hashing the package root.
+ */
+export function pythonLambdaCode(options, dockerCommand) {
+    const packageMode = isPackageMode();
+    return Code.fromAsset(packageRoot, {
+        ...(packageMode
+            ? {
+                assetHashType: AssetHashType.CUSTOM,
+                assetHash: `${options.functionDir}:${pipSpec()}:${(options.requirements ?? []).join(",")}`
+                    .replace(/[^a-zA-Z0-9._:=,-]/g, "_"),
+            }
+            : {}),
+        bundling: {
+            image: Runtime.PYTHON_3_12.bundlingImage ?? DockerImage.fromRegistry("public.ecr.aws/sam/build-python3.12"),
+            local: {
+                tryBundle(outputDir) {
+                    if (packageMode)
+                        bundleFromPip(outputDir, options);
+                    else
+                        bundleFromCheckout(outputDir, options);
+                    return true;
+                },
+            },
+            command: packageMode
+                ? ["bash", "-c", "echo 'Package-mode Python bundling runs locally (pip on the build host).' >&2; exit 1"]
+                : dockerCommand,
+        },
+    });
+}

package/amplify/functions/shared/python-bundle.ts

@@ -0,0 +1,162 @@
+import { AssetHashType, DockerImage } from "aws-cdk-lib";
+import { Code, Runtime } from "aws-cdk-lib/aws-lambda";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * Python Lambda bundling that works both in a Papyrus checkout and when
+ * `@anthusai/papyrus` is installed from npm into a publication repo.
+ *
+ * - Checkout mode (`src/` exists next to `amplify/`, default in the Papyrus
+ *   repo): copy `src/<module>` into the asset, as before.
+ * - Package mode (no `src/`, or PAPYRUS_BUNDLE_FROM_PIP=1): the asset is
+ *   `pip install papyrus-newsroom==<this package's version>` plus the
+ *   function's requirements, targeted at the Lambda platform (linux aarch64,
+ *   CPython 3.12, binary wheels only); the handler is copied from this package.
+ *
+ * PAPYRUS_PIP_EXTRA_ARGS lets a site point pip at a private index or a local
+ * wheel directory (e.g. `--find-links ./vendor`).
+ */
+const here = path.dirname(fileURLToPath(import.meta.url));
+export const packageRoot = path.resolve(here, "../../..");
+
+export function isPackageMode(): boolean {
+  if (process.env.PAPYRUS_BUNDLE_FROM_PIP === "1") return true;
+  return !fs.existsSync(path.join(packageRoot, "src", "papyrus_content"));
+}
+
+/** Lockstep version: the npm package's own version is the Python pin. */
+export function papyrusVersion(): string {
+  const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8")) as { version: string };
+  return pkg.version;
+}
+
+/**
+ * semver -> PEP 440. `1.2.0-next.3` is not a valid Python version; Semantic
+ * Release prereleases (`-next.N`) map to dev releases (`1.2.0.dev3`), which sort
+ * before the final release exactly like semver prereleases do.
+ */
+export function toPep440(version: string): string {
+  const m = /^(\d+\.\d+\.\d+)(?:-[0-9A-Za-z-]+\.(\d+))?$/.exec(version);
+  if (!m) throw new Error(`Cannot map ${version} to a PEP 440 version`);
+  return m[2] === undefined ? m[1] : `${m[1]}.dev${m[2]}`;
+}
+
+export type PythonBundleOptions = {
+  /** Directory under `amplify/functions/` holding `handler.py`. */
+  functionDir: string;
+  /** `src/` modules to copy in checkout mode. */
+  modules: string[];
+  /** Run extra checkout-mode steps (e.g. copy corpora, pip install -r). */
+  checkoutExtras?: (outputDir: string) => void;
+  /** Extra pip requirements in package mode, beyond `papyrus-newsroom`. */
+  requirements?: string[];
+  /** Package mode: install `papyrus-newsroom` with `--no-deps`, then only `requirements`. */
+  noDeps?: boolean;
+  /** Copy `<cwd>/corpora/*.yml` into the asset (publication-owned steering config). */
+  corpora?: boolean;
+};
+
+function pipSpec(): string {
+  return (process.env.PAPYRUS_PIP_SPEC ?? "").trim() || `papyrus-newsroom==${toPep440(papyrusVersion())}`;
+}
+
+function bundleFromPip(outputDir: string, options: PythonBundleOptions): void {
+  const extra = (process.env.PAPYRUS_PIP_EXTRA_ARGS ?? "").trim().split(/\s+/).filter(Boolean);
+  const python = (process.env.PAPYRUS_PIP_PYTHON ?? "python3").trim();
+  execFileSync(
+    python,
+    [
+      "-m", "pip", "install",
+      "--target", outputDir,
+      "--no-cache-dir",
+      "--platform", "manylinux2014_aarch64",
+      "--implementation", "cp",
+      "--python-version", "3.12",
+      "--only-binary=:all:",
+      // Older pip (e.g. a Python 3.9 build image) checks Requires-Python against the host interpreter, not --python-version.
+      "--ignore-requires-python",
+      ...extra,
+      ...(options.noDeps ? [] : [pipSpec()]),
+      ...(options.requirements ?? []),
+    ],
+    { stdio: "inherit" },
+  );
+  if (options.noDeps) {
+    execFileSync(
+      python,
+      [
+        "-m", "pip", "install",
+        "--target", outputDir,
+        "--no-cache-dir",
+        "--no-deps",
+        "--platform", "manylinux2014_aarch64",
+        "--implementation", "cp",
+        "--python-version", "3.12",
+        "--only-binary=:all:",
+        "--ignore-requires-python",
+        ...extra,
+        pipSpec(),
+      ],
+      { stdio: "inherit" },
+    );
+  }
+  fs.copyFileSync(
+    path.join(packageRoot, "amplify/functions", options.functionDir, "handler.py"),
+    path.join(outputDir, "handler.py"),
+  );
+  if (options.corpora) {
+    const corporaDir = path.join(outputDir, "corpora");
+    fs.mkdirSync(corporaDir, { recursive: true });
+    const sourceDir = path.join(process.cwd(), "corpora");
+    if (fs.existsSync(sourceDir)) {
+      for (const entry of fs.readdirSync(sourceDir)) {
+        if (entry.endsWith(".yml")) fs.copyFileSync(path.join(sourceDir, entry), path.join(corporaDir, entry));
+      }
+    }
+  }
+}
+
+export function bundleFromCheckout(outputDir: string, options: PythonBundleOptions): void {
+  fs.copyFileSync(
+    path.join(packageRoot, "amplify/functions", options.functionDir, "handler.py"),
+    path.join(outputDir, "handler.py"),
+  );
+  for (const module of options.modules) {
+    fs.mkdirSync(path.join(outputDir, module), { recursive: true });
+    fs.cpSync(path.join(packageRoot, "src", module), path.join(outputDir, module), { recursive: true });
+  }
+  options.checkoutExtras?.(outputDir);
+}
+
+/**
+ * CDK Code for a Python Lambda. In package mode the asset hash is derived
+ * from the pinned version and pip spec instead of hashing the package root.
+ */
+export function pythonLambdaCode(options: PythonBundleOptions, dockerCommand: string[]): Code {
+  const packageMode = isPackageMode();
+  return Code.fromAsset(packageRoot, {
+    ...(packageMode
+      ? {
+          assetHashType: AssetHashType.CUSTOM,
+          assetHash: `${options.functionDir}:${pipSpec()}:${(options.requirements ?? []).join(",")}`
+            .replace(/[^a-zA-Z0-9._:=,-]/g, "_"),
+        }
+      : {}),
+    bundling: {
+      image: Runtime.PYTHON_3_12.bundlingImage ?? DockerImage.fromRegistry("public.ecr.aws/sam/build-python3.12"),
+      local: {
+        tryBundle(outputDir: string): boolean {
+          if (packageMode) bundleFromPip(outputDir, options);
+          else bundleFromCheckout(outputDir, options);
+          return true;
+        },
+      },
+      command: packageMode
+        ? ["bash", "-c", "echo 'Package-mode Python bundling runs locally (pip on the build host).' >&2; exit 1"]
+        : dockerCommand,
+    },
+  });
+}

package/amplify/functions/shared/slack-events.ts

@@ -0,0 +1,111 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { resolveAmplifySecret } from "./amplify-secrets";
+
+const URL_PATTERN = /https?:\/\/\S+/gi;
+
+export async function slackSigningSecret(): Promise<string> {
+  return resolveAmplifySecret("PAPYRUS_SLACK_SIGNING_SECRET");
+}
+
+export function allowedSlackUserIds(): Set<string> {
+  const raw = (process.env.PAPYRUS_SLACK_ALLOWED_USER_IDS ?? "").trim();
+  if (!raw) return new Set();
+  return new Set(raw.split(",").map((entry) => entry.trim()).filter(Boolean));
+}
+
+export function verifySlackRequestSignature(input: {
+  signingSecret: string;
+  timestamp: string;
+  rawBody: Buffer;
+  signature: string;
+  maxAgeSeconds?: number;
+}): boolean {
+  const secret = input.signingSecret.trim();
+  const timestamp = input.timestamp.trim();
+  const signature = input.signature.trim();
+  if (!secret || !timestamp || !signature) return false;
+  const requestTs = Number.parseInt(timestamp, 10);
+  if (!Number.isFinite(requestTs)) return false;
+  const maxAge = input.maxAgeSeconds ?? 60 * 5;
+  if (Math.abs(Math.floor(Date.now() / 1000) - requestTs) > maxAge) return false;
+  const base = `v0:${timestamp}:${input.rawBody.toString("utf8")}`;
+  const digest = createHmac("sha256", secret).update(base).digest("hex");
+  const expected = `v0=${digest}`;
+  const expectedBuffer = Buffer.from(expected);
+  const signatureBuffer = Buffer.from(signature);
+  if (expectedBuffer.length !== signatureBuffer.length) return false;
+  return timingSafeEqual(expectedBuffer, signatureBuffer);
+}
+
+export function slackThreadId(teamId: string, channelId: string, threadTs: string): string {
+  const team = (teamId || "unknown").trim() || "unknown";
+  const channel = channelId.trim();
+  const root = threadTs.trim().replace(/\./g, "-");
+  return `thread-slack-${team}-${channel}-${root}`;
+}
+
+export function chatMessageIdForSlackEvent(eventId: string): string {
+  const token = eventId.replace(/[^a-zA-Z0-9]/g, "").slice(0, 40) || "unknown";
+  return `message-console-slack-${token}`;
+}
+
+export function shouldIgnoreSlackEvent(event: Record<string, unknown>): string | null {
+  if (event.bot_id || event.subtype === "bot_message" || event.subtype === "message_changed" || event.subtype === "message_deleted") {
+    return "bot-or-non-user-message";
+  }
+  const user = String(event.user ?? "").trim();
+  if (!user) return "missing-user";
+  const allowed = allowedSlackUserIds();
+  if (allowed.size > 0 && !allowed.has(user)) return "unauthorized-user";
+  const text = String(event.text ?? "").trim();
+  if (!text && !Array.isArray(event.files)) return "empty-message";
+  return null;
+}
+
+export function slackAgentInstructions(): string {
+  return [
+    "You are Papyrus, an editorial assistant for an autonomous newsroom, replying in Slack (not inbound email reference intake).",
+    "Use execute_tactus with the papyrus.* tool surface.",
+    "",
+    "Be concise, accurate, and concrete. Slack has no web UI: do not use papyrus.web.navigate, papyrus.web.current_location, or assume the user can see papyrus:// pages.",
+    "",
+    "Raw console chat turns are working memory and are excluded from default semantic searches unless explicitly requested. When a chat produces durable insight, recommend creating an insight Message instead of making every chat turn canonical knowledge.",
+    "",
+    "Respond openly to questions, commands, and discussion—the same conversational stance as the web console. Do not treat every message as a citation submission. Register references or create insights only when the user shares URLs/DOIs or asks you to file, summarize, or comment on specific material.",
+    "",
+    'For requests like "most recent references" or "tell me about recent references", do not ask clarifying questions first: immediately call execute_tactus with a Reference.list snippet, then summarize the results.',
+    "",
+    'When the user provides a URL and asks to add or register a reference, immediately call execute_tactus with Reference.create{ url = "<url>", apply = true } (not papyrus.reference.create).',
+    "",
+    "Keep Slack replies short; use bullet lists when listing references.",
+  ].join("\n");
+}
+
+export function buildSlackPrompt(input: {
+  event: Record<string, unknown>;
+  teamId: string | null;
+  channelId: string;
+  threadTs: string;
+}): string {
+  const user = String(input.event.user ?? "slack-user").trim();
+  const text = String(input.event.text ?? "").trim();
+  const urls = text.match(URL_PATTERN) ?? [];
+  const lines = [
+    slackAgentInstructions(),
+    "",
+    `Slack team id: ${input.teamId ?? "(unknown)"}`,
+    `Slack channel id: ${input.channelId}`,
+    `Slack thread ts: ${input.threadTs}`,
+    `Slack user id: ${user}`,
+    "",
+    "User message:",
+    text || "(no text; see files metadata if present)",
+  ];
+  if (Array.isArray(input.event.files) && input.event.files.length > 0) {
+    lines.push("", "Slack files JSON:", JSON.stringify(input.event.files, null, 2));
+  }
+  if (urls.length > 0) {
+    lines.push("", `Detected URL count: ${urls.length}`, "URLs:", ...urls.map((url) => `- ${url}`));
+  }
+  return lines.join("\n").trim();
+}