@comchatx/cx-topics 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ComChatX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/extensions/topics.js

@@ -0,0 +1,517 @@
+// src/source-packages/cx-topics/box/extensions/topics.ts
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/source-packages/cx-topics/box/core/protocol.ts
+var STOPPING = /* @__PURE__ */ new Set(["refused", "timeout", "no-model"]);
+var ReviewFailure = class extends Error {
+  constructor(kind) {
+    super(kind);
+    this.kind = kind;
+  }
+};
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var bounded = (value, max) => typeof value === "string" && value.length <= max * 2 && value.trim() !== "" && [...value].length <= max;
+var validTitle = (value) => bounded(value, 80) && !/[\r\n]/.test(value) && value.trim().split(/\s+/).length <= 8;
+var pick = (value, keys) => record(value) ? Object.fromEntries(keys.map((key) => [key, value[key]])) : void 0;
+function list(value, max, copy) {
+  if (!Array.isArray(value)) return void 0;
+  const length = value.length;
+  if (length > max) return void 0;
+  const items = [];
+  for (let i = 0; i < length; i++) items.push(copy(value[i]));
+  return items;
+}
+var GATE_CODES = /\b(membership_required|debt_owed|model_not_served|sign_in_again)\b/;
+var statusOf = (message) => {
+  const found = /^(\d{3})\b/.exec(message) ?? /^[^()\n{}":]* error \((\d{3})\)(?::|$)/.exec(message);
+  return found === null ? void 0 : Number(found[1]);
+};
+var billed = (usage) => record(usage) && ["input", "output", "totalTokens"].some((key) => typeof usage[key] === "number" && usage[key] > 0);
+function failureOf(raw) {
+  if (raw.stopReason === "aborted") return "timeout";
+  if (raw.stopReason === "length" || raw.stopReason === "toolUse" || billed(raw.usage)) return "malformed";
+  const message = typeof raw.errorMessage === "string" ? raw.errorMessage : "";
+  if (/timed out/i.test(message)) return "timeout";
+  const status = statusOf(message);
+  return status === 400 || status === 413 || status === 422 || status === 403 && !GATE_CODES.test(message) ? "rejected" : "refused";
+}
+function parseAnswers(raw, questions) {
+  if (raw === void 0) return "no-model";
+  if (!record(raw)) return "malformed";
+  if (raw.stopReason !== "stop") return failureOf(raw);
+  if (!record(raw.answers)) return "malformed";
+  const answers = {};
+  for (const key of Object.keys(questions)) {
+    if (!Object.hasOwn(raw.answers, key)) return "missing-answers";
+    const answer = raw.answers[key];
+    if (!record(answer) || answer.type !== "bool" || typeof answer.probability !== "number" || !Number.isFinite(answer.probability) || answer.probability < 0 || answer.probability > 1) return "malformed";
+    answers[key] = answer.probability;
+  }
+  return Object.freeze(answers);
+}
+async function askQuestions(state, questions, ask, timeoutMs) {
+  const controller = new AbortController();
+  let timer;
+  try {
+    const deadline = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(new ReviewFailure("timeout"));
+        controller.abort();
+      }, timeoutMs);
+    });
+    const raw = await Promise.race([ask(state, questions, controller.signal), deadline]);
+    try {
+      return parseAnswers(raw, questions);
+    } catch {
+      return "malformed";
+    }
+  } catch (error) {
+    return error instanceof ReviewFailure && error.kind === "timeout" ? "timeout" : "refused";
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/source-packages/cx-topics/box/core/routing.ts
+var ROUTING_LIMITS = Object.freeze({
+  // A seller message over 512 code points, and the latest over 2,048, keeps its head and tail (`cut`).
+  messageChars: 512,
+  latestChars: 2048,
+  // The newest 31 of a topic's seller messages are shown, as many as kept a full request in Chinese text within the size of a full one when
+  // Jev was also shown cx's words and three earlier topics (56,355 bytes): where a topic now stands is in its newest messages, and its title
+  // says where it began. The topic's length still counts every one. The bounds are code points, so the largest request is of characters
+  // JSON writes in six bytes, 109,260 bytes.
+  sellerMessages: 31,
+  // How long the router gives the asker when its caller names no deadline.
+  timeoutMs: 1e3,
+  confident: 0.8,
+  unlikely: 0.2,
+  // A title is rewritten only when Jev answers at most this that it still names the topic's work: a rewrite is a paid call and renames a
+  // row the seller reads, so it takes the answer a settled topic takes to call a message a lasting change.
+  staleTitle: 0.2,
+  // How long the title model is given: nothing waits for a title, so the bound only ends a call that would otherwise hang, at the time
+  // Jev's own call is given.
+  titleMs: 2e4,
+  // A title of 80 characters is under 128 tokens in any language; the cap bounds what a runaway answer costs.
+  titleTokens: 128,
+  // A topic of two seller messages or fewer is still finding its shape (Jack's example: two messages on one product's listing, then a
+  // third on another's, is one topic), so an even answer continues it.
+  shortTopic: 2,
+  shortTopicBar: 0.5,
+  // By eight seller messages a topic is settled, and a message continues it only on the confident answer every message needed before.
+  longTopic: 8
+});
+var filled = (value) => typeof value === "string" && value.trim() !== "";
+function cut(text2, max) {
+  const points = [...text2];
+  if (points.length <= max) return text2;
+  const marker = (omitted) => `
+[\u2026 ${omitted} characters omitted \u2026]
+`;
+  const keep = max - marker(points.length).length;
+  const head = Math.ceil(keep / 2);
+  return `${points.slice(0, head).join("")}${marker(points.length - keep)}${points.slice(points.length - (keep - head)).join("")}`;
+}
+var cutText = (value, max) => filled(value) ? cut(value, max) : value;
+var copyTopic = (value) => {
+  const topic = pick(value, ["title", "messages"]);
+  return topic && { ...topic, messages: list(topic.messages, ROUTING_LIMITS.sellerMessages, (text2) => cutText(text2, ROUTING_LIMITS.messageChars)) };
+};
+function copied(input) {
+  const envelope = pick(input, ["current", "latestUserMessage", "baselineDecision", "currentLength"]) ?? {};
+  return { ...envelope, latestUserMessage: cutText(envelope.latestUserMessage, ROUTING_LIMITS.latestChars), current: copyTopic(envelope.current) };
+}
+function validTopic(topic) {
+  return record(topic) && (topic.title === void 0 || validTitle(topic.title)) && Array.isArray(topic.messages) && (topic.title !== void 0 || topic.messages.length > 0) && topic.messages.every(filled);
+}
+function valid(input) {
+  return (input.baselineDecision === "new-topic" || input.baselineDecision === "continuation") && filled(input.latestUserMessage) && validTopic(input.current) && (input.currentLength === void 0 || Number.isSafeInteger(input.currentLength) && input.currentLength >= input.current.messages.length);
+}
+var question = (instructions, yes, no) => Object.freeze({ type: "bool", instructions, criteria: Object.freeze({ true: yes, false: no }) });
+function questionsFor(state) {
+  return Object.freeze({
+    significantChange: question("Does state.latestUserMessage request lasting separate work rather than a brief tangent or correction to state.current?", "Lasting separate work", "A brief tangent or a correction"),
+    // The same task on another product sits between the two answers, so a topic's length can decide it; another kind of task does not.
+    continueCurrent: question("Does state.latestUserMessage intend to continue or correct the work in state.current, its title and the seller's messages so far, rather than start separate work? The same task on another product continues it less surely than the same product; another kind of task does not continue it. Judge intent, not shared product words.", "Continues or corrects the work", "Starts another kind of work"),
+    ...state.current.title === void 0 ? {} : { titleAdequate: question("Does state.current.title still name the work in state.current, the seller's messages so far, together with state.latestUserMessage? A title that names where the work began but not where it has gone does not.", "Still names the work", "No longer names the work") }
+  });
+}
+var fieldPaths = (state) => Object.freeze([
+  "current",
+  ...state.current.title === void 0 ? [] : ["current.title"],
+  "current.messages",
+  ...state.current.messages.map((_, i) => `current.messages[${i}]`),
+  "latestUserMessage"
+]);
+function continuationBars(length) {
+  const { shortTopic, longTopic, shortTopicBar, confident, unlikely } = ROUTING_LIMITS;
+  const along = Math.min(1, Math.max(0, (length - shortTopic) / (longTopic - shortTopic)));
+  const between = (short, long) => short * (1 - along) + long * along;
+  return { continuing: between(shortTopicBar, confident), change: between(1 - shortTopicBar, unlikely) };
+}
+async function routeTopic(input, dependencies) {
+  const start = dependencies.now();
+  const envelope = copied(input);
+  const baselineDecision = envelope.baselineDecision === "new-topic" || envelope.baselineDecision === "continuation" ? envelope.baselineDecision : null;
+  const base = {
+    latestUserMessage: filled(envelope.latestUserMessage) ? envelope.latestUserMessage : null,
+    baseline: Object.freeze({ decision: baselineDecision }),
+    probabilities: null,
+    disagreement: null,
+    titleFlag: null
+  };
+  if (!valid(envelope)) return Object.freeze({ ...base, status: "unavailable", reason: "invalid-input", decision: null, requestCount: 0, latencyMs: 0, disclosedFields: Object.freeze([]) });
+  const current = envelope.current;
+  const state = Object.freeze({
+    current: Object.freeze({ ...current.title === void 0 ? {} : { title: current.title }, messages: Object.freeze([...current.messages]) }),
+    latestUserMessage: envelope.latestUserMessage
+  });
+  const fallback = baselineDecision === "continuation" ? "continue-current" : "create-new";
+  const evidence = { ...base, requestCount: 1, disclosedFields: fieldPaths(state) };
+  const answers = await askQuestions(state, questionsFor(state), dependencies.ask, dependencies.timeoutMs ?? ROUTING_LIMITS.timeoutMs);
+  const latencyMs = Math.max(0, dependencies.now() - start);
+  if (typeof answers === "string") return Object.freeze({ ...evidence, status: "unavailable", reason: answers, decision: fallback, latencyMs });
+  const continuing = answers.continueCurrent;
+  const bars = continuationBars(envelope.currentLength ?? current.messages.length);
+  const decision = continuing >= bars.continuing || answers.significantChange <= bars.change && continuing >= ROUTING_LIMITS.unlikely ? "continue-current" : "create-new";
+  return Object.freeze({
+    ...evidence,
+    status: "available",
+    decision,
+    probabilities: answers,
+    latencyMs,
+    disagreement: (decision === "continue-current" ? "continuation" : "new-topic") !== baselineDecision,
+    titleFlag: answers.titleAdequate === void 0 ? null : answers.titleAdequate <= ROUTING_LIMITS.staleTitle
+  });
+}
+
+// src/source-packages/cx-topics/box/core/titling.ts
+var TITLE_SYSTEM = [
+  "You write the title of one topic in a seller's History: the piece of work the seller's messages ask for.",
+  'Write at most eight words, in the language the seller writes in, such as "Competitor price history" or "\u745C\u4F3D\u57AB\u8865\u8D27\u68C0\u67E5".',
+  "Reply with the title alone: no quotes, no punctuation at its end, no explanation."
+].join("\n");
+function titleLanguage(newest) {
+  if (/\p{Script=Han}/u.test(newest)) return "Write the title in Chinese.";
+  if (/^[\x00-\x7f]*$/.test(newest)) return "Write the title in English.";
+  return "Write the title in the language of the last [seller] line.";
+}
+function titlePrompt(request) {
+  const { sellerMessages, messageChars, latestChars } = ROUTING_LIMITS;
+  const shown = request.messages.slice(-sellerMessages);
+  const lines = shown.map((text2, at) => `[seller] ${cut(text2, at === shown.length - 1 ? latestChars : messageChars)}`);
+  return [
+    ...request.title === void 0 ? ["Title this new topic from the seller's message."] : [`The topic is titled "${request.title}", which no longer names its work. Write a title that names the work as it stands now.`],
+    "",
+    ...lines,
+    "",
+    titleLanguage(shown.at(-1) ?? "")
+  ].join("\n");
+}
+
+// src/source-packages/cx-topics/box/extensions/judge.ts
+var JEV = Object.freeze({ provider: "typesafe", model: "jev-latest" });
+var TITLE_MODEL = Object.freeze({ provider: "openrouter", model: "minimax/minimax-m3" });
+var CALL_MS = 2e4;
+var isSellers = (entry) => entry.type === "message" && entry.message.role === "user";
+var QUOTE = /<quote\b[^>]*>[\s\S]*?<\/quote>/g;
+function words(entry) {
+  const content = "content" in entry.message ? entry.message.content : void 0;
+  const text2 = typeof content === "string" ? content : Array.isArray(content) ? content.flatMap((block) => block?.type === "text" && typeof block.text === "string" ? [block.text] : []).join("\n") : "";
+  return text2.replace(QUOTE, "").trim();
+}
+function topicBefore(branch, label, id) {
+  const at = branch.findIndex((entry) => entry.id === id);
+  if (at < 0) return void 0;
+  let topic;
+  for (const entry of branch.slice(0, at)) {
+    if (!isSellers(entry)) continue;
+    const named = label(entry.id);
+    if (named !== void 0) topic = { start: entry.id, title: named, said: [], length: 0 };
+    if (topic === void 0) continue;
+    topic.length += 1;
+    const text2 = words(entry);
+    if (text2 !== "") topic.said.push(text2);
+  }
+  return topic && Object.freeze({ ...topic, said: Object.freeze(topic.said) });
+}
+function projection(branch, label, id) {
+  const latest = branch.find((entry) => entry.id === id);
+  const topic = latest !== void 0 && isSellers(latest) ? topicBefore(branch, label, id) : void 0;
+  if (topic === void 0) return void 0;
+  return Object.freeze({
+    current: Object.freeze({ title: topic.title, messages: Object.freeze(topic.said.slice(-ROUTING_LIMITS.sellerMessages)) }),
+    // Without a verdict a message stays in the topic in progress.
+    latestUserMessage: words(latest),
+    baselineDecision: "continuation",
+    currentLength: topic.length
+  });
+}
+function verdictOf(advisory) {
+  if (advisory.status !== "available") return void 0;
+  return Object.freeze(advisory.decision === "continue-current" ? { decision: "continue", stale: advisory.titleFlag === true } : { decision: "new" });
+}
+var asker = (ctx) => async (state, questions, signal) => {
+  const jev = ctx.modelRegistry.findOfType("classifier", JEV.provider, JEV.model);
+  if (jev === void 0) return void 0;
+  return ctx.modelRegistry.classify(jev, { state, questions }, { maxRetries: 0, timeoutMs: CALL_MS, signal });
+};
+var titler = (ctx) => async (request) => {
+  const model = ctx.modelRegistry.find(TITLE_MODEL.provider, TITLE_MODEL.model);
+  if (model === void 0) return { failure: "no-model" };
+  try {
+    const answer = await ctx.modelRegistry.complete(model, {
+      systemPrompt: TITLE_SYSTEM,
+      messages: [{ role: "user", content: [{ type: "text", text: titlePrompt(request) }], timestamp: Date.now() }]
+    }, { maxTokens: ROUTING_LIMITS.titleTokens, signal: AbortSignal.timeout(ROUTING_LIMITS.titleMs), cacheRetention: "none" });
+    if (answer.stopReason !== "stop") return { failure: failureOf(answer) };
+    return { text: answer.content.flatMap((block) => block.type === "text" ? [block.text] : []).join(" ") };
+  } catch {
+    return { failure: "refused" };
+  }
+};
+var ended = (failure) => failure !== void 0 && STOPPING.has(failure) ? "stopped" : "judged";
+function createJudge(title2, setLabel, live = () => {
+}) {
+  const labelOf = (ctx) => (id) => {
+    const raw = ctx.sessionManager.getLabel(id);
+    return raw === void 0 ? void 0 : title2(raw);
+  };
+  async function name(ctx, target, request) {
+    live();
+    const titled = await titler(ctx)(request);
+    if ("failure" in titled) return ended(titled.failure);
+    const kept = title2(titled.text);
+    if (kept === void 0 || kept === request.title || ctx.sessionManager.getEntry(target) === void 0 || labelOf(ctx)(target) !== request.title) return "judged";
+    setLabel(target, kept);
+    return "judged";
+  }
+  return async (ctx, id) => {
+    const branch = ctx.sessionManager.getBranch();
+    const latest = branch.find((entry) => entry.id === id);
+    if (latest === void 0 || !isSellers(latest)) return "judged";
+    const said = words(latest);
+    const topic = topicBefore(branch, labelOf(ctx), id);
+    if (topic === void 0) return said === "" ? "judged" : name(ctx, id, { messages: [said] });
+    const advisory = await routeTopic(projection(branch, labelOf(ctx), id), { ask: asker(ctx), now: Date.now, timeoutMs: CALL_MS });
+    const verdict = verdictOf(advisory);
+    if (verdict === void 0) return ended(advisory.reason === "invalid-input" ? void 0 : advisory.reason);
+    if (verdict.decision === "new") return name(ctx, id, { messages: [said] });
+    if (verdict.stale) return name(ctx, topic.start, { title: topic.title, messages: [...topic.said, said] });
+    return "judged";
+  };
+}
+
+// src/source-packages/cx-topics/box/extensions/pass.ts
+var PROGRESS = "cx-topics";
+var INSTALLS_FILE = ".pi/cx-installs.json";
+function installKey(source) {
+  if (!source.startsWith("npm:")) return source;
+  const spec = source.slice("npm:".length);
+  const at = spec.indexOf("@", spec.startsWith("@") ? 1 : 0);
+  return `npm:${at < 0 ? spec : spec.slice(0, at)}`;
+}
+function tokenIn(text2, key) {
+  if (text2 === void 0 || key === void 0) return void 0;
+  try {
+    const tokens = JSON.parse(text2).tokens;
+    const token = typeof tokens === "object" && tokens !== null && !Array.isArray(tokens) ? tokens[key] : void 0;
+    return typeof token === "string" && token !== "" ? token : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var progressOf = (entries) => entries.flatMap((entry) => {
+  if (entry.type !== "custom" || entry.customType !== PROGRESS) return [];
+  const data = entry.data;
+  return [{ ...typeof data?.install === "string" ? { install: data.install } : {}, ...typeof data?.through === "string" ? { through: data.through } : {} }];
+});
+var Stopped = class extends Error {
+};
+function createPass(ports) {
+  let arrivals = 0;
+  let over = false;
+  let wanted;
+  let running;
+  const live = () => {
+    if (over) throw new Stopped();
+  };
+  const judge = createJudge(ports.title, (id, label) => {
+    live();
+    ports.setLabel(id, label);
+  }, live);
+  const keep = (progress) => {
+    live();
+    ports.keep(progress);
+    return progress;
+  };
+  async function walk(ctx) {
+    const session = ctx.sessionManager;
+    const kept = progressOf(session.getEntries());
+    const token = ports.token(ctx);
+    let last = kept.at(-1);
+    if (token !== void 0 && !kept.some((progress) => progress.install === token)) {
+      for (const entry of session.getEntries()) if (isSellers(entry) && session.getLabel(entry.id) !== void 0) {
+        live();
+        ports.setLabel(entry.id, void 0);
+      }
+      last = keep({ install: token });
+    } else if (last === void 0) {
+      const newest = session.getBranch().filter(isSellers).at(-1);
+      last = keep(newest === void 0 ? {} : { through: newest.id });
+    }
+    for (; ; ) {
+      const sellers = session.getBranch().filter(isSellers);
+      const at = last.through === void 0 ? -1 : sellers.findIndex((entry) => entry.id === last.through);
+      if (last.through !== void 0 && at < 0) {
+        const newest = sellers.at(-1);
+        if (newest === void 0) return;
+        last = keep({ through: newest.id });
+        continue;
+      }
+      const next = sellers[at + 1];
+      if (next === void 0) return;
+      if (await judge(ctx, next.id) === "stopped") return;
+      last = keep({ through: next.id });
+    }
+  }
+  function poke(ctx) {
+    if (over) return;
+    wanted = ctx;
+    if (running !== void 0) return;
+    running = (async () => {
+      while (wanted !== void 0 && !over) {
+        const now = wanted;
+        wanted = void 0;
+        try {
+          await walk(now);
+        } catch {
+        }
+      }
+      running = void 0;
+    })();
+  }
+  return {
+    arrived: () => {
+      arrivals += 1;
+    },
+    context(ctx) {
+      if (arrivals === 0) return;
+      arrivals = 0;
+      poke(ctx);
+    },
+    started: poke,
+    stopped: () => {
+      over = true;
+    },
+    async idle() {
+      while (running !== void 0) await running;
+    }
+  };
+}
+
+// src/source-packages/cx-topics/box/extensions/topics.ts
+var TITLE_WORDS = 8;
+var TITLE_CHARS = 80;
+var QUOTED_CHARS = 8e3;
+var AROUND_CHARS = 1e3;
+var AROUND = 2;
+function title(raw) {
+  const words2 = raw.replace(/\s+/g, " ").trim().split(" ").slice(0, TITLE_WORDS).join(" ");
+  const cut3 = [...words2].slice(0, TITLE_CHARS).join("").trim();
+  return cut3 === "" ? void 0 : cut3;
+}
+var blocksOf = (content) => typeof content === "string" ? [{ type: "text", text: content }] : Array.isArray(content) ? content : [];
+var cut2 = (text2, chars) => text2.length <= chars ? text2 : `${text2.slice(0, chars)} [${text2.length - chars} more characters]`;
+var when = (timestamp) => {
+  const at = new Date(timestamp);
+  return Number.isNaN(at.getTime()) ? "" : ` \xB7 ${at.toISOString().slice(0, 16).replace("T", " ")} UTC`;
+};
+var UNDRAWN = "topic";
+function parts(entry) {
+  const blocks = blocksOf("content" in entry.message ? entry.message.content : void 0);
+  const words2 = blocks.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n").trim();
+  const steps = blocks.filter((block) => block.type === "toolCall" && block.name !== UNDRAWN).map((block) => `(step: ${block.name ?? "tool"})`);
+  return { words: words2, steps };
+}
+function line(entry, chars) {
+  const who = entry.message.role === "user" ? "seller" : "cx";
+  const { words: words2, steps } = parts(entry);
+  return [`[${who}${when(entry.timestamp)}]`, ...words2 === "" ? [] : [cut2(words2, chars)], ...steps].join("\n");
+}
+var isSaid = (entry) => entry.type === "message" && (entry.message.role === "user" || entry.message.role === "assistant");
+var isShown = (entry) => {
+  const { words: words2, steps } = parts(entry);
+  return words2 !== "" || steps.length > 0;
+};
+function quoted(session, id) {
+  const said = session.entries().filter(isSaid).filter((entry) => entry.id === id || isShown(entry));
+  const at = said.findIndex((entry) => entry.id === id);
+  if (at < 0) return "This message is from an earlier conversation and can't be read here.";
+  const around = (from, to) => said.slice(Math.max(0, from), Math.max(0, to)).map((entry) => line(entry, AROUND_CHARS));
+  return [
+    ...around(at - AROUND, at),
+    `>>> The quoted message:
+${line(said[at], QUOTED_CHARS)}
+<<<`,
+    ...around(at + 1, at + 1 + AROUND)
+  ].join("\n\n");
+}
+var text = (words2) => ({ content: [{ type: "text", text: words2 }], details: {} });
+var TOOL = "quoted";
+function ownKey(pi, file) {
+  const own = pi.getAllTools().find((tool) => tool.name === TOOL && typeof tool.sourceInfo?.path === "string" && resolve(tool.sourceInfo.path) === resolve(file));
+  return own === void 0 || typeof own.sourceInfo.source !== "string" ? void 0 : installKey(own.sourceInfo.source);
+}
+var readText = (file) => {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return void 0;
+  }
+};
+function topics(pi) {
+  const file = fileURLToPath(import.meta.url);
+  const pass = createPass({
+    title,
+    setLabel: (id, label) => pi.setLabel(id, label),
+    keep: (progress) => pi.appendEntry(PROGRESS, progress),
+    token: (ctx) => tokenIn(readText(join(ctx.cwd, INSTALLS_FILE)), ownKey(pi, file))
+  });
+  pi.on("message_end", (event) => {
+    if (event.message.role === "user") pass.arrived();
+  });
+  pi.on("context", (_event, ctx) => {
+    pass.context(ctx);
+  });
+  pi.on("session_start", (_event, ctx) => {
+    pass.started(ctx);
+  });
+  pi.on("session_shutdown", () => {
+    pass.stopped();
+  });
+  pi.registerTool({
+    name: TOOL,
+    label: "Read the quoted message",
+    description: "Read a message the seller quoted, by its entry id, with the messages around it.",
+    promptSnippet: "Read a message the seller quoted, by the `entry` attribute of its `<quote>` tag, with the messages around it",
+    promptGuidelines: ['When the seller\'s message holds `<quote entry="\u2026">`, call `quoted` with that entry before answering; the words inside are what the seller selected.'],
+    parameters: { type: "object", properties: { entry: { type: "string" } }, required: ["entry"] },
+    async execute(_call, params, _signal, _update, ctx) {
+      return text(quoted({ entries: () => ctx.sessionManager.getEntries() }, params.entry));
+    }
+  });
+}
+export {
+  AROUND,
+  AROUND_CHARS,
+  QUOTED_CHARS,
+  TITLE_CHARS,
+  TITLE_WORDS,
+  topics as default,
+  ownKey,
+  quoted,
+  title
+};

package/package.json

@@ -1,6 +1,21 @@
 {
   "name": "@comchatx/cx-topics",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HS-Jack-YZY/ComChatX.git",
+    "directory": "src/source-packages/cx-topics"
+  },
+  "keywords": [
+    "pi-package"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.