pi-mono-all 1.0.0

package/node_modules/pi-mono-linear/src/linear-tools.ts

@@ -0,0 +1,362 @@
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { registerAuthConfigurator, runWithAuthRetry, type AuthConfiguratorOptions } from "pi-common/auth-config";
+import { jsonToolResult } from "pi-common/tool-result";
+import { LinearClient, type UploadedFileResult } from "./linear-client.js";
+import {
+	EmptyParams,
+	LinearCommentsParams,
+	LinearCreateCommentParams,
+	LinearCreateIssueParams,
+	LinearDocumentsParams,
+	LinearGetDocumentParams,
+	LinearGetIssueParams,
+	LinearGetProjectParams,
+	LinearGetStatusParams,
+	LinearGetTeamParams,
+	LinearGetUserParams,
+	LinearListIssuesParams,
+	LinearListMyIssuesParams,
+	LinearSearchIssuesParams,
+	LinearUpdateIssueParams,
+	LinearUploadFileParams,
+	LinearUploadFileToIssueCommentParams,
+	OptionalTeamParams,
+} from "./linear-schemas.js";
+
+const LINEAR_AUTH: AuthConfiguratorOptions = {
+	service: "linear",
+	displayName: "Linear",
+	envName: "LINEAR_API_KEY",
+	authPath: ["linear", "key"],
+	commandName: "linear-auth",
+	toolName: "linear_configure_auth",
+	tokenUrl: "https://linear.app/settings/account/security",
+	scopeInstructions: [
+		"Read access is enough for lookup/list/get tools.",
+		"Write access is required for creating issues, updating issues, creating comments, and uploading files.",
+		"Admin access is not required.",
+	],
+};
+
+function withLinearAuth<T>(ctx: ExtensionContext, operation: () => Promise<T>): Promise<T> {
+	return runWithAuthRetry(ctx, LINEAR_AUTH, operation);
+}
+
+function buildFileCommentBody(upload: UploadedFileResult, commentBody?: string, altText?: string): string {
+	const markdown = upload.contentType.startsWith("image/")
+		? `![${escapeMarkdownAltText(altText?.trim() || upload.filename)}](${upload.assetUrl})`
+		: `[${upload.filename}](${upload.assetUrl})`;
+	if (!commentBody?.trim()) return markdown;
+	if (commentBody.includes("{markdown}") || commentBody.includes("{url}")) {
+		return commentBody.replaceAll("{markdown}", markdown).replaceAll("{url}", upload.assetUrl);
+	}
+	return `${commentBody.trim()}\n\n${markdown}`;
+}
+
+function escapeMarkdownAltText(value: string): string {
+	return value.replaceAll("[", "\\[").replaceAll("]", "\\]");
+}
+
+export function registerLinearTools(pi: ExtensionAPI): void {
+	const client = new LinearClient();
+	registerAuthConfigurator(pi, LINEAR_AUTH);
+
+	pi.registerTool({
+		name: "linear_whoami",
+		label: "Linear Whoami",
+		description: "Get the authenticated Linear user.",
+		parameters: EmptyParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.whoami()), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_workspace_metadata",
+		label: "Linear Workspace Metadata",
+		description: "Get teams, projects, workflow states, labels, and users in one Linear call.",
+		promptSnippet: "Fetch Linear workspace teams, projects, states, labels, and users.",
+		promptGuidelines: [
+			"Use linear_configure_auth only when Linear auth is missing, invalid, expired, or the user asks to update the key; never ask the user to paste API keys in chat.",
+			"Use linear_workspace_metadata first when Linear team, project, state, label, or user IDs are unknown.",
+			"Use linear_search_issues for Linear keyword lookup.",
+			"Use linear_get_issue before updating or commenting on a Linear issue.",
+		],
+		parameters: EmptyParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.workspaceMetadata()), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_list_teams",
+		label: "Linear List Teams",
+		description: "List Linear teams.",
+		parameters: EmptyParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.listTeams()), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_get_team",
+		label: "Linear Get Team",
+		description: "Get a Linear team by ID.",
+		parameters: LinearGetTeamParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.getTeam(params.teamId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_list_issues",
+		label: "Linear List Issues",
+		description: "List Linear issues with optional team, assignee, status, and limit filters.",
+		parameters: LinearListIssuesParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const result = await withLinearAuth(ctx, () => client.listIssues({
+				teamId: params.teamId,
+				assigneeId: params.assigneeId,
+				statusName: params.statusName,
+				limit: params.limit,
+			}));
+			return jsonToolResult(result, { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_get_issue",
+		label: "Linear Get Issue",
+		description: "Get full Linear issue details by UUID or identifier like ENG-123.",
+		parameters: LinearGetIssueParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.getIssue(params.issueId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_search_issues",
+		label: "Linear Search Issues",
+		description: "Search Linear issues by keyword.",
+		parameters: LinearSearchIssuesParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.searchIssues(params.query, params.limit)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_list_my_issues",
+		label: "Linear My Issues",
+		description: "List open Linear issues assigned to the authenticated user.",
+		parameters: LinearListMyIssuesParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.listMyIssues(params.limit)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_create_issue",
+		label: "Linear Create Issue",
+		description: "Create a Linear issue. Use linear_workspace_metadata first if team/state/user/project IDs are unknown.",
+		parameters: LinearCreateIssueParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const result = await withLinearAuth(ctx, () => client.createIssue({
+				teamId: params.teamId,
+				title: params.title,
+				description: params.description,
+				priority: params.priority,
+				assigneeId: params.assigneeId,
+				labelIds: params.labelIds,
+				projectId: params.projectId,
+				stateId: params.stateId,
+			}));
+			return jsonToolResult(result, { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_update_issue",
+		label: "Linear Update Issue",
+		description: "Update a Linear issue title, description, priority, state, or assignee. Call linear_get_issue first.",
+		parameters: LinearUpdateIssueParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const result = await withLinearAuth(ctx, () => client.updateIssue(params.issueId, {
+				title: params.title,
+				description: params.description,
+				priority: params.priority,
+				stateId: params.stateId,
+				assigneeId: params.assigneeId,
+			}));
+			return jsonToolResult(result, { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_list_projects",
+		label: "Linear List Projects",
+		description: "List Linear projects, optionally for a team.",
+		parameters: OptionalTeamParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.listProjects(params.teamId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_get_project",
+		label: "Linear Get Project",
+		description: "Get a Linear project by ID.",
+		parameters: LinearGetProjectParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.getProject(params.projectId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_list_issue_statuses",
+		label: "Linear List Issue Statuses",
+		description: "List Linear workflow states, optionally for a team.",
+		parameters: OptionalTeamParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.listIssueStatuses(params.teamId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_get_issue_status",
+		label: "Linear Get Issue Status",
+		description: "Get a Linear workflow state by ID.",
+		parameters: LinearGetStatusParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.getIssueStatus(params.stateId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_list_labels",
+		label: "Linear List Labels",
+		description: "List Linear labels, optionally for a team.",
+		parameters: OptionalTeamParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.listLabels(params.teamId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_list_users",
+		label: "Linear List Users",
+		description: "List Linear users.",
+		parameters: EmptyParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.listUsers()), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_get_user",
+		label: "Linear Get User",
+		description: "Get a Linear user by ID.",
+		parameters: LinearGetUserParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.getUser(params.userId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_list_comments",
+		label: "Linear List Comments",
+		description: "List comments for a Linear issue.",
+		parameters: LinearCommentsParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.listComments(params.issueId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_create_comment",
+		label: "Linear Create Comment",
+		description: "Create a comment on a Linear issue. Call linear_get_issue first.",
+		parameters: LinearCreateCommentParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.createComment(params.issueId, params.body)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_upload_file",
+		label: "Linear Upload File",
+		description: "Upload a local file to Linear and return a Linear asset URL. Supports images, videos, and generic files.",
+		promptGuidelines: [
+			"Use this when you need a Linear-hosted URL for a local image, video, or file.",
+			"Tool results include the asset URL and sanitized metadata, not file bytes, signed upload URLs, or upload headers.",
+			"Use linear_get_issue before inserting the returned URL into an issue or comment.",
+		],
+		parameters: LinearUploadFileParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const result = await withLinearAuth(ctx, () => client.uploadFile({
+				filePath: params.filePath,
+				filename: params.filename,
+				contentType: params.contentType,
+				maxBytes: params.maxBytes,
+				makePublic: params.makePublic,
+			}));
+			return jsonToolResult(result, { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_upload_file_to_issue_comment",
+		label: "Linear Upload File to Issue Comment",
+		description: "Upload a local file to Linear and create a Markdown comment on an issue. Call linear_get_issue first.",
+		promptGuidelines: [
+			"Use this after linear_get_issue has verified the target issue.",
+			"Images are inserted as Markdown images; videos and other files are inserted as links.",
+			"Use commentBody with {url} or {markdown} placeholders for custom wording, or omit it to post only the file Markdown.",
+		],
+		parameters: LinearUploadFileToIssueCommentParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const result = await withLinearAuth(ctx, async () => {
+				const upload = await client.uploadFile({
+					filePath: params.filePath,
+					filename: params.filename,
+					contentType: params.contentType,
+					maxBytes: params.maxBytes,
+					makePublic: params.makePublic,
+				});
+				const body = buildFileCommentBody(upload, params.commentBody, params.altText);
+				const comment = await client.createComment(params.issueId, body);
+				return { upload, comment };
+			});
+			return jsonToolResult(result, { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_list_cycles",
+		label: "Linear List Cycles",
+		description: "List Linear cycles, optionally for a team.",
+		parameters: OptionalTeamParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.listCycles(params.teamId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_list_documents",
+		label: "Linear List Documents",
+		description: "List Linear documents, optionally for a project.",
+		parameters: LinearDocumentsParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.listDocuments(params.projectId)), { maxChars: params.maxResponseChars });
+		},
+	});
+
+	pi.registerTool({
+		name: "linear_get_document",
+		label: "Linear Get Document",
+		description: "Get a Linear document by ID.",
+		parameters: LinearGetDocumentParams,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			return jsonToolResult(await withLinearAuth(ctx, () => client.getDocument(params.documentId)), { maxChars: params.maxResponseChars });
+		},
+	});
+}

package/node_modules/pi-mono-loop/CHANGELOG.md

@@ -0,0 +1,163 @@
+# pi-mono-loop
+
+## 1.7.2
+
+### Patch Changes
+
+### Fixed: ask-user-question
+
+- Remove unused `StringEnum` import from `@mariozechner/pi-ai`.
+
+
+## 1.7.1
+
+### Patch Changes
+
+### Fixed: team-mode
+
+- Widget no longer mislabels blocked or approval-pending teams as "running smoothly" — blockers and pending approvals are now detected via team summaries.
+- Preserve in-flight work on re-emitted `session_start` events instead of tearing the runtime down and SIGTERM-ing live teammates.
+- Auto-relaunch leaders for `running` teams after a session reset; surface failures as both a team signal and a UI notification.
+- `createTeam` now defaults `repoRoots` to `[process.cwd()]` when the caller passes an empty array.
+- Archive `process.json` into `history/` before a new task reuses the same role slot, so the prior task's final state is no longer silently clobbered.
+
+### Enhanced: team-mode
+
+- Durable intent queue for subprocess handoff: `team_spawn_teammate` calls made from a teammate subprocess are written to disk and executed by the main session's `LeaderRuntime` instead of spawning orphaned grand-children.
+- New tool `team_task_create_batch` lets the leader emit the full initial task DAG in one call, removing per-task LLM round-trips during bootstrap.
+- `team_create` / `launchLeader` accept an `awaitBootstrap` option so the user sees the task graph before the tool returns; leader launch retries up to 3 times on transient failures.
+- Persist per-turn debug artifacts (prompt, invocation, stderr, raw event stream) for both leader and teammate subprocesses, exposed via `TeammateSummary.debugArtifacts`.
+- Track `exitCode`, `exitSignal`, `terminationReason`, `stderrTail`, `toolExecutions`, `model` and `modelProvider` on every `TeammateProcess` record.
+- Provider detection now consults pi's `settings.json` and `auth.json` in addition to env vars; default model IDs aligned with the provider/model scheme.
+- `collectPiOutput` supports `AbortSignal` cancellation.
+
+### Tests
+
+- New `intent-queue` and `model-config` suites; expanded coverage across `leader-runtime`, `team-manager`, `team-query-tool` and `formatters`.
+
+
+## 1.7.0
+
+### Minor Changes
+
+### Enhanced: status-line
+
+- Improved progress rendering and colors in expert mode
+
+### Enhanced: team-mode
+
+- **LLM-driven leader** — replaced the hardcoded `research → synthesis → implementation → verification` state machine with a pi subprocess coordinator that authors the task graph via tool calls
+- **New tool `team_task_create`** so the leader can author tasks at runtime
+- **New tool `team_handoff`** for explicit teammate → teammate context handoffs (replaces regex-scraping of `Handoffs:` output sections)
+- **File-based teammate specs** — drop `.claude/teammates/<role>.md` frontmatter files (`name`, `description`, `needsWorktree`, `hasMemory`, `modelTier`) to extend or override the seven built-in roles
+- **Event-driven leader wakes** — mailbox messages addressed to the leader (or broadcast) trigger a debounced (~200ms) cycle instead of waiting for the 20s polling tick
+- **Templates accept any string** — `fullstack` / `research` / `refactor` remain as built-ins, but unknown template keys are accepted and no-op gracefully
+- **Provider config per team** — per-team model overrides via `/team models`
+- Reduced leader overhead and parent-session token churn
+- `spawnTeammate` now always appends the full runtime-built context (signals, mailbox, dependencies, team memory) so teammates get the richer snapshot even when the caller's `context` argument is brief
+
+### Breaking changes: team-mode
+
+- Removed `LeaderPhase` enum and `currentPhase` field from `TeamRecord` / `TeamSummary`
+- Removed `parseExplicitHandoffs` export and the legacy `Handoffs:` output parser — peer handoffs must go through the `team_handoff` tool
+- Removed the deterministic auto-spawn loop (`ensureBootstrapTasks`) — all task authoring and teammate spawning is now the LLM leader's responsibility
+- Removed `StringEnum` gate on `team_create`'s `template` parameter (now plain string)
+
+### Fixed: review
+
+- Annotate diff lines so the model picks correct line numbers
+- Fix slice chunk around lines for comments in the reviewer TUI
+
+### Documentation
+
+- Updated root README and sentinel extension README
+- Documented the new file-based teammate spec format and event-driven leader wake in the team-mode README
+
+## 1.6.0
+
+### Minor Changes
+
+### New Extension: sentinel
+
+Replaced the `grep` extension with a new security-focused `sentinel` extension for monitoring and guarding sensitive operations.
+
+### Enhanced: team-mode
+
+- Added comprehensive test suite with integration tests
+- New mock helpers for subprocess testing
+- Improved signal manager with better error handling
+- Leader runtime refactoring for stability
+- Team query tool with dedicated tests
+
+### Enhanced: status-line
+
+- Added basic and expert mode displays
+- Improved index.ts with better state management
+
+### Enhanced: clear
+
+- Updated keyboard shortcut to `Ctrl+Shift+L`
+- Better busy-state handling for shortcuts
+- Added warning/cancel handling and error notifications
+
+### Enhanced: context-guard
+
+- Improved read deduplication across sessions
+- Added `context-guard:file-modified` event for cache eviction
+
+### Documentation
+
+- Added dedicated README for `clear` extension
+- Added dedicated README for `context-guard` extension
+- Updated main README with improved extension descriptions
+
+## 1.5.0
+
+### Minor Changes
+
+- ### `multi-edit` — diverge from upstream fork
+
+  The extension was originally derived from [mitsuhiko/agent-stuff](https://github.com/mitsuhiko/agent-stuff)'s `pi-extensions/multi-edit.ts`. This release rewrites the largest unmodified subsystems so the implementation is structurally distinct from upstream while keeping the public contract intact.
+
+  - **Modularized layout** — the 953-line `index.ts` is split into purpose-scoped modules: `types.ts`, `workspace.ts`, `classic.ts`, `patch.ts`, `diff.ts`, and a slim `index.ts` (~180 lines of registration + dispatch wiring).
+  - **New patch engine** — `patch.ts` is now a recursive-descent parser over a `LineCursor` class with `indexOf`-based hunk anchoring. Hunks are stored as `{ oldBlock, newBlock }` raw strings (previously `{ oldLines[], newLines[] }` arrays), letting the applier splice content directly instead of reconstructing line arrays per apply.
+  - **Two-pass diff renderer** — `diff.ts` now walks `diffLines` parts into a typed `Entry[]` stream and makes all gutter / context-collapse decisions in a second pass, replacing the prior single-loop state-flag design.
+  - **Polished classic edits** — extracted `groupEditsByPath`, `sortGroupByPosition`, `applyGroupToContent`, and `rollbackSnapshots` helpers; formalized the quote-fallback as an ordered `MATCH_PASSES` array so new normalizers (dashes, NBSP, etc.) can be added by appending one entry.
+  - **First contract test suite** — 34 tests under `__tests__/` cover classic edits (positional reordering, redundant-pair skip, quote fallback, atomic rollback, read-only preflight), patch operations (Add/Delete/Update round-trips, move-rejection, multi-op batches), and diff rendering (line-number gutter, context collapse, add/remove-only cases). Runs via `npm test` (`tsx --test`).
+  - **Dropped Codex apply_patch edge cases** (documented in `README.md` → "Codex apply_patch compatibility"): `*** End of File` sentinel hunks, 4-pass fuzzy `seekSequence` matching, implicit first hunk without `@@`, whitespace-tolerant anchoring. Common paths (Add/Delete/Update-single-chunk, Update with multiple hunks, Add+Update+Delete batches) are fully tested and preserved.
+  - **README attribution** — new "Origins" section crediting `mitsuhiko/agent-stuff` as the original source.
+
+## 1.4.0
+
+### Minor Changes
+
+- Add teammate progress heartbeats and widget refresh improvements to team mode.
+
+## 1.3.0
+
+### Minor Changes
+
+- ### New Extensions
+
+  #### `loop`
+
+  New extension that runs a prompt or slash command on a recurring interval. Useful for periodic tasks, polling, and automated repeated actions within a pi session.
+
+  #### `simplify`
+
+  New extension that reviews changed code for reuse, quality, and efficiency, then automatically fixes any issues found. Integrates with `git diff` to scope the review to recent changes.
+
+  ***
+
+  ### Bug Fixes
+
+  #### `multi-edit`
+
+  - **Broader unicode normalization**: `findActualString` now handles the full range of Unicode single-quote variants (`‘’‚‛`) and double-quote variants (`“”„‟`) when falling back from exact match — fixes more curly-quote mismatch cases
+  - **Parallel write-access preflight**: `checkWriteAccess` calls are now issued concurrently via `Promise.all` instead of sequentially — faster batch preflight on large edit sets
+  - **Removed redundant `editOrder` array**: `Map` insertion order is now relied upon directly, simplifying the grouping loop
+
+  #### `team-mode`
+
+  - **Stall detection hardened**: introduced `STALL_BLOCKER_MARKER` / `STALL_BLOCKER_MESSAGE` constants so the marker used to detect and record abnormal process exits stays in sync — prevents duplicate stall reports
+  - **Leader cycle guard comment clarified**: `cycleRunning` guard comment now explicitly calls out the race between the poll interval and teammate-completion handlers

package/node_modules/pi-mono-loop/README.md

@@ -0,0 +1,54 @@
+# loop extension
+
+Runs a prompt or slash command on a recurring interval.
+
+Adapted from the [`/loop` skill in claude-code](https://github.com/emanuelcasco/claude-code/blob/main/src/skills/bundled/loop.ts). The original relied on Claude Code's Kairos cron system; this version uses JS timers and `pi.sendUserMessage()` instead.
+
+## Usage
+
+```
+/loop [interval] <prompt>
+```
+
+Intervals use a number followed by a unit suffix: `s` (seconds), `m` (minutes), `h` (hours), `d` (days). If no interval is given, it defaults to `10m`.
+
+## Subcommands
+
+| Command | Description |
+|---|---|
+| `/loop list` | Show all active loops with their IDs and fire counts |
+| `/loop stop` | Cancel all active loops |
+| `/loop stop <id>` | Cancel a specific loop by ID |
+
+## Examples
+
+```
+/loop 5m /review
+/loop 30m check the deploy
+/loop 1h run the tests and report failures
+/loop check the deploy            # defaults to 10m
+/loop check the deploy every 20m  # trailing "every" clause
+/loop list
+/loop stop loop-1
+/loop stop
+```
+
+## Interval parsing
+
+Arguments are parsed using this priority order:
+
+1. **Leading token** — if the first word matches `\d+[smhd]` it is the interval (e.g. `5m /review`)
+2. **Trailing "every" clause** — if the input ends with `every <N><unit>`, that is the interval (e.g. `check the deploy every 20m`)
+3. **Default** — no interval found; uses `10m` and the full input is the prompt
+
+## Behaviour
+
+- The prompt is **executed immediately** on the first invocation, then repeated at the given interval
+- If the agent is busy when a timer fires, the next prompt is queued as a follow-up rather than interrupting the current turn
+- Minimum interval is **10 seconds**
+- Loops **auto-expire after 7 days**
+- All timers are cleaned up on session shutdown
+
+## Files
+
+- `index.ts` — extension entry point