@stevecastaneda/paseo-progress 1.13.0 → 1.14.0

package/client/tabs.tsx

@@ -1,7 +1,9 @@
 import type { PluginWorkspacePanelProps } from "@getpaseo/plugin/client";
 import { Icon } from "@getpaseo/plugin/client/ui";
-import React, { useState } from "react";
-import { Pressable, Text, View } from "react-native";
+import React, { useRef, useState } from "react";
+import { type LayoutChangeEvent, Pressable, ScrollView, Text, View } from "react-native";
+import { useReducedMotion } from "./motion";
+import { withAlpha } from "./surfaces";
 
 type Colors = PluginWorkspacePanelProps["theme"]["colors"];
 
@@ -13,39 +15,131 @@ export interface TabEntry<Id extends string> {
   count?: number;
 }
 
+// What the row does when its tabs don't fit on one line: wrap onto a second line,
+// drop the icons first and wrap only if that's still not enough, or scroll
+// sideways in one row, as on phones, where a faded edge and an arrow show there's more.
+export type TabOverflow = "wrap" | "fit" | "scroll";
+
 // A row of tabs over a bottom rule, as in the panel's history card and the
 // ticket dialog. Narrow tightens the spacing so three tabs fit the 320px sidebar.
-// `fit` drops the icons when the tabs would otherwise wrap onto a second line.
-export function TabStrip<Id extends string>({ colors, tabs, selected, onSelect, narrow = false, fit = false, style }: {
+export function TabStrip<Id extends string>({ colors, tabs, selected, onSelect, narrow = false, overflow = "wrap", style }: {
   colors: Colors;
   tabs: Array<TabEntry<Id>>;
   selected: Id;
   onSelect(id: Id): void;
   narrow?: boolean;
-  fit?: boolean;
+  overflow?: TabOverflow;
   style?: object;
 }) {
   // Set once the tabs wrapped with icons, for this set of tabs.
   const ids = tabs.map((entry) => entry.id).join();
   const [wrappedFor, setWrappedFor] = useState<string | null>(null);
-  const iconless = fit && wrappedFor === ids;
+  const scroller = useRef<ScrollView>(null);
+  const widths = useRef(new Map<string, number>());
+  // The tab the row last scrolled to; null until the first scroll, which jumps.
+  const revealed = useRef<string | null>(null);
+  const size = useRef({ viewport: 0, content: 0, offset: 0 });
+  const [hidden, setHidden] = useState({ before: false, after: false });
+  const reduced = useReducedMotion();
+  const scroll = overflow === "scroll";
+  // Scrolling rows go without icons, so less of the row is hidden.
+  const iconless = scroll || (overflow === "fit" && wrappedFor === ids);
+  const gap = narrow ? 10 : 16;
+  const rule = { borderBottomWidth: 1, borderBottomColor: colors.border };
+  // The next scrolling row is a new scroll view, which starts at the left.
+  if (!scroll) {
+    size.current.offset = 0;
+    revealed.current = null;
+    if (hidden.before || hidden.after) setHidden({ before: false, after: false });
+  }
+  // Centers a tab in the visible part of the row, so the ones beside it show too.
+  // Positions come from widths, since a tab that moves without resizing never reports it.
+  const reveal = (id: string) => {
+    const upTo = tabs.slice(0, tabs.findIndex((entry) => entry.id === id) + 1).map((entry) => widths.current.get(entry.id));
+    const { viewport } = size.current;
+    if (!upTo.length || !viewport || upTo.includes(undefined)) return;
+    const width = upTo.pop()!;
+    const x = upTo.reduce((sum: number, w) => sum + w! + gap, 0);
+    scroller.current?.scrollTo({ x: Math.max(0, x + width / 2 - viewport / 2), animated: !reduced && revealed.current !== null });
+    revealed.current = id;
+  };
+  // Scrolls to the chosen tab once it can be measured, and not again until the choice changes.
+  const settle = () => { if (revealed.current !== selected) reveal(selected); };
+  // A chevron press moves the row most of its width that way.
+  const page = (direction: 1 | -1) => {
+    const { viewport, content, offset } = size.current;
+    const x = Math.max(0, Math.min(offset + direction * (viewport - 48), content - viewport));
+    scroller.current?.scrollTo({ x, animated: !reduced });
+  };
+  // Which ends have tabs scrolled out of sight, so those edges fade.
+  const measure = (next: Partial<typeof size.current>) => {
+    const s = Object.assign(size.current, next);
+    const before = s.offset > 1;
+    const after = s.offset + s.viewport < s.content - 1;
+    if (before !== hidden.before || after !== hidden.after) setHidden({ before, after });
+  };
+  const items = tabs.map((entry) => (
+    <Tab key={entry.id} colors={colors} narrow={narrow} entry={iconless ? { ...entry, icon: null } : entry} selected={entry.id === selected}
+      onPress={() => { onSelect(entry.id); if (scroll) reveal(entry.id); }}
+      onLayout={scroll ? (event) => { widths.current.set(entry.id, event.nativeEvent.layout.width); settle(); } : undefined} />
+  ));
+  if (scroll) {
+    // Scrolling rows sit on Paseo's phone sheet, which is surface0.
+    return (
+      <View style={[{ position: "relative" }, style]}>
+        <ScrollView ref={scroller} horizontal showsHorizontalScrollIndicator={false} accessibilityRole="tablist" scrollEventThrottle={16}
+          onLayout={(event) => { measure({ viewport: event.nativeEvent.layout.width }); settle(); }}
+          onContentSizeChange={(width) => measure({ content: width })}
+          onScroll={(event) => measure({ offset: event.nativeEvent.contentOffset.x })}
+          contentContainerStyle={{ flexGrow: 1, flexDirection: "row", columnGap: gap, ...rule }}>
+          {items}
+        </ScrollView>
+        {hidden.before ? <EdgeFade colors={colors} side="left" onPress={() => page(-1)} /> : null}
+        {hidden.after ? <EdgeFade colors={colors} side="right" onPress={() => page(1)} /> : null}
+      </View>
+    );
+  }
   return (
     <View accessibilityRole="tablist"
       // One row is 32px (8 + 18 + 6); anything taller wrapped.
-      onLayout={fit ? (event) => { if (!iconless && event.nativeEvent.layout.height > 40) setWrappedFor(ids); } : undefined}
-      style={[{ flexDirection: "row", flexWrap: "wrap", columnGap: narrow ? 10 : 16, borderBottomWidth: 1, borderBottomColor: colors.border }, style]}>
-      {tabs.map((entry) => (
-        <Tab key={entry.id} colors={colors} narrow={narrow} entry={iconless ? { ...entry, icon: null } : entry} selected={entry.id === selected} onPress={() => onSelect(entry.id)} />
+      onLayout={overflow === "fit" ? (event) => { if (!iconless && event.nativeEvent.layout.height > 40) setWrappedFor(ids); } : undefined}
+      style={[{ flexDirection: "row", flexWrap: "wrap", columnGap: gap, ...rule }, style]}>
+      {items}
+    </View>
+  );
+}
+
+const FADE_SLICES = 12;
+
+// Fades a row that scrolls on past this edge, with a chevron at the edge, so the
+// cue shows even when the next tab sits wholly out of sight. The slices stand in
+// for a gradient, which React Native Web lacks (see pill-popover.tsx).
+function EdgeFade({ colors, side, onPress }: { colors: Colors; side: "left" | "right"; onPress(): void }) {
+  return (
+    <View pointerEvents="box-none" style={{ position: "absolute", top: 0, bottom: 0, [side]: 0, flexDirection: side === "right" ? "row" : "row-reverse" }}>
+      {Array.from({ length: FADE_SLICES }, (_, i) => (
+        <View key={i} pointerEvents="none" style={{ width: 2, backgroundColor: withAlpha(colors.surface0, (i + 1) / (FADE_SLICES + 1)) ?? undefined }} />
       ))}
+      <Pressable accessibilityElementsHidden importantForAccessibility="no-hide-descendants" onPress={onPress} hitSlop={8}
+        style={{ width: 16, justifyContent: "center", alignItems: side === "right" ? "flex-end" : "flex-start", backgroundColor: colors.surface0 }}>
+        <Icon name={side === "right" ? "ChevronRight" : "ChevronLeft"} size={14} color={colors.foregroundMuted} />
+      </Pressable>
     </View>
   );
 }
 
 // Instant feedback: tabs switch often, so hover and press change color only.
-function Tab<Id extends string>({ colors, narrow, entry, selected, onPress }: { colors: Colors; narrow: boolean; entry: TabEntry<Id>; selected: boolean; onPress(): void }) {
+function Tab<Id extends string>({ colors, narrow, entry, selected, onPress, onLayout }: {
+  colors: Colors;
+  narrow: boolean;
+  entry: TabEntry<Id>;
+  selected: boolean;
+  onPress(): void;
+  onLayout?(event: LayoutChangeEvent): void;
+}) {
   const [hovered, setHovered] = useState(false);
   return (
-    <Pressable accessibilityRole="tab" accessibilityState={{ selected }} onPress={onPress}
+    <Pressable accessibilityRole="tab" aria-selected={selected} onPress={onPress} onLayout={onLayout}
       onHoverIn={() => setHovered(true)} onHoverOut={() => setHovered(false)}
       style={({ pressed }) => ({
         flexDirection: "row", alignItems: "center", gap: narrow ? 4 : 6, paddingTop: 8, paddingBottom: 6, marginBottom: -1,

package/client/ticket-dialog.tsx

@@ -22,27 +22,30 @@ type AttachmentContext = { workspaceId: string; workspaceDirectory: string; navi
 
 // A ticket's story, opened from its row: where its time went, and what came out
 // of it. Its questions and previews open in the same dialog (see StackedDialog).
-export function TicketDialogs({ colors, dashboard, openId, setOpenId, now, live, context }: {
+export function TicketDialogs({ colors, dashboard, openId, setOpenId, now, live, compact, context }: {
   colors: Colors;
   dashboard: Dashboard;
   openId: string | null;
   setOpenId(id: string | null): void;
   now: number;
   live: boolean;
+  compact: boolean;
   context: AttachmentContext;
 }) {
   return (
     <StackedDialog colors={colors} root={openId ? { kind: "ticket", id: openId } : null} onClose={() => setOpenId(null)}
-      questions={[...dashboard.questions.open, ...dashboard.questions.answered]} dashboard={dashboard} now={now} live={live} context={context} />
+      questions={[...dashboard.questions.open, ...dashboard.questions.answered]} dashboard={dashboard} now={now} live={live} compact={compact} context={context} />
   );
 }
 
-export function TicketStoryView({ colors, dashboard, ticket, now, live, context, onOpenAttachment, onOpenQuestion, onOpenAgent }: {
+export function TicketStoryView({ colors, dashboard, ticket, now, live, compact, context, onOpenAttachment, onOpenQuestion, onOpenAgent }: {
   colors: Colors;
   dashboard: Dashboard;
   ticket: Ticket;
   now: number;
   live: boolean;
+  // Paseo's phone-sized layout.
+  compact: boolean;
   context: AttachmentContext;
   onOpenAttachment(attachment: Attachment, group: Attachment[]): void;
   onOpenQuestion(id: string): void;
@@ -138,7 +141,7 @@ export function TicketStoryView({ colors, dashboard, ticket, now, live, context,
       </View>
 
       <View style={{ gap: 12 }}>
-        {tabs.length > 1 ? <TabStrip colors={colors} tabs={tabs} selected={current.id} onSelect={choose} fit /> : null}
+        {tabs.length > 1 ? <TabStrip colors={colors} tabs={tabs} selected={current.id} onSelect={choose} overflow={compact ? "scroll" : "fit"} /> : null}
         {current.content}
       </View>
 
@@ -187,7 +190,7 @@ function AgentRow({ colors, agentId, onOpen }: { colors: Colors; agentId: string
       <Text numberOfLines={1} style={{ flexShrink: 1, color: colors.foregroundMuted, fontSize: 12, lineHeight: 17 }}>{title}</Text>
       {alert ? <Text numberOfLines={1} style={{ flexShrink: 0, color: alert.danger ? colors.statusDanger : colors.statusWarning, fontSize: 12, lineHeight: 17 }}>{alert.text}</Text> : null}
       <View style={{ flex: 1 }} />
-      {open ? <Text style={{ color: colors.foregroundMuted, fontSize: 12, lineHeight: 17, fontWeight: "500" }}>{m.openChat}</Text> : null}
+      {open ? <Text numberOfLines={1} style={{ flexShrink: 0, color: colors.foregroundMuted, fontSize: 12, lineHeight: 17, fontWeight: "500" }}>{m.openChat}</Text> : null}
     </PressableRow>
   );
 }

package/client/write-up.tsx

@@ -71,7 +71,7 @@ function TextButton({ colors, icon, label, accessibilityLabel, onPress, grow = f
   colors: Colors; icon?: string; label: string; accessibilityLabel?: string; onPress(): void; grow?: boolean; expanded?: boolean;
 }) {
   return (
-    <PressableRow colors={colors} accessibilityRole="button" accessibilityLabel={accessibilityLabel ?? label} accessibilityState={expanded === undefined ? undefined : { expanded }} onPress={onPress}
+    <PressableRow colors={colors} accessibilityRole="button" accessibilityLabel={accessibilityLabel ?? label} aria-expanded={expanded} onPress={onPress}
       style={{ flexDirection: "row", alignItems: "center", gap: 6, paddingVertical: 3, paddingHorizontal: 6, marginHorizontal: -6, borderRadius: 4, flexShrink: grow ? 1 : 0, minWidth: 0 }}>
       {icon ? <Icon name={icon} size={12} color={colors.foregroundMuted} /> : null}
       <Text numberOfLines={1} style={{ flexShrink: 1, color: colors.foregroundMuted, fontSize: 12, lineHeight: 17, fontWeight: "500" }}>{label}</Text>

package/dist/server/cli.js

@@ -21055,6 +21055,12 @@ function guessKind(target, isUrl, cwd) {
 var SHOW_SUMMARY = "Print the dashboard as text: what the user sees in the Progress panel.";
 var INSTALL_SUMMARY = "Write the paseo-progress launcher (default ~/.local/bin/paseo-progress). It runs this command from whichever copy of the plugin Paseo is running.";
 var DEFAULT_LAUNCHER = "~/.local/bin/paseo-progress";
+function commandSummary(name) {
+  if (name === "show") return SHOW_SUMMARY;
+  const command = commands[name];
+  if (!command) throw new Error(`No command named ${name}.`);
+  return command.summary;
+}
 function help() {
   return [
     `Usage: ${USAGE_NAME} <command>`,
@@ -21166,5 +21172,6 @@ if (isMain()) {
   );
 }
 export {
+  commandSummary,
   runCli
 };

package/index.client.tsx

@@ -7,6 +7,8 @@ import { ProgressLanguageProvider } from "./client/language";
 import { addPageScreen } from "./client/page-screen";
 import { PdfPanel } from "./client/pdf";
 import { showsPdfs } from "./shared/attachments";
+import { CHAT_ROW_KIND, CHAT_ROW_VERSION, chatRowSchema, transformChatRow } from "./client/chat-row";
+import { ChatRowView } from "./client/chat-row-view";
 
 const SETTINGS_ID = "settings";
 
@@ -45,8 +47,17 @@ export default function contribute(client: PluginClientContext) {
     icon: "Settings",
     Component: (props) => <ProgressLanguageProvider><QuestionSettings {...props} /></ProgressLanguageProvider>,
   });
+  const stopTransformer = client.addTimelineTransformer({ id: "tool-calls", query: { itemType: "tool_call" }, transform: transformChatRow });
+  const stopRenderer = client.addTimelineRenderer({
+    kind: CHAT_ROW_KIND,
+    version: CHAT_ROW_VERSION,
+    schema: chatRowSchema,
+    Component: (props) => <ProgressLanguageProvider><ChatRowView {...props} /></ProgressLanguageProvider>,
+  });
 
   return () => {
+    void stopTransformer();
+    void stopRenderer();
     stopPage();
     void stopPdf();
     void stopSettings();

package/index.server.ts

@@ -4,8 +4,9 @@ import { handleInstallLauncher, handleLauncherStatus } from "./server/launcher";
 import { handleCanOpenOnHost, handleOpenDeliverable, handlePreviewDeliverable, handleReadDeliverablePiece } from "./server/open";
 import { mirrorQuestionMode } from "./server/question-mode";
 import { handleInstallSkill, handleReadSkill, handleSkillStatus, repairSkill } from "./server/skill";
+import { attachProgressTools, handleToolsStatus } from "./server/tool";
 import { handleDismissWhatsNew, handleGetWhatsNew } from "./server/whats-new";
-import { canOpenOnHost, dismissWhatsNew, getAttention, getDashboard, getLauncherStatus, getSkillStatus, getWhatsNew, installLauncher, installSkill, listFolders, readSkill, markPanelOpened, openDeliverable, previewDeliverable, readDeliverablePiece, setHistoryFolder } from "./shared/rpc";
+import { canOpenOnHost, dismissWhatsNew, getAttention, getDashboard, getLauncherStatus, getSkillStatus, getToolsStatus, getWhatsNew, installLauncher, installSkill, listFolders, readSkill, markPanelOpened, openDeliverable, previewDeliverable, readDeliverablePiece, setHistoryFolder } from "./shared/rpc";
 import { displaySettings, questionSettings } from "./shared/settings";
 
 export default function contribute(server: PluginServerContext) {
@@ -23,12 +24,14 @@ export default function contribute(server: PluginServerContext) {
   server.handle(readSkill, handleReadSkill);
   server.handle(listFolders, handleListFolders);
   server.handle(setHistoryFolder, handleSetHistoryFolder);
+  server.handle(getToolsStatus, handleToolsStatus);
   server.handle(getWhatsNew, handleGetWhatsNew);
   server.handle(dismissWhatsNew, handleDismissWhatsNew);
   // Settles a new install before any panel opens. Opening one makes a
   // worktree folder, which would look like an earlier version's.
   void handleGetWhatsNew().catch(() => {});
   void repairSkill();
+  attachProgressTools(server);
   server.registerSettings(displaySettings);
   const mirror = mirrorQuestionMode(server.registerSettings(questionSettings));
   return mirror.stop;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stevecastaneda/paseo-progress",
-  "version": "1.13.0",
-  "description": "A live progress dashboard per worktree for Paseo, drawn from a file agents write with the paseo-progress command.",
+  "version": "1.14.0",
+  "description": "A live progress dashboard per worktree for Paseo, drawn from a file agents write with the Progress tools or the paseo-progress command.",
   "license": "MIT",
   "author": "Steve Castaneda",
   "repository": {
@@ -50,8 +50,8 @@
     "postpack": "rm -rf dist"
   },
   "devDependencies": {
-    "@getpaseo/client": "0.13.0",
-    "@getpaseo/plugin": "0.13.0",
+    "@getpaseo/client": "0.14.0",
+    "@getpaseo/plugin": "0.14.0",
     "@tanstack/react-query": "^5.90.11",
     "@types/node": "^20.9.0",
     "@types/react": "~19.2.0",

package/paseo-plugin.json

@@ -6,7 +6,9 @@
     "images/2-ticket.png",
     "images/3-question.png",
     "images/4-pill.png",
-    "images/5-settings.png"
+    "images/5-settings.png",
+    "images/6-chat-rows.png",
+    "images/7-empty-tools-note.png"
   ],
   "requirements": {
     "paseo": ">=0.13.0"

package/server/cli.ts

@@ -494,6 +494,14 @@ const SHOW_SUMMARY = "Print the dashboard as text: what the user sees in the Pro
 const INSTALL_SUMMARY = "Write the paseo-progress launcher (default ~/.local/bin/paseo-progress). It runs this command from whichever copy of the plugin Paseo is running.";
 const DEFAULT_LAUNCHER = "~/.local/bin/paseo-progress";
 
+// The agent tools describe themselves with the summaries agents see in --help.
+export function commandSummary(name: string): string {
+  if (name === "show") return SHOW_SUMMARY;
+  const command = commands[name];
+  if (!command) throw new Error(`No command named ${name}.`);
+  return command.summary;
+}
+
 function help(): string {
   return [
     `Usage: ${USAGE_NAME} <command>`,

package/server/tool.ts

@@ -0,0 +1,174 @@
+import type { AgentToolContext, AgentToolDefinition, AgentToolResult, PluginHandlerContext, PluginServerContext } from "@getpaseo/plugin/server";
+import * as sdk from "@getpaseo/plugin/server";
+import { z } from "zod";
+import { DELIVERABLE_KINDS, ticketStatusSchema } from "../shared/events.ts";
+import type { ToolsState } from "../shared/rpc.ts";
+import { PROGRESS_TOOL_NAMES, type ProgressToolName } from "../shared/tools.ts";
+import { commandSummary, runCli } from "./cli.ts";
+
+// Paseo supplies this SDK at runtime. Paseo 0.13's has no defineAgentTool and
+// can't give agents plugin tools; reading the name calls nothing, so it's safe there.
+export const agentToolsSupported = "defineAgentTool" in sdk;
+
+// Importing defineAgentTool would stop Progress loading on Paseo 0.13. This
+// mirrors its typing; Paseo validates the input before execute.
+type Tool = Omit<AgentToolDefinition, "name">;
+
+function agentTool<Input extends z.ZodType>(tool: Omit<Tool, "input" | "execute"> & {
+  input: Input;
+  execute(input: z.output<Input>, context: AgentToolContext): Promise<AgentToolResult>;
+}): Tool {
+  return { ...tool, execute: (input, context) => tool.execute(input as z.output<Input>, context) };
+}
+
+async function run(args: string[], { agent }: AgentToolContext): Promise<AgentToolResult> {
+  const lines: string[] = [];
+  const code = await runCli(args, { cwd: agent.cwd, agentId: agent.id, out: (line) => lines.push(line) });
+  return { text: lines.join("\n"), isError: code !== 0 };
+}
+
+type Flags = Record<string, string | number | string[] | undefined>;
+
+// Flags go as --name=value so a value starting with "-" stays a value, and the
+// positionals follow "--" so a title starting with "-" isn't read as a flag.
+function commandArgs(command: string, positionals: string[], flags: Flags = {}): string[] {
+  const options = Object.entries(flags).flatMap(([name, value]) => (value === undefined ? [] : [value].flat().map((entry) => `--${name}=${entry}`)));
+  return [...command.split(" "), ...options, "--", ...positionals];
+}
+
+// The command's --help summary, with its flags renamed to this tool's fields.
+const FIELD_FOR_FLAG: Record<string, string> = { estimate: "estimateMinutes", option: "options", file: "files" };
+function toolSummary(command: string): string {
+  return commandSummary(command).replace(/--([a-z]+(?:-[a-z]+)*)/g, (_, flag: string) =>
+    FIELD_FOR_FLAG[flag] ?? flag.replace(/-([a-z])/g, (_m, letter: string) => letter.toUpperCase()));
+}
+
+function commandTool<Input extends z.ZodType>(title: string, command: string, input: Input, args: (input: z.output<Input>) => string[], extra = "") {
+  return agentTool({
+    title: `Progress: ${title}`,
+    description: `Progress dashboard for this worktree in Paseo. ${toolSummary(command)}${extra}`,
+    input,
+    execute: (value, context) => run(args(value), context),
+  });
+}
+
+const ticketId = (what: string) => z.string().describe(`${what}, like T03`);
+const estimate = z.number().int().describe("Whole minutes, like 90");
+const source = z.string().describe("Spec file path or http(s) link where the ticket is written up");
+
+// Keyed by name, so the compiler holds this to the shared list.
+const tools: Record<ProgressToolName, Tool> = {
+  progress_show: commandTool("Show", "show", z.object({}), () => ["show"]),
+  progress_start: commandTool("Start run", "start",
+    z.object({
+      title: z.string(),
+      subtitle: z.string().optional(),
+      itemLabel: z.string().optional().describe('What to call each item instead of "Ticket", like Step'),
+    }),
+    ({ title, subtitle, itemLabel }) => commandArgs("start", [title], { subtitle, "item-label": itemLabel })),
+  progress_ticket_add: commandTool("Add ticket", "ticket add",
+    z.object({
+      title: z.string().describe('Like "Ticket 01: Export button"'),
+      estimateMinutes: estimate,
+      status: ticketStatusSchema.optional(),
+      waitsFor: ticketId("A ticket this one can't start before").optional(),
+      source: source.optional(),
+    }),
+    ({ title, estimateMinutes, status, waitsFor, source }) => commandArgs("ticket add", [title], { estimate: estimateMinutes, status, "waits-for": waitsFor, source })),
+  progress_ticket_update: commandTool("Update ticket", "ticket update",
+    z.object({
+      id: ticketId("The ticket"),
+      status: ticketStatusSchema.optional(),
+      stage: z.string().optional().describe('The step in progress, like Build or Fixes; "" clears it'),
+      title: z.string().optional(),
+      estimateMinutes: estimate.optional(),
+      note: z.string().optional(),
+      waitsFor: z.string().optional().describe('A ticket this one can\'t start before, like T02; "" clears it'),
+      source: z.string().optional().describe('Spec file path or http(s) link where the ticket is written up; "" clears it'),
+    }),
+    ({ id, status, stage, title, estimateMinutes, note, waitsFor, source }) =>
+      commandArgs("ticket update", [id], { status, stage, title, estimate: estimateMinutes, note, "waits-for": waitsFor, source })),
+  progress_question_ask: commandTool("Ask question", "question ask",
+    z.object({
+      title: z.string().describe("A short title"),
+      question: z.string(),
+      options: z.array(z.object({
+        letter: z.string().describe("A, B, C, ..."),
+        label: z.string(),
+        consequence: z.string().describe("What picking it means for the user"),
+      })),
+      recommend: z.string().describe("The option letter you would pick"),
+      big: z.string().optional().describe("Only for a big question: which test it meets, in a few plain words"),
+      background: z.string().optional(),
+      files: z.array(z.object({
+        target: z.string().describe("A file path or http(s) link, like a screenshot"),
+        label: z.string().optional(),
+      })).optional(),
+      ticket: ticketId("The ticket it's about").optional(),
+    }),
+    ({ title, question, options, recommend, big, background, files, ticket }) => commandArgs("question ask", [title, question], {
+      option: options.map(({ letter, label, consequence }) => `${letter}=${label} | ${consequence}`),
+      recommend,
+      big,
+      background,
+      file: files?.map(({ target, label }) => (label ? `${target}=${label}` : target)),
+      ticket,
+    })),
+  progress_question_answer: commandTool("Record answer", "question answer",
+    z.object({
+      id: z.string().describe("The question, like Q2"),
+      choice: z.string().describe("An option letter, or the user's own short answer"),
+      words: z.string().optional().describe("What the user said"),
+    }),
+    ({ id, choice, words }) => commandArgs("question answer", [id, choice], { words })),
+  progress_deliverable_add: commandTool("Add deliverable", "deliverable add",
+    z.object({
+      title: z.string(),
+      target: z.string().describe("A file or folder path, or an http(s) link"),
+      ticket: ticketId("The ticket it belongs to").optional(),
+      kind: z.enum(DELIVERABLE_KINDS).optional(),
+    }),
+    ({ title, target, ticket, kind }) => commandArgs("deliverable add", [title, target], { ticket, kind })),
+  progress_activity_add: commandTool("Log activity", "activity add",
+    z.object({ text: z.string(), ticket: ticketId("The ticket it's about").optional() }),
+    ({ text, ticket }) => commandArgs("activity add", [text], { ticket })),
+  progress_ticker: commandTool("Set ticker", "ticker set",
+    z.object({ text: z.string() }),
+    ({ text }) => (text.trim() ? commandArgs("ticker set", [text]) : commandArgs("ticker clear", [])),
+    ' Pass "" to hide it.'),
+  progress_finish: commandTool("Finish run", "finish",
+    z.object({ outcome: z.string().describe("One line") }),
+    ({ outcome }) => commandArgs("finish", [outcome])),
+  paseo_progress: agentTool({
+    title: "Progress",
+    description: [
+      "Record progress for this worktree on the Progress panel in Paseo. Works like the paseo-progress command:",
+      'pass its arguments as a list, like ["ticket", "add", "Fix login", "--estimate", "30"].',
+      'Pass ["--help"] to list the commands, or add "--help" after any command for its options.',
+    ].join(" "),
+    input: z.object({ args: z.array(z.string()).min(1).describe("Arguments for paseo-progress, one per item") }),
+    execute: ({ args }, context) => run(args, context),
+  }),
+};
+
+export const progressTools: AgentToolDefinition[] = PROGRESS_TOOL_NAMES.map((name) => ({ name, ...tools[name] }));
+
+export function attachProgressTools(server: PluginServerContext): void {
+  server.before("agent.session_open", ({ request }) => {
+    // Paseo 0.13 has no tools list and fails the session open if a plugin adds one.
+    if (!Array.isArray(request.tools)) return;
+    return { ...request, tools: [...request.tools, ...progressTools] };
+  });
+}
+
+// Tools reach agents only while the host's "Enable Paseo tools" setting is on,
+// which needs Paseo's tools (mcp.enabled) on as well.
+export async function toolsState(supported: boolean, paseo: PluginHandlerContext["paseo"]): Promise<ToolsState> {
+  if (!supported) return "unsupported";
+  const { config } = await paseo.config.get();
+  return config.mcp.enabled !== false && config.mcp.injectIntoAgents ? "on" : "off";
+}
+
+export async function handleToolsStatus(_input: unknown, { paseo }: PluginHandlerContext): Promise<{ state: ToolsState }> {
+  return { state: await toolsState(agentToolsSupported, paseo) };
+}

package/shared/rpc.ts

@@ -69,6 +69,17 @@ export const installLauncher = defineRpc({
   output: launcherStatus,
 });
 
+// Whether agents get the Progress tools: "unsupported" before Paseo 0.14, then
+// whether the host's "Enable Paseo tools" setting is "on" or "off".
+export const TOOLS_STATES = ["unsupported", "off", "on"] as const;
+export type ToolsState = (typeof TOOLS_STATES)[number];
+
+export const getToolsStatus = defineRpc({
+  name: "progress.tools.status",
+  input: z.object({}),
+  output: z.object({ state: z.enum(TOOLS_STATES) }),
+});
+
 // The paseo-progress skill, linked into each agent's skills folder.
 const skillState = z.enum(["missing", "current", "outdated", "foreign"]);
 const skillStatus = z.object({

package/shared/tools.ts

@@ -0,0 +1,23 @@
+// The tools Progress hands agents on Paseo 0.14 and later. The server defines
+// one tool per name, and the chat draws Progress's own row for a call to any of them.
+export const PROGRESS_TOOL_NAMES = [
+  "progress_show",
+  "progress_start",
+  "progress_ticket_add",
+  "progress_ticket_update",
+  "progress_question_ask",
+  "progress_question_answer",
+  "progress_deliverable_add",
+  "progress_activity_add",
+  "progress_ticker",
+  "progress_finish",
+  "paseo_progress",
+] as const;
+
+export type ProgressToolName = (typeof PROGRESS_TOOL_NAMES)[number];
+
+// Chats record a tool under the agent's own prefix: Claude Code's
+// mcp__paseo__progress_ticket_add, or Codex's paseo.progress_ticket_add.
+export function progressToolName(name: string): ProgressToolName | undefined {
+  return PROGRESS_TOOL_NAMES.find((tool) => name === tool || name.endsWith(`__${tool}`) || name.endsWith(`.${tool}`));
+}

package/skills/paseo-progress/SKILL.md

@@ -1,15 +1,19 @@
 ---
 name: paseo-progress
-description: Keep the Paseo Progress dashboard live with the paseo-progress command. Use when working through a spec or a set of tickets, on any job over 5 steps or 30 minutes, or when the user asks for a progress dashboard.
+description: Keep the Paseo Progress dashboard live with the Progress tools or the paseo-progress command. Use when working through a spec or a set of tickets, on any job over 5 steps or 30 minutes, or when the user asks for a progress dashboard.
 ---
 
 # Paseo progress
 
-The user watches a live dashboard in Paseo for this worktree. Keep it live: run `paseo-progress` from inside the worktree the moment each change happens, so the dashboard is a side effect of the work. Write every line for a product manager, in plain words. `paseo-progress --help` is the reference for every command and flag.
+The user watches a live dashboard in Paseo for this worktree. Keep it live: record each change the moment it happens, so the dashboard is a side effect of the work. Write every line for a product manager, in plain words.
+
+Use the Progress tools when you have them: `progress_show`, `progress_start`, `progress_ticket_add`, `progress_ticket_update`, `progress_question_ask`, `progress_question_answer`, `progress_deliverable_add`, `progress_activity_add`, `progress_ticker`, `progress_finish`, and `paseo_progress` for any other command. Paseo hands them to agents when the user turns on Paseo tools. Claude Code names them like `mcp__paseo__progress_show` and keeps them hidden until you search, so search your tools for `progress_` before your first update. Otherwise, run the `paseo-progress` command from inside the worktree. When a tool call says the tool isn't found, use the command for the rest of that reply.
+
+The tools and the command take the same values and print the same answers. The steps below use the command's words: `--estimate` is `estimateMinutes` in the tools, `--waits-for` is `waitsFor`. `paseo-progress --help` is the reference for every command and flag.
 
 ## 1. Set up
 
-Run `paseo-progress show` and continue an open run for this job. A Finished run is closed, so `start` a new one, then add every ticket in order:
+Run `show` and continue an open run for this job. A Finished run is closed, so `start` a new one, then add every ticket in order:
 
 - Title each `"Ticket 01: <title>"`. The dashboard shortens titles to that prefix.
 - Give each an `--estimate`, plus `--waits-for` when it can't start before another and `--source` when a spec file or issue describes it.
@@ -27,16 +31,20 @@ Move each ticket through `--status working --stage Build`, then the stages `Revi
 - Put this in a subagent's prompt, with the worktree path and ticket id filled in. While you wait on it, its updates are the dashboard's only sign the work is moving:
 
   ```text
-  Record progress on the Paseo dashboard as you work:
-  - at each new stage: cd <worktree> && paseo-progress ticket update T03 --stage <stage>
-  - between stages:    cd <worktree> && paseo-progress ticker set "<what you are doing now>"
+  Record progress on the Paseo dashboard as you work. Use the Progress tools if you
+  have them (search your tools for progress_), otherwise the paseo-progress command.
+  If a tool call says the tool isn't found, use the command for the rest of that reply.
+  - at each new stage: progress_ticket_update with id T03 and stage <stage>,
+    or: cd <worktree> && paseo-progress ticket update T03 --stage <stage>
+  - between stages:    progress_ticker with "<what you are doing now>",
+    or: cd <worktree> && paseo-progress ticker set "<what you are doing now>"
   ```
 
 Done when every ticket is done or skipped, or waits on a question.
 
 ## 3. Ask
 
-When a decision belongs to the user, ask it with `question ask`, lettered `--option`s and your `--recommend`. Read `paseo-progress question ask --help` before your first question. It defines a big question, which you mark with `--big "<the test it meets>"`.
+When a decision belongs to the user, ask it with `question ask`, lettered `--option`s and your `--recommend`. Read the `progress_question_ask` description or `paseo-progress question ask --help` before your first question. Both define a big question, which you mark with `--big "<the test it meets>"`.
 
 The user picks the question mode in Paseo's Settings, and `question ask` prints what that mode means for this question. Do what it prints. Record the user's reply ("Q7 A", or their own words) with `question answer Q7 A --words "<their words>"`, and do what that prints too.
 
@@ -45,6 +53,6 @@ The user picks the question mode in Paseo's Settings, and `question ask` prints
 
 ## 4. Finish
 
-The job is over when every ticket is done or skipped and every question is answered. While questions wait on the user, leave the run open and tell the user in chat which ones. Then run `paseo-progress finish "<one-line outcome>"`, and settle whatever it lists if it refuses.
+The job is over when every ticket is done or skipped and every question is answered. While questions wait on the user, leave the run open and tell the user in chat which ones. Then `finish` with a one-line outcome, and settle whatever it lists if it refuses.
 
 Done when `show` says Finished with the right outcome.