feat(ticktick): external task views — contract spike + hidden web/worker lanes

.github/workflows/ticktick-live-smoke.yml

@@ -0,0 +1,51 @@
+name: ticktick-live-smoke
+
+# The plan's credentialed LIVE contract validation (docs/plans/
+# external-task-views-plan.md): deterministic tests use hand-authored wire
+# values, so upstream TickTick schema/tool drift stays green locally — this job
+# is the drift detector. Scheduled weekly + manually dispatchable; deliberately
+# NOT part of the PR gate (needs a repo secret; must not hammer the live API).
+#
+# Two lanes, each through its production surface (review R10 #3):
+#   - OpenAPI (Web lane): the `#[ignore]`d Rust test `live_openapi_contract_smoke`
+#     runs the REAL decoder (reqwest → wire.rs → normalize) and asserts
+#     representative-shape counters (the smoke account stages due/tags/checklist).
+#   - MCP (Worker lane): scripts/ticktick-live-smoke.mjs asserts initialize +
+#     tools/list still offer the exact read allowlist.
+# Both are non-capturing: counts/booleans only reach the log.
+
+on:
+  schedule:
+    - cron: "17 6 * * 1"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  smoke:
+    name: live-contract-smoke
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: "."
+          shared-key: core
+      - name: Smoke the OpenAPI lane through the production decoder
+        env:
+          TICKTICK_ACCESS_TOKEN: ${{ secrets.TICKTICK_ACCESS_TOKEN }}
+        run: >
+          cargo test --manifest-path crates/core/Cargo.toml
+          live_openapi_contract_smoke -- --ignored --nocapture
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+      - name: Smoke the MCP lane (initialize + tools/list allowlist)
+        env:
+          TICKTICK_ACCESS_TOKEN: ${{ secrets.TICKTICK_ACCESS_TOKEN }}
+        run: node scripts/ticktick-live-smoke.mjs

apps/web/src/components/ToolActivity.tsx

@@ -1,12 +1,16 @@
+import { EXTERNAL_TOOL_PREFIX, isExternalToolName } from "@inkstone/protocol";
 import {
 	AlertTriangle,
 	BookOpen,
 	Check,
+	ChevronRight,
+	ListChecks,
 	type LucideIcon,
 	Search,
 	Sparkles,
 	Wrench,
 } from "lucide-react";
+import { useState } from "react";
 import { cn } from "@/lib/utils.js";
 import type { ToolCall } from "@/store/chat";
 
@@ -47,6 +51,12 @@ function humanize(name: string): string {
 function presentation(name: string): ToolPresentation {
 	const known = TOOL_PRESENTATION[name];
 	if (known) return known;
+	if (isExternalToolName(name)) {
+		// An external (Worker-executed MCP) tool: label it by its TickTick verb
+		// (external-task-views A3/A4) — read-only by the dual allowlist.
+		const label = `TickTick · ${name.slice(EXTERNAL_TOOL_PREFIX.length).replace(/[_-]+/g, " ")}`;
+		return { active: label, done: label, Icon: ListChecks, access: "read" };
+	}
 	const label = humanize(name);
 	return { active: label, done: label, Icon: Wrench };
 }
@@ -58,21 +68,26 @@ const MAX_VISIBLE_ARGS = 3;
  * into one row, except errored calls — each is its own group so the failed arg
  * is never buried in a survivors' row. `status` is the aggregate (running if any
  * member is in flight). `args` is capped at {@link MAX_VISIBLE_ARGS}; `overflow`
- * is how many more were folded away. `key` is stable across renders. */
+ * is how many more were folded away. `key` is stable across renders. `call` is
+ * set ONLY for external (`ticktick_*`) break-outs (external-task-views A4): the
+ * single call the row represents, whose `result` the expansion reveals. */
 export type ToolCallGroup = {
 	key: string;
 	name: string;
 	status: ToolCall["status"];
 	args: string[];
 	overflow: number;
+	call?: ToolCall;
 };
 
 /** Collapse a turn's tool calls into grouped rows (ADR-0043). Non-errored calls
  * of the same tool merge (args deduped + joined, in first-seen order, status
- * running-if-any); each errored call breaks out into its own row. Groups are
- * ordered by first occurrence; a tool's errored break-out sorts at the position
- * of its first errored call. Shared by the live and rehydrated paths, so both
- * render identically. */
+ * running-if-any); each errored call breaks out into its own row. EXTERNAL
+ * (`ticktick_*`) calls NEVER group (external-task-views A4): one expandable row
+ * per call, keyed by `tool_call_id`, so two same-name calls keep their distinct
+ * results. Groups are ordered by first occurrence; a tool's errored break-out
+ * sorts at the position of its first errored call. Shared by the live and
+ * rehydrated paths, so both render identically. */
 export function groupToolCalls(
 	toolCalls: readonly ToolCall[],
 ): ToolCallGroup[] {
@@ -83,6 +98,20 @@ export function groupToolCalls(
 	for (const call of toolCalls) {
 		const arg = call.arg?.trim() ? call.arg.trim() : undefined;
 
+		// External calls never merge (A4): per-call identity is the point — the
+		// row expands to THIS call's model-received result.
+		if (isExternalToolName(call.name)) {
+			groups.push({
+				key: call.id,
+				name: call.name,
+				status: call.status,
+				args: [],
+				overflow: 0,
+				call,
+			});
+			continue;
+		}
+
 		// Errored calls never merge — each is its own row showing the failed arg.
 		if (call.status === "error") {
 			groups.push({
@@ -140,13 +169,109 @@ export function ToolActivity({
 			aria-live="polite"
 			className="flex w-full flex-col gap-1.5"
 		>
-			{groups.map((group) => (
-				<ToolCallRow key={group.key} group={group} />
-			))}
+			{groups.map((group) =>
+				group.call === undefined ? (
+					<ToolCallRow key={group.key} group={group} />
+				) : (
+					<ExternalToolRow key={group.key} call={group.call} />
+				),
+			)}
 		</ul>
 	);
 }
 
+/** One EXTERNAL (`ticktick_*`) call (external-task-views A4): a collapsed
+ * name + status row that expands on demand to the normalized
+ * `TranscriptToolResult.content` the model received — errors identically
+ * (collapsed error row → expanded error content). Never grouped; never shows
+ * credentials or raw MCP metadata (the result IS the normalized content). */
+function ExternalToolRow({ call }: { call: ToolCall }) {
+	const [expanded, setExpanded] = useState(false);
+	const { active, done, Icon } = presentation(call.name);
+	const running = call.status === "running";
+	const errored = call.status === "error";
+	const label = running ? active : done;
+	const contentText = (call.result?.content ?? [])
+		.map((block) => block.text)
+		.join("\n");
+	const expandable = !running && call.result !== undefined;
+
+	const srText = running
+		? `${active}, read-only, in progress`
+		: errored
+			? `${done} failed`
+			: `${done}, read-only, done`;
+
+	return (
+		<li
+			data-testid="tool-call"
+			data-status={call.status}
+			data-external
+			className="flex w-fit max-w-full flex-col"
+		>
+			<button
+				type="button"
+				disabled={!expandable}
+				aria-expanded={expanded}
+				onClick={() => setExpanded((open) => !open)}
+				className={cn(
+					"inline-flex w-fit max-w-full items-center gap-2 rounded-lg px-2.5 py-1.5 text-left text-sm font-medium",
+					"transition-colors duration-200 ease-out-quint",
+					running && "bg-secondary/50 text-foreground",
+					!running && !errored && "text-muted-foreground",
+					errored && "bg-destructive/10 text-destructive",
+					expandable && "cursor-pointer hover:bg-secondary/40",
+				)}
+			>
+				<span
+					aria-hidden
+					className="relative grid size-5 shrink-0 place-items-center rounded-full"
+				>
+					{running && (
+						<span className="tool-glow pointer-events-none absolute inset-0 rounded-full motion-safe:animate-tool-glow" />
+					)}
+					{errored ? (
+						<AlertTriangle className="relative size-4" />
+					) : running ? (
+						<Icon className="relative size-4 text-tool-glyph" />
+					) : (
+						<Check className="relative size-4 motion-safe:animate-tool-pop" />
+					)}
+				</span>
+				<span aria-hidden className="min-w-0 truncate">
+					{label}
+				</span>
+				{errored && (
+					<span aria-hidden className="shrink-0 text-xs">
+						failed
+					</span>
+				)}
+				{expandable && (
+					<ChevronRight
+						aria-hidden
+						className={cn(
+							"size-3.5 shrink-0 text-muted-foreground transition-transform duration-200",
+							expanded && "rotate-90",
+						)}
+					/>
+				)}
+				<span className="sr-only">{srText}</span>
+			</button>
+			{expanded && expandable && (
+				<pre
+					data-testid="tool-call-result"
+					className={cn(
+						"mt-1 max-h-64 w-full max-w-full overflow-auto whitespace-pre-wrap rounded-lg border border-secondary/50 px-3 py-2 text-xs",
+						errored ? "text-destructive" : "text-muted-foreground",
+					)}
+				>
+					{contentText}
+				</pre>
+			)}
+		</li>
+	);
+}
+
 function ToolCallRow({ group }: { group: ToolCallGroup }) {
 	const { active, done, Icon, access } = presentation(group.name);
 	const running = group.status === "running";