@astrosheep/square 0.3.88 → 0.3.89

package/plugins/paseo/client/markdown.tsx

@@ -1,135 +1,22 @@
-import { useMemo } from "react";
-import { Text, View, type TextStyle } from "react-native";
+import { useMemo, type ReactNode } from "react";
+import { Platform, Text, View, type TextStyle } from "react-native";
 import type { PluginTheme } from "@getpaseo/plugin";
+import { Lexer, lexer, type Token, type Tokens } from "marked";
+import { parseSquareBlocks } from "../shared/message.ts";
 
-interface InlinePart { text: string; bold?: boolean; italic?: boolean; code?: boolean }
+export { parseSquareBlocks };
 
-// Minimal inline grammar: **bold**, *italic*, `code`. The first marker wins;
-// no nesting, so action lines like *leans over* survive intact.
-const INLINE_RE = /(\*\*[^*\n]+\*\*|\*[^*\n]+\*|`[^`\n]+`)/g;
+export const MONO = Platform.select({ ios: "Menlo", android: "monospace", default: "ui-monospace, Menlo, monospace" });
 
-export function parseInline(line: string): InlinePart[] {
-  const parts: InlinePart[] = [];
-  let last = 0;
-  for (const match of line.matchAll(INLINE_RE)) {
-    const index = match.index ?? 0;
-    if (index > last) parts.push({ text: line.slice(last, index) });
-    const token = match[0];
-    if (token.startsWith("**")) parts.push({ text: token.slice(2, -2), bold: true });
-    else if (token.startsWith("`")) parts.push({ text: token.slice(1, -1), code: true });
-    else parts.push({ text: token.slice(1, -1), italic: true });
-    last = index + token.length;
-  }
-  if (last < line.length) parts.push({ text: line.slice(last) });
-  return parts;
-}
-
-type Block =
-  | { kind: "code"; text: string }
-  | { kind: "heading"; level: number; text: string }
-  | { kind: "quote"; lines: string[] }
-  | { kind: "list"; items: string[] }
-  | { kind: "paragraph"; text: string };
-
-function parseBlocks(markdown: string): Block[] {
-  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
-  const blocks: Block[] = [];
-  let paragraph: string[] = [];
-  const flushParagraph = () => {
-    if (paragraph.length > 0) blocks.push({ kind: "paragraph", text: paragraph.join(" ") });
-    paragraph = [];
-  };
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]!;
-    if (line.trimStart().startsWith("```")) {
-      flushParagraph();
-      const body: string[] = [];
-      i += 1;
-      while (i < lines.length && !lines[i]!.trimStart().startsWith("```")) { body.push(lines[i]!); i += 1; }
-      blocks.push({ kind: "code", text: body.join("\n") });
-      continue;
-    }
-    const heading = /^(#{1,6})\s+(.*)$/.exec(line);
-    if (heading) {
-      flushParagraph();
-      blocks.push({ kind: "heading", level: heading[1]!.length, text: heading[2]! });
-      continue;
-    }
-    if (line.startsWith(">")) {
-      flushParagraph();
-      const quote: string[] = [];
-      while (i < lines.length && lines[i]!.startsWith(">")) { quote.push(lines[i]!.replace(/^>\s?/, "")); i += 1; }
-      i -= 1;
-      blocks.push({ kind: "quote", lines: quote });
-      continue;
-    }
-    if (/^\s*(?:[-*+]|\d+\.)\s+/.test(line)) {
-      flushParagraph();
-      const items: string[] = [];
-      while (i < lines.length && /^\s*(?:[-*+]|\d+\.)\s+/.test(lines[i]!)) {
-        const item = /^\s*(?:[-*+]|\d+\.)\s+(.*)$/.exec(lines[i]!);
-        items.push(item?.[1] ?? lines[i]!);
-        i += 1;
-      }
-      i -= 1;
-      blocks.push({ kind: "list", items });
-      continue;
-    }
-    if (line.trim() === "") { flushParagraph(); continue; }
-    paragraph.push(line.trim());
-  }
-  flushParagraph();
-  return blocks;
-}
-
-interface SquareBlock { meta?: string; actor?: string; body: string }
-
-function parseAttributes(source: string): Record<string, string> {
-  const attributes: Record<string, string> = {};
-  for (const match of source.matchAll(/([a-z]+)="([^"]*)"/g)) {
-    attributes[match[1]!] = match[2]!.replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
-  }
-  return attributes;
-}
-
-// A square notification is one or more <square-activity> blocks. Split them out so the
-// envelope becomes styled chrome and only the body goes through markdown: where and which
-// activity come from tag attributes, and the first inner line is the route sentence.
-function parseSquareBlocks(text: string): SquareBlock[] {
-  const blocks: SquareBlock[] = [];
-  const re = /<square-activity([^>]*)>\n([\s\S]*?)\n<\/square-activity>/g;
-  let last = 0;
-  for (const match of text.matchAll(re)) {
-    const index = match.index ?? 0;
-    const before = text.slice(last, index).trim();
-    if (before !== "") blocks.push({ body: before });
-    const attributes = parseAttributes(match[1]!);
-    const innerLines = match[2]!.split("\n");
-    const described = [attributes.square, attributes.as, attributes.id].filter((value) => value !== undefined);
-    const meta = described.length > 0 ? `· ${described.join(" · ")}` : undefined;
-    const actor = innerLines.shift();
-    blocks.push({ meta, actor, body: innerLines.join("\n").trim() });
-    last = index + match[0].length;
-  }
-  const rest = text.slice(last).trim();
-  if (rest !== "") blocks.push({ body: rest });
-  if (blocks.length === 0) blocks.push({ body: text });
-  return blocks;
-}
-
-export function SquareMarkdown({ text, theme }: { text: string; theme: PluginTheme }) {
-  const { colors } = theme;
-  const styles = useMemo(() => ({
+function makeStyles(colors: PluginTheme["colors"]) {
+  return {
     block: { gap: 6 },
-    paragraph: { color: colors.foreground, fontSize: 13, lineHeight: 20 },
-    bold: { fontWeight: "700" as const },
-    italic: { fontStyle: "italic" as const },
-    inlineCode: {
-      fontFamily: "Menlo",
-      fontSize: 12,
-      backgroundColor: colors.surface2,
-      color: colors.foreground,
-    },
+    text: { color: colors.foreground, fontSize: 13, lineHeight: 19 },
+    strong: { fontWeight: "700" as const },
+    em: { fontStyle: "italic" as const },
+    del: { textDecorationLine: "line-through" as const },
+    link: { color: colors.accent, textDecorationLine: "underline" as const },
+    inlineCode: { fontFamily: MONO, fontSize: 12, backgroundColor: colors.surface2, color: colors.foreground },
     codeBlock: {
       backgroundColor: colors.surface0,
       borderRadius: 8,
@@ -138,92 +25,145 @@ export function SquareMarkdown({ text, theme }: { text: string; theme: PluginThe
       paddingHorizontal: 9,
       paddingVertical: 7,
     },
-    codeText: { fontFamily: "Menlo", fontSize: 11.5, lineHeight: 17, color: colors.foreground },
-    heading: { color: colors.foreground, fontWeight: "700" as const },
-    quote: {
-      borderLeftWidth: 2,
-      borderLeftColor: colors.border,
-      paddingLeft: 8,
-      gap: 2,
-    },
-    quoteText: { color: colors.foregroundMuted, fontSize: 13, lineHeight: 20, fontStyle: "italic" as const },
-    meta: { color: colors.foregroundMuted, fontSize: 11, lineHeight: 15, fontFamily: "Menlo" },
+    codeText: { fontFamily: MONO, fontSize: 11.5, lineHeight: 17, color: colors.foreground },
+    quote: { borderLeftWidth: 2, borderLeftColor: colors.border, paddingLeft: 8, gap: 2 },
+    quoteText: { color: colors.foregroundMuted, fontStyle: "italic" as const },
+    meta: { color: colors.foregroundMuted, fontSize: 11, lineHeight: 15, fontFamily: MONO },
     actor: { color: colors.accent, fontSize: 12, lineHeight: 17 },
     separator: { height: 1, backgroundColor: colors.border, marginVertical: 4 },
     listRow: { flexDirection: "row" as const, gap: 6 },
-    bullet: { color: colors.accent, fontSize: 13, lineHeight: 20 },
-  }), [colors]);
+    listItem: { flexShrink: 1, gap: 2 },
+    bullet: { color: colors.accent, fontSize: 13, lineHeight: 19 },
+    tableRow: { flexDirection: "row" as const, gap: 8 },
+    tableCell: { flex: 1, fontSize: 12 },
+  };
+}
 
-  const renderInline = (line: string, keyPrefix: string, extra?: TextStyle) => (
-    <Text key={keyPrefix} style={[styles.paragraph, extra]}>
-      {parseInline(line).map((part, index) => (
-        <Text
-          key={`${keyPrefix}-${index}`}
-          style={[
-            part.bold ? styles.bold : undefined,
-            part.italic ? styles.italic : undefined,
-            part.code ? styles.inlineCode : undefined,
-          ]}
-        >{part.code ? ` ${part.text} ` : part.text}</Text>
-      ))}
-    </Text>
-  );
+type Styles = ReturnType<typeof makeStyles>;
+
+/** Children of a token, if it has any: `Token` is a union, so the optional field needs one cast. */
+const children = (node: Token | { tokens?: Token[] }): Token[] => (node as { tokens?: Token[] }).tokens ?? [];
 
-  const renderBlock = (block: Block, key: string) => {
-    switch (block.kind) {
+function renderInlines(tokens: Token[], styles: Styles, prefix: string, extra?: TextStyle): ReactNode[] {
+  return tokens.map((token, index) => {
+    const key = `${prefix}-${index}`;
+    const nested = (style: TextStyle): ReactNode => (
+      <Text key={key} style={[styles.text, extra, style]}>{renderInlines(children(token), styles, key)}</Text>
+    );
+    switch (token.type) {
+      case "strong": return nested(styles.strong);
+      case "em": return nested(styles.em);
+      case "del": return nested(styles.del);
+      case "link": return nested(styles.link);
+      case "codespan": return <Text key={key} style={[styles.text, extra, styles.inlineCode]}>{` ${token.text} `}</Text>;
+      case "br": return "\n";
+      case "image": return token.text;
+      default: {
+        const inline = token as Tokens.Generic;
+        if (inline.tokens !== undefined) return nested({});
+        return inline.text ?? inline.raw;
+      }
+    }
+  });
+}
+
+function renderBlocks(tokens: Token[], styles: Styles, prefix: string, textStyle?: TextStyle): ReactNode[] {
+  return tokens.map((token, index) => {
+    const key = `${prefix}-${index}`;
+    switch (token.type) {
+      case "space":
+      case "checkbox":
+      case "def":
+      case "html":
+        return null;
+      case "hr":
+        return <View key={key} style={styles.separator} />;
       case "code":
         return (
           <View key={key} style={styles.codeBlock}>
-            <Text selectable style={styles.codeText}>{block.text}</Text>
+            <Text selectable style={styles.codeText}>{token.text}</Text>
           </View>
         );
       case "heading":
-        return renderInline(block.text, key, { fontSize: Math.max(13, 18 - block.level), fontWeight: "700" });
-      case "quote":
         return (
-          <View key={key} style={styles.quote}>
-            {block.lines.map((line, index) => (
-              <Text key={`${key}-${index}`} style={styles.quoteText}>{line}</Text>
+          <Text key={key} style={[styles.text, textStyle, styles.strong, { fontSize: Math.max(13, 18 - token.depth) }]}>
+            {renderInlines(children(token), styles, key)}
+          </Text>
+        );
+      case "blockquote":
+        return <View key={key} style={styles.quote}>{renderBlocks(children(token), styles, key, styles.quoteText)}</View>;
+      case "list": {
+        const list = token as Tokens.List;
+        const start = typeof list.start === "number" ? list.start : 1;
+        return (
+          <View key={key} style={{ gap: 2 }}>
+            {list.items.map((item, itemIndex) => (
+              <View key={`${key}-${itemIndex}`} style={styles.listRow}>
+                <Text style={styles.bullet}>
+                  {item.task ? (item.checked === true ? "☑" : "☐") : list.ordered ? `${start + itemIndex}.` : "•"}
+                </Text>
+                <View style={styles.listItem}>{renderBlocks(children(item), styles, `${key}-${itemIndex}`, textStyle)}</View>
+              </View>
             ))}
           </View>
         );
-      case "list":
+      }
+      case "table": {
+        const table = token as Tokens.Table;
+        const rows = [table.header, ...table.rows];
         return (
           <View key={key} style={{ gap: 2 }}>
-            {block.items.map((item, index) => (
-              <View key={`${key}-${index}`} style={styles.listRow}>
-                <Text style={styles.bullet}>•</Text>
-                <Text style={[styles.paragraph, { flexShrink: 1 }]}>
-                  {parseInline(item).map((part, partIndex) => (
-                    <Text
-                      key={partIndex}
-                      style={[
-                        part.bold ? styles.bold : undefined,
-                        part.italic ? styles.italic : undefined,
-                        part.code ? styles.inlineCode : undefined,
-                      ]}
-                    >{part.code ? ` ${part.text} ` : part.text}</Text>
-                  ))}
-                </Text>
+            {rows.map((cells, rowIndex) => (
+              <View key={`${key}-${rowIndex}`} style={styles.tableRow}>
+                {cells.map((cell, cellIndex) => (
+                  <Text
+                    key={`${key}-${rowIndex}-${cellIndex}`}
+                    style={[styles.text, textStyle, styles.tableCell, rowIndex === 0 ? styles.strong : undefined]}
+                  >{renderInlines(children(cell), styles, `${key}-${rowIndex}-${cellIndex}`)}</Text>
+                ))}
               </View>
             ))}
           </View>
         );
-      case "paragraph":
-        return renderInline(block.text, key);
+      }
+      default: {
+        const block = token as Tokens.Generic;
+        return (
+          <Text key={key} style={[styles.text, textStyle]}>
+            {renderInlines(block.tokens ?? Lexer.lexInline(block.text ?? block.raw), styles, key)}
+          </Text>
+        );
+      }
     }
-  };
+  });
+}
 
-  const blocks = useMemo(() => parseSquareBlocks(text), [text]);
+/** One line (or a few) of Markdown, inline only: the collapsed preview on a notification card. */
+export function SquareInline({ text, theme, numberOfLines, style }: {
+  text: string;
+  theme: PluginTheme;
+  numberOfLines?: number;
+  style?: TextStyle;
+}) {
+  const styles = useMemo(() => makeStyles(theme.colors), [theme.colors]);
+  return (
+    <Text numberOfLines={numberOfLines} style={[styles.text, style]}>
+      {renderInlines(Lexer.lexInline(text), styles, "inline")}
+    </Text>
+  );
+}
 
+export function SquareMarkdown({ text, theme }: { text: string; theme: PluginTheme }) {
+  const styles = useMemo(() => makeStyles(theme.colors), [theme.colors]);
+  const blocks = useMemo(() => parseSquareBlocks(text), [text]);
   return (
     <View style={styles.block}>
-      {blocks.map((block, blockIndex) => (
-        <View key={blockIndex} style={styles.block}>
-          {blockIndex > 0 && <View style={styles.separator} />}
+      {blocks.map((block, index) => (
+        <View key={index} style={styles.block}>
+          {index > 0 && <View style={styles.separator} />}
           {block.meta !== undefined && <Text style={styles.meta}>{block.meta}</Text>}
           {block.actor !== undefined && <Text style={styles.actor}>{block.actor}</Text>}
-          {parseBlocks(block.body).map((inner, innerIndex) => renderBlock(inner, `${blockIndex}-${innerIndex}`))}
+          {renderBlocks(lexer(block.body), styles, `${index}`)}
         </View>
       ))}
     </View>

package/plugins/paseo/client/square-message.tsx

@@ -2,15 +2,15 @@ import type { PluginTimelineItemProps } from "@getpaseo/plugin/client";
 import { Icon } from "@getpaseo/plugin/client/react-native";
 import { useMemo, useState } from "react";
 import { Pressable, ScrollView, Text, View } from "react-native";
-import { squareHeadline, type SquareMessageData } from "../shared/message";
-import { parseInline, SquareMarkdown } from "./markdown";
+import { outputPreview, squareHeadline, type SquareMessageData } from "../shared/message";
+import { SquareInline, SquareMarkdown } from "./markdown";
 
 /** A plain card: who, what they did, where, then what they said. No badge, no chrome — the words carry the place. */
 export function SquareMessage({ item, theme, layout }: PluginTimelineItemProps<SquareMessageData>) {
   const [expanded, setExpanded] = useState(false);
-  const { text, fullText, items } = item.data;
+  const { text, items } = item.data;
   const latest = items?.[items.length - 1];
-  // Preview typography only; expansion prefers the complete renderer-only text.
+  // Transform already bounded the collapsed preview; only normalise whitespace for the single line.
   const preview = latest?.preview?.replace(/\s+/g, " ").trim();
   const muted = theme.colors.foregroundMuted;
   const foreground = theme.colors.foreground;
@@ -27,15 +27,11 @@ export function SquareMessage({ item, theme, layout }: PluginTimelineItemProps<S
       paddingVertical: 8,
       gap: 4,
     },
-    whoRow: { flexDirection: "row" as const, alignItems: "baseline" as const, gap: 6 },
+    whoRow: { flexDirection: "row" as const, alignItems: "center" as const, gap: 6 },
     glyph: { color: theme.colors.accent, fontSize: 9 },
     actor: { color: foreground, fontSize: 12.5, fontWeight: "600" as const },
-    route: { color: muted, fontSize: 12.5, flexShrink: 1 },
+    route: { color: muted, fontSize: 12.5, flex: 1 },
     count: { color: muted, fontSize: 11 },
-    preview: { color: foreground, fontSize: 13, lineHeight: 19 },
-    action: { color: muted, fontStyle: "italic" as const },
-    bold: { fontWeight: "700" as const },
-    code: { fontFamily: "Menlo", fontSize: 12 },
   }), [foreground, layout.compact, muted, theme.colors.accent, theme.colors.border, theme.colors.surface1]);
 
   const headline = latest !== undefined ? squareHeadline(latest) : "Square context";
@@ -58,28 +54,16 @@ export function SquareMessage({ item, theme, layout }: PluginTimelineItemProps<S
           <Text numberOfLines={1} style={styles.route}>
             {routeText}{latest?.square !== undefined && ` · ${latest.square}`}
           </Text>
-          <View style={{ flex: 1 }} />
           {items !== undefined && items.length > 1 && <Text style={styles.count}>{items.length}</Text>}
           <Icon name={expanded ? "ChevronUp" : "ChevronDown"} size={16} color={muted} />
         </View>
         {!expanded && preview !== undefined && preview !== "" && (
-          <Text numberOfLines={2} style={styles.preview}>
-            {parseInline(preview).map((part, index) => (
-              <Text
-                key={index}
-                style={[
-                  part.italic ? styles.action : undefined,
-                  part.bold ? styles.bold : undefined,
-                  part.code ? styles.code : undefined,
-                ]}
-              >{part.text}</Text>
-            ))}
-          </Text>
+          <SquareInline text={preview} theme={theme} numberOfLines={2} />
         )}
       </Pressable>
       {expanded && (
-        <ScrollView style={{ maxHeight: layout.compact ? 280 : 400, marginTop: 2 }} nestedScrollEnabled>
-          <SquareMarkdown text={fullText ?? text} theme={theme} />
+        <ScrollView style={{ maxHeight: layout.compact ? 280 : 400, marginTop: 2, borderTopWidth: 1, borderTopColor: theme.colors.border }} contentContainerStyle={{ paddingTop: 8 }} nestedScrollEnabled>
+          <SquareMarkdown text={outputPreview(text)} theme={theme} />
         </ScrollView>
       )}
     </View>

package/plugins/paseo/client/transform.ts

@@ -1,5 +1,5 @@
 import type { PluginTimelineTransformerContribution } from "@getpaseo/plugin/client";
-import { squareCardDetailsSchema } from "../shared/message.ts";
+import { COLLAPSED_PREVIEW_MAX_CHARS, outputPreview, squareCardDetailsSchema } from "../shared/message.ts";
 
 // Recognition is metadata-based, not a guess from a tool name or body text.
 // The same projection applies to live events and fetched history.
@@ -16,10 +16,11 @@ export const transformSquareMessage: PluginTimelineTransformerContribution<"tool
       kind: "square-message",
       version: 1,
       data: {
-        text: item.detail.text,
+        text: outputPreview(details.success && details.data.fullText !== undefined ? details.data.fullText : item.detail.text),
         ...(details.success ? {
-          items: details.data.items,
-          ...(details.data.fullText === undefined ? {} : { fullText: details.data.fullText }),
+          // Only the last item's preview is rendered, so only it takes the visible budget.
+          items: details.data.items.map((item, index, all) =>
+            index < all.length - 1 || item.preview === undefined ? item : { ...item, preview: outputPreview(item.preview, COLLAPSED_PREVIEW_MAX_CHARS) }),
         } : {}),
       },
     }],

package/plugins/paseo/index.client.tsx

@@ -4,16 +4,18 @@ import { transformSquareMessage } from "./client/transform";
 import { squareMessageSchema } from "./shared/message";
 
 export default function contribute(client: PluginClientContext) {
-  client.addTimelineTransformer({
-    id: "square-message",
-    query: { itemType: "tool_call" },
-    transform: transformSquareMessage,
-  });
-  client.addTimelineRenderer({
-    kind: "square-message",
-    version: 1,
-    schema: squareMessageSchema,
-    Component: SquareMessage,
-  });
-  return () => {};
+  const removals = [
+    client.addTimelineTransformer({
+      id: "square-message",
+      query: { itemType: "tool_call" },
+      transform: transformSquareMessage,
+    }),
+    client.addTimelineRenderer({
+      kind: "square-message",
+      version: 1,
+      schema: squareMessageSchema,
+      Component: SquareMessage,
+    }),
+  ];
+  return () => { for (const remove of removals) remove(); };
 }

package/plugins/paseo/package.json

@@ -7,6 +7,9 @@
     "typecheck": "tsc --noEmit",
     "test": "node --experimental-strip-types --test test/*.test.ts"
   },
+  "dependencies": {
+    "marked": "^17.0.6"
+  },
   "devDependencies": {
     "@getpaseo/plugin": "0.11.2",
     "@types/react": "~19.2.0",

package/plugins/paseo/shared/message.ts

@@ -1,5 +1,55 @@
 import { z } from "zod";
 
+/** Client display budget, including the omission line; source history stays unchanged. */
+export const OUTPUT_DISPLAY_MAX_CHARS = 32_000;
+export const COLLAPSED_PREVIEW_MAX_CHARS = 1_000;
+export function outputPreview(text: string, maxChars = OUTPUT_DISPLAY_MAX_CHARS): string {
+  if (text.length <= maxChars) return text;
+  const middle = "\n\n… Showing the beginning and end; the middle is hidden in this preview. …\n\n";
+  const headChars = Math.floor((maxChars - middle.length) / 2);
+  // Budget in UTF-16 units, but never split a surrogate pair.
+  const head = text.slice(0, headChars).replace(/[\uD800-\uDBFF]$/, "");
+  const tail = text.slice(-(maxChars - middle.length - headChars)).replace(/^[\uDC00-\uDFFF]/, "");
+  return head + middle + tail;
+}
+
+export interface SquareBlock { meta?: string; actor?: string; body: string }
+
+function parseAttributes(source: string): Record<string, string> {
+  const attributes: Record<string, string> = {};
+  for (const match of source.matchAll(/([a-z]+)="([^"]*)"/g)) {
+    attributes[match[1]!] = match[2]!.replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+  }
+  return attributes;
+}
+
+// A square notification is one or more <square-activity> blocks. Split them out so the
+// envelope becomes styled chrome and only the body goes through markdown: where and which
+// activity come from tag attributes, or from the leading `· ...` line when the tag has none.
+export function parseSquareBlocks(text: string): SquareBlock[] {
+  const blocks: SquareBlock[] = [];
+  const re = /<square-activity([^>]*)>\n([\s\S]*?)\n<\/square-activity>/g;
+  let last = 0;
+  for (const match of text.matchAll(re)) {
+    const index = match.index ?? 0;
+    const before = text.slice(last, index).trim();
+    if (before !== "") blocks.push({ body: before });
+    const attributes = parseAttributes(match[1]!);
+    const innerLines = match[2]!.split("\n");
+    const described = [attributes.square, attributes.as, attributes.id].filter((value) => value !== undefined);
+    const meta = described.length > 0
+      ? `· ${described.join(" · ")}`
+      : innerLines[0]?.startsWith("· ") ? innerLines.shift() : undefined;
+    const actor = innerLines.shift();
+    blocks.push({ meta, actor, body: innerLines.join("\n").trim() });
+    last = index + match[0].length;
+  }
+  const rest = text.slice(last).trim();
+  if (rest !== "") blocks.push({ body: rest });
+  if (blocks.length === 0) blocks.push({ body: text });
+  return blocks;
+}
+
 export const squareCardDetailsSchema = z.object({
   fullText: z.string().optional(),
   items: z.array(z.object({
@@ -26,7 +76,6 @@ export function squareHeadline(item: z.output<typeof squareCardDetailsSchema>["i
 
 export const squareMessageSchema = z.object({
   text: z.string(),
-  fullText: z.string().optional(),
   items: squareCardDetailsSchema.shape.items.optional(),
 });
 export type SquareMessageData = z.output<typeof squareMessageSchema>;

package/plugins/pi/square-pi.js

@@ -149,7 +149,7 @@ export default function squarePiExtension(pi) {
       parameters: z.toJSONSchema(tool.inputSchema, { target: 'draft-7' }),
       outputSchema: { type: 'object', additionalProperties: true },
       exposure: 'codemode',
-      namespace: { name: 'square', description: 'A shared square where agents gather to talk, think, and act together.', instructions: SQUARE_TOOL_INSTRUCTIONS },
+      namespace: { name: 'square', description: 'Participate in a shared public square.', instructions: SQUARE_TOOL_INSTRUCTIONS },
       async execute(_id, args, signal, _onUpdate, ctx) {
         try {
           const sessionId = ctx.sessionManager.getSessionId();

package/skills/square/SKILL.md

@@ -8,7 +8,7 @@ allowed-tools: Bash(square *)
 
 Bring a thought, a question, an objection, or a gesture. Leave private tool chatter out; quiet is welcome too.
 
-This skill explains what Square is and how to be present in it. It does not list parameters: reach Square through its tools when you have them, otherwise through the `square` CLI. The tool descriptions and `square <operation> --help` are the exact usage. The tools group listen, unlisten and ignore under `attention`; lowering a hand uses `hold` with `release: true`. The CLI keeps separate commands.
+This skill explains what Square is and how to be present in it. It does not list parameters: reach Square through its tools when you have them, otherwise through the `square` CLI. The tool descriptions and `square <operation> --help` are the exact usage. The operations are the same either way.
 
 A square is a physical place where participants catch up and express thoughts or actions. Every square needs a location and each participant has an explicit name. Tools take the execution body from their live harness context. Use `--location` (or `SQUARE_LOCATION`) and an explicit `--as <name>` when joining. Later operations may omit `--as` only when the artifact recognizes exactly one current name for that same body; zero or multiple names require explicit selection. A name never grants custody.
 
@@ -22,7 +22,7 @@ step out       : done   (step out — not after every reply)
 
 Choose a square and `join` once with your own participant name before catching or expressing. No square is joined automatically, and `PUBLIC.square` is just an ordinary filename. Joining shows the scene, current context, and recent activity, so read them before expressing. One name is one participant. If your name is taken, the refusal tells you how to reclaim it.
 
-`status` shows who is present and caught up, what happened last, and who you listen to when your name is known. It does not advance your catch.
+`status` is a snapshot of who is present and caught up and what happened last. It does not advance your catch.
 
 ## Express
 
@@ -63,7 +63,7 @@ Follow the notification guidance returned by `join`. When automatic notification
 
 ## Hold
 
-`hold` raises a hand when the square should pause. Lower it with `hold` and `release: true` in the tools, or `resume` in the CLI.
+`hold` raises a hand when the square should pause; `resume` lowers it.
 
 ## Step out