@chainingintention/pi-web-cn 2.0.0 → 2.202610.0

package/dist/{pi-web-plugins → pi-packages}/relays/relaysPanelElement.js

@@ -1,7 +1,10 @@
-// Generated from pi-web-plugins/relays/relaysPanelElement.ts. Do not edit directly.
+// Generated from pi-packages/relays/relaysPanelElement.ts. Do not edit directly.
+import { t } from "./i18n.js";
 import { isMarkdownDocumentPath, renderRelayDocumentHtml } from "./markdownDocument.js";
+import { isRelayPacketPath } from "./relayIdentity.js";
 import { ancestorDirectoryPaths, collectDirectoryPaths, defaultRelayDocument, flattenRelayTree, listRelayDocumentTree, listWorkspaceRelays, readRelayDocument, RELAYS_ROOT, } from "./relayDiscovery.js";
 export const relaysPanelTagName = "pi-web-relays-panel";
+export const RELAY_SELECTION_QUERY_KEY = "relay";
 export function defineRelaysPanelElement() {
     if (!customElements.get(relaysPanelTagName))
         customElements.define(relaysPanelTagName, PiWebRelaysPanel);
@@ -20,6 +23,24 @@ export function defineRelaysPanelElement() {
  * horizontal scroll position and keyboard focus survive document switches.
  */
 class PiWebRelaysPanel extends HTMLElement {
+    integration;
+    releaseStyles;
+    set stylesheetIntegration(value) {
+        if (value === this.integration)
+            return;
+        this.releaseStyles?.();
+        this.releaseStyles = undefined;
+        this.integration = value;
+        if (this.isConnected)
+            this.releaseStyles = value?.registerRoot(this.root, { sharedUi: true });
+    }
+    connectedCallback() {
+        this.releaseStyles ??= this.integration?.registerRoot(this.root, { sharedUi: true });
+    }
+    disconnectedCallback() {
+        this.releaseStyles?.();
+        this.releaseStyles = undefined;
+    }
     contextValue;
     listing;
     selectedRelayPath;
@@ -37,9 +58,9 @@ class PiWebRelaysPanel extends HTMLElement {
         this.root = this.attachShadow({ mode: "open" });
         this.root.innerHTML = `
       ${relaysStyles()}
-      <section class="toolbar" hidden></section>
-      <nav class="document-tabs" aria-label="中继文档" hidden></nav>
-      <section class="viewer"><div class="empty">请选择工作区。</div></section>
+      <section class="toolbar ui-toolbar" hidden></section>
+      <nav class="document-tabs ui-tabs" aria-label="${escapeAttr(t("bundled.relays.relay.documents.91711b", "Relay documents"))}" hidden></nav>
+      <section class="viewer"><div class="empty">${escapeHtml(t("bundled.relays.select.a.workspace.234859", "Select a workspace."))}</div></section>
     `;
         this.toolbar = requiredRegion(this.root, ".toolbar");
         this.tabStrip = requiredRegion(this.root, "nav.document-tabs");
@@ -80,32 +101,51 @@ class PiWebRelaysPanel extends HTMLElement {
     set context(value) {
         const previousKey = this.contextValue === undefined ? undefined : contextKey(this.contextValue);
         const nextKey = value === undefined ? undefined : contextKey(value);
+        const previousRelay = linkedRelayPath(this.contextValue);
+        const nextRelay = linkedRelayPath(value);
         this.contextValue = value;
-        // Parent app updates should not rescan or re-render this panel for the
-        // same workspace (mirrors the workspace-tasks panel).
-        if (previousKey === nextKey)
+        // Unrelated host renders should not rescan. A picker already starts its
+        // load before publishing navigation, so adopting that route does not load twice.
+        if (previousKey === nextKey && (previousRelay === nextRelay
+            || (nextRelay !== undefined && nextRelay === this.selectedRelayPath)))
             return;
         this.expandedDirs = new Set();
         if (value === undefined) {
+            ++this.scanToken;
             this.resetScanState();
             this.renderAll();
             return;
         }
-        void this.scan(value, {});
+        void this.scan(value, { relayPath: nextRelay });
     }
     /** Rescan relays, then reload the selected relay's documents and the open document. */
     async scan(context, selection) {
         const token = ++this.scanToken;
         this.resetScanState();
         this.renderAll();
+        const requestedPath = selection.relayPath ?? linkedRelayPath(context);
+        if (requestedPath !== undefined && !isRelayPacketPath(requestedPath)) {
+            this.listing = { kind: "unavailable", detail: t("bundled.relays.invalid.packet.link", "Relay links must select a normalized workspace-relative packet directory.") };
+            this.renderAll();
+            return;
+        }
         const listing = await listWorkspaceRelays(context.files);
         if (!this.isCurrentScan(context, token))
             return;
-        this.listing = listing;
-        // listWorkspaceRelays returns most recently modified first, so the first
-        // relay is the default pre-selection.
-        const relay = listing.kind === "loaded"
-            ? listing.relays.find((candidate) => candidate.path === selection.relayPath) ?? listing.relays[0]
+        // An exact link need not be under the discovery root. Keep that packet in
+        // the picker even if the default root is absent/unavailable, and let its
+        // own document load report a missing or unreadable target rather than
+        // silently substituting another relay.
+        const discovered = listing.kind === "loaded" ? listing.relays : [];
+        this.listing = requestedPath === undefined ? listing : {
+            kind: "loaded",
+            relays: discovered.some((relay) => relay.path === requestedPath) ? discovered : [
+                { name: documentName(requestedPath), path: requestedPath }, ...discovered,
+            ],
+        };
+        // Default discovery remains most recently modified first.
+        const relay = this.listing.kind === "loaded"
+            ? this.listing.relays.find((candidate) => candidate.path === requestedPath) ?? this.listing.relays[0]
             : undefined;
         this.selectedRelayPath = relay?.path;
         this.renderToolbar();
@@ -119,6 +159,7 @@ class PiWebRelaysPanel extends HTMLElement {
         const token = ++this.scanToken;
         this.selectedRelayPath = relayPath;
         this.expandedDirs = new Set();
+        context.navigation?.set(RELAY_SELECTION_QUERY_KEY, relayPath);
         await this.loadDocuments(context, token, relayPath, undefined);
     }
     toggleDirectory(directoryPath) {
@@ -247,10 +288,10 @@ class PiWebRelaysPanel extends HTMLElement {
         }
         this.toolbar.hidden = false;
         this.toolbar.innerHTML = `
-      <strong>中继</strong>
-      <span class="toolbar-actions">
+      <strong class="ui-toolbar-title">${escapeHtml(t("bundled.relays.relays.715ce8", "Relays"))}</strong>
+      <span class="toolbar-actions ui-toolbar-group">
         ${this.renderRelayPicker()}
-        <button class="icon-button" data-refresh aria-label="刷新" title="刷新">${refreshIconSvg()}</button>
+        <button type="button" class="ui-button ui-button--compact ui-button--icon" data-refresh aria-label="${escapeAttr(t("bundled.relays.refresh.aee887", "Refresh"))}" title="${escapeAttr(t("bundled.relays.refresh.aee887", "Refresh"))}">${refreshIconSvg()}</button>
       </span>
     `;
     }
@@ -267,7 +308,7 @@ class PiWebRelaysPanel extends HTMLElement {
             const selected = relay.path === this.selectedRelayPath ? " selected" : "";
             return `<option value="${escapeAttr(relay.path)}"${selected}>${escapeHtml(relay.name)}</option>`;
         }).join("");
-        return `<select data-relay-picker aria-label="中继">${options}</select>`;
+        return `<select class="ui-select" data-relay-picker aria-label="${escapeAttr(t("bundled.relays.relays.715ce8", "Relays"))}">${options}</select>`;
     }
     renderTabs() {
         const documents = this.documents;
@@ -293,26 +334,26 @@ class PiWebRelaysPanel extends HTMLElement {
             const chip = this.renderDirectoryChip(node, containsActivePath);
             if (!this.expandedDirs.has(node.path) || node.children.length === 0)
                 return chip;
-            return `<span class="directory-group">${chip}${this.renderStripNodes(node.children, containsActivePath)}</span>`;
+            return `<span class="directory-group ui-toolbar-group">${chip}${this.renderStripNodes(node.children, containsActivePath)}</span>`;
         }).join("");
     }
     renderFileTab(file) {
         const active = file.path === this.selectedDocumentPath;
-        return `<button class="document-tab${active ? " active" : ""}" data-document-path="${escapeAttr(file.path)}" title="${escapeAttr(file.relativePath)}"${active ? ' aria-current="true"' : ""}>${escapeHtml(file.name)}</button>`;
+        return `<button type="button" class="ui-button ui-tab document-tab${active ? " selected" : ""}" data-document-path="${escapeAttr(file.path)}" title="${escapeAttr(file.relativePath)}"${active ? ' aria-current="page"' : ""}>${escapeHtml(file.name)}</button>`;
     }
     renderDirectoryChip(directory, containsActivePath) {
         const expanded = this.expandedDirs.has(directory.path);
         const containsActive = directory.path === containsActivePath;
-        const title = containsActive ? "包含当前打开的文档" : directory.relativePath;
-        return `<button class="document-tab directory-tab${containsActive ? " contains-active" : ""}" data-directory-path="${escapeAttr(directory.path)}" title="${escapeAttr(title)}" aria-expanded="${expanded ? "true" : "false"}">${chevronSvg()}${escapeHtml(directory.name)}</button>`;
+        const title = containsActive ? t("ui.main.6a634d20bc86", "Contains the open document") : directory.relativePath;
+        return `<button type="button" class="ui-button ui-tab document-tab directory-tab${containsActive ? " contains-active" : ""}" data-directory-path="${escapeAttr(directory.path)}" title="${escapeAttr(title)}" aria-expanded="${expanded ? "true" : "false"}">${chevronSvg()}${escapeHtml(directory.name)}</button>`;
     }
     /** Move the active marker between the mounted tab buttons without rebuilding them. */
     updateActiveTab() {
         for (const tab of this.tabStrip.querySelectorAll("button[data-document-path]")) {
             const active = tab.getAttribute("data-document-path") === this.selectedDocumentPath;
-            tab.classList.toggle("active", active);
+            tab.classList.toggle("selected", active);
             if (active)
-                tab.setAttribute("aria-current", "true");
+                tab.setAttribute("aria-current", "page");
             else
                 tab.removeAttribute("aria-current");
         }
@@ -321,7 +362,7 @@ class PiWebRelaysPanel extends HTMLElement {
     }
     renderViewer() {
         if (this.contextValue === undefined) {
-            this.viewer.innerHTML = `<div class="empty">请选择工作区。</div>`;
+            this.viewer.innerHTML = `<div class="empty">${escapeHtml(t("bundled.relays.select.a.workspace.234859", "Select a workspace."))}</div>`;
             return;
         }
         this.viewer.innerHTML = this.renderViewerContent();
@@ -329,9 +370,9 @@ class PiWebRelaysPanel extends HTMLElement {
     renderViewerContent() {
         const listing = this.listing;
         if (listing === undefined)
-            return `<p class="muted">正在扫描 ${escapeHtml(RELAYS_ROOT)}…</p>`;
+            return `<p class="muted">${escapeHtml(t("bundled.relays.scanning.d7c334", "Scanning {value1}...", { value1: RELAYS_ROOT }))}</p>`;
         if (listing.kind === "unavailable")
-            return renderErrorState("无法扫描工作区中继。", listing.detail);
+            return renderErrorState(t("bundled.relays.could.not.scan.workspace.relays.d8b2bc", "Could not scan workspace relays."), listing.detail);
         if (listing.kind === "missing" || listing.relays.length === 0)
             return renderEmptyState();
         return this.renderSelectedRelay();
@@ -339,20 +380,20 @@ class PiWebRelaysPanel extends HTMLElement {
     renderSelectedRelay() {
         const documents = this.documents;
         if (documents === undefined)
-            return `<p class="muted">正在加载中继文档…</p>`;
+            return `<p class="muted">${escapeHtml(t("bundled.relays.loading.relay.documents.94db7f", "Loading relay documents..."))}</p>`;
         if (documents.kind === "unavailable")
-            return renderErrorState("无法列出此中继的文档。", documents.detail);
+            return renderErrorState(t("bundled.relays.could.not.list.documents.for.this.relay.cad056", "Could not list documents for this relay."), documents.detail);
         if (documents.kind === "missing") {
-            return `<div class="empty-state"><strong>此中继已不存在。</strong><p>点击“刷新”重新扫描 ${escapeHtml(RELAYS_ROOT)}。</p></div>`;
+            return `<div class="empty-state"><strong>${escapeHtml(t("bundled.relays.this.relay.no.longer.exists.f8d39d", "This relay no longer exists."))}</strong><p>${escapeHtml(t("bundled.relays.click.refresh.to.rescan.7a2ef0", "Click Refresh to rescan {value1}.", { value1: RELAYS_ROOT }))}</p></div>`;
         }
         const partialNotice = documents.partial
-            ? `<div class="status info">部分嵌套内容未列出：此中继目录树超过了面板的深度或数量限制。</div>`
+            ? `<div class="status info">${escapeHtml(t("bundled.relays.partial", "Some nested content is omitted because this relay exceeds the panel depth or count limit."))}</div>`
             : "";
         if (documents.documentCount === 0) {
             return `${partialNotice}
         <div class="empty-state">
-          <strong>此中继还没有文档。</strong>
-          <p>中继包通常包含 <code>status.md</code>、<code>charter.md</code> 和 <code>log.md</code>。</p>
+          <strong>${escapeHtml(t("bundled.relays.this.relay.has.no.documents.yet.d5948c", "This relay has no documents yet."))}</strong>
+          <p>${escapeHtml(t("bundled.relays.packet.documents", "Relay packets contain charter.md (goal), status.md (current baton), and log.md (history). An optional decisions.md keeps consequential decisions and their reasons."))}</p>
         </div>
       `;
         }
@@ -362,19 +403,19 @@ class PiWebRelaysPanel extends HTMLElement {
         const documentPath = this.selectedDocumentPath;
         const content = this.documentContent;
         if (documentPath === undefined)
-            return `<p class="muted">请选择文档。</p>`;
+            return `<p class="muted">${escapeHtml(t("bundled.relays.select.a.document.1c46a5", "Select a document."))}</p>`;
         if (content === undefined)
-            return `<p class="muted">正在加载 ${escapeHtml(documentName(documentPath))}…</p>`;
+            return `<p class="muted">${escapeHtml(t("bundled.relays.loading.9f624f", "Loading {value1}...", { value1: documentName(documentPath) }))}</p>`;
         if (content.kind === "unavailable")
-            return renderErrorState("无法读取此文档。", content.detail);
+            return renderErrorState(t("bundled.relays.could.not.read.this.document.7cd2d0", "Could not read this document."), content.detail);
         if (content.kind === "missing") {
-            return `<div class="empty-state"><strong>此文档已不存在。</strong><p>点击“刷新”重新扫描中继。</p></div>`;
+            return `<div class="empty-state"><strong>${escapeHtml(t("bundled.relays.this.document.no.longer.exists.6d4a00", "This document no longer exists."))}</strong><p>${escapeHtml(t("bundled.relays.click.refresh.to.rescan.relays.2fe15f", "Click Refresh to rescan relays."))}</p></div>`;
         }
         if (content.binary) {
-            return `<div class="empty-state"><strong>二进制文件：${escapeHtml(documentName(documentPath))}</strong><p>二进制文档无法提供文本预览。</p></div>`;
+            return `<div class="empty-state"><strong>${escapeHtml(t("bundled.relays.binary.file.f080cb", "Binary file: {value1}", { value1: documentName(documentPath) }))}</strong><p>${escapeHtml(t("bundled.relays.binary.documents.cannot.be.previewed.as.text.535534", "Binary documents cannot be previewed as text."))}</p></div>`;
         }
         const truncation = content.truncated
-            ? `<div class="status info">此文档已截断，仅显示开头内容。</div>`
+            ? `<div class="status info">${escapeHtml(t("bundled.relays.this.document.is.truncated.only.the.beginning.is.shown.bf465f", "This document was truncated; only its beginning is shown."))}</div>`
             : "";
         if (isMarkdownDocumentPath(documentPath)) {
             return `${truncation}<div class="document markdown">${renderRelayDocumentHtml(content.content)}</div>`;
@@ -424,7 +465,11 @@ function chevronSvg() {
     return `<svg class="chevron" viewBox="0 0 16 16" aria-hidden="true" focusable="false"><path d="M6 4l4 4-4 4"></path></svg>`;
 }
 function contextKey(context) {
-    return `${context.machine.id}:${context.workspace.projectId}:${context.workspace.id}`;
+    return JSON.stringify([context.machine.id, context.workspace.projectId, context.workspace.id]);
+}
+function linkedRelayPath(context) {
+    const value = context?.navigation?.query[RELAY_SELECTION_QUERY_KEY];
+    return typeof value === "string" ? value : value?.[0];
 }
 function documentName(path) {
     return path.slice(path.lastIndexOf("/") + 1);
@@ -432,8 +477,8 @@ function documentName(path) {
 function renderEmptyState() {
     return `
     <div class="empty-state">
-      <strong>此工作区中没有中继。</strong>
-      <p>中继包存放在 <code>${escapeHtml(RELAYS_ROOT)}/&lt;name&gt;/</code>，此工作区目前还没有中继包。</p>
+      <strong>${escapeHtml(t("bundled.relays.no.relays.in.this.workspace.6ba356", "No relays in this workspace."))}</strong>
+      <p>${escapeHtml(t("bundled.relays.empty.location", "Relay packages are stored in {path}. This workspace has none yet.", { path: `${RELAYS_ROOT}/<name>/` }))}</p>
     </div>
   `;
 }
@@ -448,30 +493,24 @@ function relaysStyles() {
          (the app container is a fixed-height flex column; with shrink enabled
          the viewer's huge content basis starves them down to a sliver once a
          tall document renders). The viewer absorbs all shrinking instead. */
-      .toolbar { flex: 0 0 auto; display: flex; align-items: center; justify-content: space-between; gap: 8px; padding: 10px 12px; border-bottom: 1px solid var(--pi-border-muted); }
+      .toolbar { flex: 0 0 auto; justify-content: space-between; padding-inline-start: 10px; }
       .toolbar[hidden], .document-tabs[hidden] { display: none; }
-      .toolbar-actions { display: inline-flex; align-items: center; flex-wrap: nowrap; justify-content: flex-end; gap: 8px; min-width: 0; }
+      .toolbar-actions { justify-content: flex-end; }
       .relay-name { min-width: 0; color: var(--pi-text-secondary); overflow-wrap: anywhere; }
-      /* Bottom padding (not viewer margin) so the gap below the tabs persists
-         when the viewer's content scrolls up against its top edge. */
-      .document-tabs { flex: 0 0 auto; display: flex; flex-wrap: nowrap; gap: 6px; padding: 8px 12px; overflow-x: auto; overflow-y: hidden; overscroll-behavior-x: contain; scrollbar-width: thin; }
+      .document-tabs { flex: 0 0 auto; overflow-x: auto; overflow-y: hidden; overscroll-behavior-x: contain; scrollbar-width: thin; }
       .viewer { flex: 1 1 auto; box-sizing: border-box; display: grid; align-content: start; gap: 12px; min-height: 0; overflow: auto; padding: 12px; }
       /* Grid children default to min-width: auto; without these caps a wide code
          block or table would silently stretch the whole viewer track. */
       .viewer > * { box-sizing: border-box; min-width: 0; max-width: 100%; }
-      button, select { border: 1px solid var(--pi-border); border-radius: 7px; background: var(--pi-surface); color: var(--pi-text); font: inherit; }
-      button { cursor: pointer; padding: 6px 10px; }
-      button.icon-button { flex: 0 0 auto; display: inline-grid; place-items: center; width: 30px; height: 30px; padding: 0; }
-      button.icon-button svg { width: 16px; height: 16px; fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; pointer-events: none; }
-      select { min-width: 0; max-width: 240px; padding: 5px 6px; }
-      .document-tab { flex: 0 0 auto; white-space: nowrap; font-size: 12px; padding: 4px 10px; }
-      .document-tab.active { border-color: var(--pi-accent-border); background: var(--pi-accent); color: var(--pi-bg); }
-      .directory-group { flex: 0 0 auto; display: inline-flex; align-items: center; gap: 6px; min-width: 0; border: 1px solid var(--pi-border-muted); border-radius: 10px; background: var(--pi-bg-overlay-soft); padding: 0; margin: -1px 0; }
-      .directory-tab { display: inline-flex; align-items: center; gap: 5px; }
-      .directory-tab .chevron { flex: 0 0 auto; width: 9px; height: 9px; fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; transition: transform 0.12s ease; }
-      .directory-tab[aria-expanded="true"] .chevron { transform: rotate(90deg); }
-      .directory-tab.contains-active { border-color: var(--pi-accent-border); color: var(--pi-accent); }
-      .directory-tab.contains-active::after { content: ""; width: 5px; height: 5px; border-radius: 50%; background: var(--pi-accent); }
+      [data-refresh] svg { width: 16px; height: 16px; fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; pointer-events: none; }
+      select { min-width: 0; max-width: 240px; }
+      /* Folder controls interleave with file tabs; shared groups keep nested controls contiguous. */
+      .directory-tab .chevron { flex: 0 0 auto; width: 9px; height: 9px; fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; transition: transform 0.12s ease; }
+      .directory-tab[aria-expanded="true"] .chevron { transform: rotate(90deg); }
+      /* The selection survives a folder collapse: the nearest collapsed ancestor
+         highlights instead, without taking the fill reserved for the open document. */
+      .directory-tab.contains-active { color: var(--pi-accent); }
+      .directory-tab.contains-active::after { content: ""; width: 5px; height: 5px; border-radius: 50%; background: var(--pi-accent); }
       code, pre { border: 1px solid var(--pi-border-muted); border-radius: 6px; background: var(--pi-bg); color: var(--pi-text-secondary); font: 12px ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
       code { padding: 2px 5px; }
       pre { margin: 0; overflow: auto; padding: 8px; white-space: pre-wrap; overflow-wrap: anywhere; }

package/dist/pi-packages/relays/skills/relay/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: relay
+description: "Carry work across a chain of fresh agent contexts using a shared goal, compact baton, and durable record. Use when a user invokes Relay, discusses the Relay method, prepares a Relay, or continues an active Relay. Do not load for generic multi-step work or ordinary delegation."
+---
+
+# Relay
+
+A Relay carries work across fresh agent contexts until the agreed goal is reached or an agent needs human help. Each context owns one useful slice, called a **leg**. There is no standing coordinator or fixed set of agent roles.
+
+Follow the [Relay Principle](https://relayprinciple.ai/): give agents a destination and enough continuity to act, rather than recreating a management structure around them.
+
+## Finish line over plan
+
+Help the human express what they want built and how they will recognize it is done. Resolve material ambiguity before dispatch. An existing requirements document can supply the goal; reference it rather than rewriting it into a larger specification.
+
+Keep the goal stable and the route adaptable. Each runner checks the finish line against the current work and chooses the next useful slice. Changing the goal requires human agreement; changing implementation or sequencing within scope does not.
+
+## Scope over script
+
+Record the relay-specific boundaries, limitations, conditions, and clarifications needed to understand the request. Preserve technical requirements and any other details the human explicitly asks to include.
+
+Do not invent an implementation roadmap, speculative requirements, or a new software process. Project instructions, skills, and harness conventions remain where they belong; each runner discovers and follows what applies to its work. A Relay does not replace or weaken those rules.
+
+## Handoff over handhold
+
+A baton says **where we are**, not **how you must work**. Avoid suggesting or assigning the next slice: even a provisional suggestion can anchor the successor. Record remaining gaps and concrete dependencies instead, and trust the successor to inspect reality and choose its slice.
+
+Choose a meaningful increment that fits one context, not the tiniest possible task. Investigation and related work can stay together. Leg boundaries protect context quality, not organizational ownership.
+
+Finish ongoing work and preserve the state before starting at most one fresh successor. Handoff is the final operational action; only a user-facing summary follows. Do not watch or steer the successor.
+
+## Record over memory
+
+Keep three kinds of durable information:
+
+- **Goal:** the agreed finish line and relay-specific scope. Current status cannot override it.
+- **Baton:** current position, completed work, what remains, relevant evidence and decisions, useful pointers, and any blocker.
+- **History:** concise entries recording each leg's result, decisions, artifacts, checks, and handoff or stop.
+
+Keep the baton compact. Use history for targeted lookup, not mandatory reconstruction. Inspect the actual work as needed; the record saves rediscovering prior decisions, not reading the project.
+
+## Signal over spin
+
+Stop when the finish line is met, with evidence. Completion does not require finding another improvement.
+
+Stop visibly when progress needs human input: record the blocker, what was tried, and the specific decision or help needed. If successive legs keep revisiting the same issue without new evidence or meaningful progress, surface that stall instead of spawning another attempt.
+
+Optional cleanup, hypothetical risks, and a desire for perfection are not reasons to prolong the chain. Revisit a settled decision when facts change or concrete evidence shows it was wrong, not merely because a fresh agent has arrived.
+
+Tools, storage, and session creation belong to the environment-specific runner skill, not the definition of Relay.

package/dist/pi-packages/relays/skills/relay-runner/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: relay-runner
+description: "Prepare and run Relay legs in Pi: keep the goal, baton, and log durable, then hand off to one fresh session or stop visibly. Use with relay for /relay, /relay-worktree, or a handoff naming relay-runner. Supplies continuity and a bounded fresh-context final review without prescribing the development route."
+---
+
+# Relay runner
+
+This skill binds the `relay` method to Pi sessions and a small file packet. It supplies continuity and one completion gate: a fresh-context final review. The development route remains adaptive. Each agent discovers applicable project instructions and skills through the repository and harness; do not copy them into the packet or preselect them for future legs.
+
+## Packet
+
+Use `.pi-web/relays/<name>/` in the working checkout unless the user selects another location inside the target workspace. Start with three files:
+
+- **`charter.md` — goal.** The agreed outcome and recognizable finish line, relay-specific scope boundaries and clarifications, and any explicit human requirements. Reference an existing specification when useful. Do not add project rules, implementation plans, or generic quality or delivery procedures; include such details only when the human explicitly asks.
+- **`status.md` — baton.** State (`Draft — awaiting approval; not dispatched`, `Active`, `Complete`, or `Needs help`), last completed leg and next leg number, working location, current progress, remaining gaps to the goal, relevant checks, current review state, targeted pointers, and blockers. Include only what is useful now. Avoid suggesting the next slice; record remaining gaps and concrete dependencies instead.
+- **`log.md` — history.** Append a short entry per leg: what changed or was learned, important decisions and why, artifact or commit references, checks and actual results, and the next leg or stop. Record human approval and scope changes here too.
+
+Charter = agreement; status = position; decisions = durable reasoning; log = history. Keep revisions in the log, not a separate revisions document; no decision template is required. Status, decisions, and the log cannot silently change the agreement. Keep relay-specific decisions durable without adding documents merely to satisfy a template. The packet is not a second home for project policy or this skill's instructions.
+
+Add **`decisions.md` only when useful**: a compact, living record of consequential decisions and their reasons, including rejected approaches or review concerns worth remembering. Keep current conclusions there and record revisions in the log. Link it from status and consult relevant entries rather than duplicating the reasoning in the baton. It is not a plan, task list, or another home for project rules. Human changes to the goal or scope still belong in the charter. Do not create an empty register or impose a decision template.
+
+## Preparation and dispatch
+
+The preparation prompt owns discussion and approval. Drafting is allowed before approval; `dispatch_relay` is not. After the human reviews the goal and boundaries, require an explicit **Approve and dispatch** response. If the approved goal, scope, or working target changes materially, obtain fresh approval.
+
+Use the current checkout for `/relay` unless the user chooses another. For `/relay-worktree`, create a fresh branch and worktree after approval, following project conventions; use current HEAD as the starting point unless another base is agreed. Ask about a material target ambiguity rather than guessing. Move the draft packet into the target checkout before dispatch, update its location, and remove the stale drafting copy.
+
+Record the actual checkout and, in Git, branch and starting commit in status. Keep packet files out of delivery commits using an existing ignore rule or a local Git exclusion. Leave unrelated existing work untouched. Bootstrap the target as needed under project conventions; setup does not automatically require a separate leg.
+
+Record approval in status/log, mark status `Active`, and seed leg 1. The first runner chooses its own slice; preparation need not prescribe one. Dispatch with the same handoff mechanics used by later legs.
+
+## Run a leg
+
+1. Read the charter and status, then inspect relevant project guidance and work. Consult only the history or supporting material needed to understand the current state. Repair small record gaps with targeted inspection; ask for help if the goal or ownership is unclear.
+2. Compare reality with the finish line and completion requirements, including the final review below. If all are satisfied, record completion and stop. Otherwise choose one useful, context-sized slice that closes a remaining gap. Briefly state in the session which slice you chose and how it advances the goal.
+3. Do the work and the checks appropriate to it under project conventions. Record failed, skipped, or incomplete checks honestly.
+4. Make the result durable before handoff. In Git, commit the leg's changes when project policy and human instructions permit, without including unrelated changes or the packet. Otherwise record the exact saved work and why it is uncommitted. Finish any helpers before handing off.
+5. Refresh the compact status and append the log entry. Record progress against the goal, important evidence and decisions, remaining gaps, and any limitations the successor needs to know. Then complete, ask for help, or hand off once.
+
+Other reviews, delivery steps, and gates apply only when the human or project requires them. Keep this skill's review procedure here, not copied into the packet.
+
+## Final review
+
+When a leg finishes substantive work and believes implementation is done, record that final review is pending and hand off to a fresh leg. A fresh runner finding implementation complete with review pending performs the review instead of passing it on again. Leave substantive corrections to another leg so the review stays independent.
+
+Review the whole relay result, not just the last slice, against the charter and applicable project guidance. Approve when no concrete, evidence-backed in-scope blocker remains. Optional improvements, speculative concerns, and unrelated pre-existing shortcomings do not block completion. Record consequential finding dispositions in `decisions.md` when useful.
+
+Allow **at most three review attempts total**: the initial review and up to two post-correction reviews, not three mandatory passes. Keep the attempt count, latest result, and reviewed work reference in status; put evidence and findings in the log or link to decisions. Subsequent attempts happen only after concrete corrections and focus on those corrections and changed evidence, carrying supported prior decisions forward rather than restarting an expanding audit.
+
+If the third attempt still has blockers, or a required further review would exceed the budget, mark `Needs help`, record what remains, and stop without dispatching another review or correction leg. A valid approval satisfies the gate; a new context or packet-only update does not reopen it. Material changes to the reviewed result require re-review within the same budget.
+
+## Stop or hand off
+
+Mark `Complete` and report the result and evidence when no required work remains and final review has passed for the current result. Do not spawn a successor to search for extra work.
+
+Mark `Needs help` when a decision, permission, environment problem, or lack of progress prevents responsible continuation. Record the concrete blocker, attempts and evidence, and the smallest question or action needed from the human. Surface it clearly in the user-facing response; use `ask_user` when an answer is needed. Do not hand a human-dependent blocker to another context hoping it will disappear.
+
+Before continuing, check that concrete required work remains, including any pending final review; leave slice selection to the successor.
+
+For handoff, finish work and all packet writes first. The charter supplies the goal and saved `status.md` is the actual baton: save progress, remaining gaps, decisions, checks and blockers there, with targeted pointers to supporting records as needed. Do not put missing continuity into a separate handover prompt.
+
+Call the dedicated `dispatch_relay` tool at most once with the saved directory as `packet`, the next leg identity as `leg`, and the target checkout as `cwd`. A relative `packet` resolves inside that `cwd`; custom packet locations must also stay inside the target workspace. Pass `leg` as a string: the next leg number written as `"2"`, or an explicitly chosen identifier of 1–32 letters, digits, dots, underscores or hyphens, starting with a letter or digit. Non-string values are rejected rather than converted. For example, substitute the actual paths and next leg:
+
+```json
+{
+  "packet": ".pi-web/relays/<name>",
+  "leg": "2",
+  "cwd": "/absolute/path/to/checkout"
+}
+```
+
+The tool validates the saved packet, generates the handover instructions, and records explicit Relay identity and a predictable session name. It accepts no free-form prompt and starts an independent session; do not substitute a generic session tool or tracked subsession. Omit `model` and `thinkingLevel` to inherit them unless the human instructed otherwise; keep any relay-wide instruction in the packet.
+
+`dispatch_relay` is the final operational action. After it returns, give only a brief handoff summary: no further tool use, packet writes, work, or downstream supervision. If the tool is unavailable or dispatch fails, report the failure rather than claiming the next leg started.

package/dist/pi-packages/workflows/browser/pi-web-plugin.js

@@ -0,0 +1,42 @@
+// Generated from pi-packages/workflows/browser/pi-web-plugin.ts. Do not edit directly.
+import { openWorktreeDialog } from "./worktreeDialog.js";
+function canCreateWorktree({ state, backend }) {
+    return state.selectedProject !== undefined && backend !== undefined;
+}
+const plugin = {
+    apiVersion: 5,
+    name: "Workflows",
+    activate: ({ lifetimeSignal, selection, translate }) => {
+        const t = translate ?? ((_key, fallback) => fallback);
+        let closeDialog;
+        let unsubscribe;
+        const close = () => { closeDialog?.(); closeDialog = undefined; unsubscribe?.(); unsubscribe = undefined; };
+        lifetimeSignal.addEventListener("abort", close, { once: true });
+        return {
+            contributions: {
+                actions: [{
+                        id: "worktree.create",
+                        title: t("bundled.workflows.create.worktree", "Create Worktree"),
+                        description: t("bundled.workflows.create.description", "Choose a base branch and purpose, then start a new conversation in the main workspace"),
+                        group: t("bundled.workflows.group", "Workflows"),
+                        enabled: canCreateWorktree,
+                        disabledReason: () => t("bundled.workflows.select.project", "Select a project with the Workflows backend available first."),
+                        run: (context) => {
+                            const project = context.state.selectedProject;
+                            if (!project || !context.backend || lifetimeSignal.aborted)
+                                return;
+                            close();
+                            const peer = context.backend.forScope({ kind: "project", projectId: project.id });
+                            closeDialog = openWorktreeDialog(context, peer, () => { closeDialog = undefined; unsubscribe?.(); unsubscribe = undefined; }, translate);
+                            unsubscribe = selection?.subscribe((snapshot) => {
+                                if (snapshot.selectedProject?.id !== project.id || snapshot.selectedMachine?.id !== context.catalog.machineId)
+                                    close();
+                            });
+                        },
+                    }],
+            },
+            dispose() { close(); lifetimeSignal.removeEventListener("abort", close); },
+        };
+    },
+};
+export default plugin;