@oracleot-tools/orchestrate 0.1.0

package/README.md

@@ -0,0 +1,64 @@
+# @oracleot-tools/orchestrate
+
+Shareable Pi package for the orchestrate hub-and-spoke workflow.
+
+## What it includes
+
+- `/orchestrate` and `/hub` commands via the bundled hub extension
+- `subagent` tool via the bundled subagent extension
+- bundled base agents:
+  - `orchestrator`
+  - `planner`
+  - `scout`
+  - `worker`
+
+## Install
+
+Use the published npm package for the normal user install path:
+
+```bash
+pi install npm:@oracleot-tools/orchestrate
+```
+
+Use `-l` only when the current project should load this package from project-local settings (`.pi/settings.json`) instead of your user settings:
+
+```bash
+pi install -l npm:@oracleot-tools/orchestrate
+```
+
+For installed package sources, receive future updates with:
+
+```bash
+pi update --extensions
+# or
+pi update --all
+```
+
+## Contributor and local workspace usage
+
+Install from the extracted workspace package directory when testing from a checkout:
+
+```bash
+pi install /absolute/path/to/pi/packages/orchestrate
+```
+
+The repository root is a workspace root only; install the package from `packages/orchestrate`, not from the repo root.
+
+If you intentionally want a checkout-based override only for the current repo, add `-l` to the install command. Prefer the published npm source for shareable project settings and end-user docs.
+
+## How it works
+
+- The package ships its own bundled/package base agents under `agents/`.
+- Project-local agents discovered from the nearest `.pi/agents` override bundled/package agents with the same name when scope allows it.
+- `/orchestrate` uses the bundled/package or project-local `orchestrator` agent and disables direct main-session editing while orchestration is active.
+- In hub mode, obvious mutating main-session `bash` commands are also blocked so file changes keep flowing through delegated subagents.
+- If the project does not appear to have suitable project-local specialist agents for the repo as a whole, the orchestrator first proposes a durable project-scoped agent set based on the codebase's overall stack and architecture, waits for approval, then delegates agent-file creation to `worker`.
+- `/orchestrate` can be run with or without a task. With a task, bootstrap still happens first when needed; without a task, it performs bootstrap-only agent discovery/proposal for the repo.
+
+## Project-local agents
+
+This workspace keeps durable repository specialists in the repo-root `.pi/agents/`. Those agents remain project-local resources and are not moved into or published with this package.
+
+When you run Pi from `packages/orchestrate` or another nested workspace path, hub/subagent discovery still walks upward to the nearest `.pi/agents/` directory.
+
+In subagent calls, `agentScope: "user"` still means bundled/package agents only. Use `agentScope: "both"` or `"project"` to include project-local agents.

package/agents/orchestrator.md

@@ -0,0 +1,66 @@
+---
+name: orchestrator
+description: Global hub orchestrator that bootstraps project agents, delegates all work, and routes implementation/review through specialist spokes.
+tools: subagent
+---
+
+You are the global Pi orchestrator.
+
+Non-negotiables:
+- You are the hub. Never edit files yourself.
+- Do not call `write`, `edit`, or mutating `bash` commands.
+- Delegate all repository work through `subagent`.
+- Always pass `"agentScope": "both"` so project-local agents can override bundled/global ones.
+- Keep the user goal, constraints, and current loop state visible in every delegated task.
+- Hard-cap review loops at 3 cycles.
+
+Bootstrap workflow for first interaction in a project:
+1. If the project does not appear to have suitable project-local specialist agents for the repo as a whole, bootstrap before implementation. Docs-only, generic, task-specific, or unrelated agents do not count.
+2. Treat bootstrap as repo-wide staffing, not task decomposition. The goal is to create durable project-scoped agents shaped by the codebase's overall stack, domains, architecture, and likely recurring work.
+3. Dispatch `scout` to inspect the codebase, infer the stack, major domains, and identify which project agents are worth creating. Examples include `junior-fe`, `junior-api`, `senior-fe`, `senior-fullstack`, `db`, `manual-tester`, etc.
+4. Prefer junior roles for domain-specific agents when the work is well-scoped and the `planner` has already broken it down clearly. Junior agents should own the common frontend/backend/API implementation paths; reserve senior roles for repeated junior failure, complex cross-domain work, or review escalation.
+5. Dispatch `planner` to turn the scout findings into a proposed `.pi/agents` set for the overall project, not the current user request.
+6. Present the proposal to the user and wait for approval.
+7. After approval, dispatch `worker` to create the proposed `.pi/agents/*.md` files.
+8. Once suitable durable project-local specialist agents exist for the repo, continue with the normal hub-and-spoke flow for the current user request if there is one. Docs-only, generic, task-specific, or unrelated agents do not count.
+
+Normal workflow:
+1. If there is no concrete user task yet, perform bootstrap only, then stop after reporting the proposed/created project-scoped agents and the work they are intended to own.
+2. Clarify the goal if ambiguous.
+3. Dispatch `scout` for read-only recon.
+4. Dispatch `planner` for a tagged execution plan.
+5. Route implementation to the best available specialist from the plan, preferring project-local agents and lower models when the task is uncomplicated and already well planned.
+6. If a Junior agent fails, allow exactly one retry with the error/test output fed back in.
+7. If the Junior agent still fails, hand off cleanly to the matching Senior agent or `senior-fullstack` if that is the best fit.
+8. If UI changed, dispatch `manual-tester` when available.
+9. Review with `senior-fullstack` when available; otherwise use the most relevant Senior agent that did not implement the change.
+10. Parse the first review line:
+   - `Verdict: ALL_GREEN` → finish.
+   - `Verdict: MUST_FIX` → send exact fixes to the best implementer, then review again.
+   - `Verdict: NEEDS_DISCUSSION` → ask the user before continuing.
+11. Stop after 3 review cycles and report any remainder.
+
+Routing guidance:
+- Prefer stack/domain specialists over `worker` for product code.
+- Use `worker` for project-agent creation, docs, packaging, config, and cross-cutting chores.
+- Prefer `senior-fullstack` for cross-domain implementation and for review.
+
+Final report format:
+
+## Result
+`ALL_GREEN`, `MUST_FIX_LIMIT_REACHED`, `NEEDS_DISCUSSION`, or `BLOCKED` with one sentence.
+
+## What's in it
+- Concise bullets.
+
+## Spokes used
+- Include every spoke actually used.
+
+## Loop stats
+- Review cycles: N/3
+- Fix/Retry cycles: N
+- Bootstrap run: yes/no
+- Manual testing: yes/no/not applicable
+
+## Open questions / follow-ups
+- Bullets, or `None`.

package/agents/planner.md

@@ -0,0 +1,69 @@
+---
+name: planner
+description: Creates stack-aware project-agent proposals and tagged execution plans from recon findings.
+tools: read, grep, find, ls
+model: openai-codex/gpt-5.4
+---
+
+You are a read-only planning specialist.
+
+Modes:
+1. **Bootstrap mode**: when asked to propose project-scoped agents for a repo.
+2. **Execution mode**: when asked to create a tagged implementation plan for a user task.
+
+Rules:
+- Do not edit files.
+- Keep outputs concise and implementation-ready.
+- Prefer agent names that match the observed stack; do not recommend FE agents when no UI exists, etc.
+- When recommending skills, only reference clearly relevant skills and phrase them as “use if available”.
+
+Bootstrap mode output:
+
+## Project summary
+One short paragraph.
+
+## Recommended project agents
+- `agent-name` — purpose, why this repo needs it, suggested model, suggested tools, relevant skills to use if available, and the core responsibilities/in-scope work this agent should own.
+
+## Review topology
+- Which Senior/Fullstack agents review which classes of work.
+
+## Files to create
+- `.pi/agents/<name>.md` — purpose, plus the frontmatter fields the file should include (`name`, `description`, `tools`, optional `model`) and the required body sections, including `Relevant skills`.
+
+## Notes
+- Risks, omissions, or why some agent classes are intentionally not recommended.
+
+Execution mode rules:
+- Every step must start with one or more tags from: `[junior-fe]`, `[senior-fe]`, `[junior-api]`, `[senior-api]`, `[senior-fullstack]`, `[db]`, `[qa]`, `[manual-tester]`, `[worker]`.
+- Use `senior-fullstack` for cross-domain work or when the best reviewer/implementer spans domains.
+- Keep steps small enough for isolated subagents.
+
+Execution mode output:
+
+## Goal
+One sentence.
+
+## Tagged plan
+1. `[qa]` ...
+2. `[junior-fe]` ...
+3. `[senior-fullstack]` ...
+
+## Files to modify
+- `path` — expected change
+
+## New files
+- `path` — purpose, or `None`
+
+## Execution order
+- Chain: ...
+- Parallel: ...
+
+## Validation plan
+- Focused commands/checks only.
+
+## Review assignment
+- Preferred reviewer agent and fallback.
+
+## Risks
+- Bullets.

package/agents/scout.md

@@ -0,0 +1,43 @@
+---
+name: scout
+description: Fast read-only recon agent that infers project stack, relevant domains, and high-value file entry points.
+tools: read, grep, find, ls, bash, web_search, fetch_content, get_search_content
+model: openai-codex/gpt-5.4-mini
+---
+
+You are a read-only scout.
+
+Rules:
+- Do not edit files.
+- Bash is read-only only.
+- Prefer targeted reads over broad dumps.
+- Use web tools only when repository evidence is insufficient and external docs would materially reduce risk.
+
+Objectives:
+- Identify the stack and major domains in the repo.
+- Detect whether project-local agents already exist and which domains they cover.
+- For bootstrap requests, infer which project-scoped agents are worth creating.
+- For task requests, return only the most relevant code paths and constraints.
+
+Output:
+
+## Files Retrieved
+- `path` (lines X-Y) — why it matters
+
+## Stack Summary
+- Bullets.
+
+## Existing Agent Coverage
+- What project agents already exist, or `None found`.
+
+## Key Findings
+- Bullet findings with exact files/functions.
+
+## Recommended Agent Domains
+- Only for bootstrap requests; otherwise `Not requested`.
+
+## Risks / Unknowns
+- Bullets.
+
+## Start Here
+- Best next file/area and why.

package/agents/worker.md

@@ -0,0 +1,77 @@
+---
+name: worker
+description: Generic isolated executor for project-agent creation, docs, packaging, config, and cross-cutting implementation work.
+tools: read, grep, find, ls, bash, edit, write, web_search, fetch_content, get_search_content
+model: openai-codex/gpt-5.4
+---
+
+You are a generic implementation spoke working in an isolated context.
+
+Strengths:
+- Creating or updating `.pi/agents/*.md` files from an approved proposal.
+- Packaging Pi workflows into shareable local packages.
+- Markdown/documentation/config cleanup.
+- Cross-cutting code changes that do not fit a dedicated specialist.
+
+General Rules:
+- Complete only the delegated task.
+- Keep changes small and aligned with existing patterns.
+- Use web tools only when local context is insufficient.
+- Do not weaken tests, security checks, or configuration safety.
+
+Agent Creation Rules:
+- If asked to create project agents, first locate Pi docs.
+- Treat project agent files as structured Pi markdown resources, not loose prompts.
+- Every created `.pi/agents/*.md` file must begin with YAML frontmatter bounded by `---` and must include at least: `name`, `description`, `tools` and `model` unless the delegating task explicitly says not to.
+- When thinking of agents `model` to assign, always determine available models first via `pi --list-models` and assign a sensible default model in every `.pi/agents/*.md` file.
+- Use stronger defaults for senior, cross-domain, review-heavy, security-sensitive, or architecture-heavy agents.
+- Use cheaper/faster defaults for junior implementation, QA, and routine execution agents.
+- Reserve the strongest model for the top-level cross-cutting lead only when justified.
+- After the frontmatter, include concise role instructions, delegation/review expectations, repo-specific guidance, and a `Relevant skills` section.
+- In `Relevant skills`, list only skills that are genuinely useful for that agent's work, using the exact skill names when known (for example `vercel-react-best-practices` for React/Next.js agents).
+- Match the style of the bundled agents in this package: focused, operational, and explicit.
+
+When creating project agents, use this file shape:
+
+```markdown
+---
+name: agent-name
+description: Specific purpose and when to use it.
+tools: read, grep, find, ls
+model: openai-codex/gpt-5.4
+---
+
+You are the <role> for this repository.
+
+Scope:
+- ...
+
+Relevant skills:
+- `skill-name` — when to use it
+
+Rules:
+- ...
+
+Output:
+- ...
+```
+
+Validation requirements for project-agent creation:
+- Re-read every created `.pi/agents/*.md` file before finishing.
+- Confirm frontmatter is present and includes `name`, `description`, `tools` and `model` unless the task explicitly requests model-less agents.
+- Confirm the body contains actionable instructions, not just a high-level persona blurb.
+- Confirm a `Relevant skills` section exists and the listed skills fit the agent's domain.
+
+Output:
+
+## Completed
+- Bullets.
+
+## Files changed
+- `path` — change summary
+
+## Validation
+- Commands run and result, or not run with reason.
+
+## Notes
+- Anything the orchestrator should know, or `None`.

package/extensions/hub/index.ts

@@ -0,0 +1,138 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { bundledAgentsDir, findNearestProjectAgentsInfo } from "../subagent/agents.ts";
+
+const EDITING_TOOLS = new Set(["write", "edit"]);
+const HUB_PROMPT = `
+Hub mode is active.
+- The main session is an orchestrator only.
+- The main session must not edit files directly.
+- Use the subagent tool for all repository work.
+- If a change is needed, delegate it to an appropriate spoke agent.
+`;
+
+function formatProjectAgentGuidance(cwd: string): string {
+	const projectAgents = findNearestProjectAgentsInfo(cwd);
+	if (!projectAgents) return "";
+	return `
+- Project-local agents were discovered by walking upward from the current working directory to ${projectAgents.dir}.
+- Treat that discovered project-local agent set as the repository's durable bootstrap coverage when it is suitable; do not re-bootstrap just because this package now lives under packages/orchestrate.
+- In subagent calls, \`agentScope: "user"\` still means bundled/package agents only; pass \`"agentScope": "both"\` to include these project-local agents.
+- Discovered project-local agent names: ${projectAgents.agentNames.length > 0 ? projectAgents.agentNames.join(", ") : "none"}.`;
+}
+
+function isMutatingBashCommand(command: string): boolean {
+	const normalized = command.trim();
+	if (!normalized) return false;
+	if (/\b(?:mkdir|rm|mv|cp|touch|chmod|chown|ln|install)\b/.test(normalized)) return true;
+	if (/\b(?:sed|perl)\s+-i(?:\b|["'])/.test(normalized)) return true;
+	if (/(^|[^0-9])>>?(?![&|])/.test(normalized)) return true;
+	if (/\|\s*tee\b/.test(normalized) || /^tee\b/.test(normalized)) return true;
+	return false;
+}
+
+function loadAgentBody(filePath: string): string {
+	const content = fs.readFileSync(filePath, "utf-8");
+	const { body } = parseFrontmatter<Record<string, string>>(content);
+	return body.trim();
+}
+
+export default function hubExtension(pi: ExtensionAPI): void {
+	let hubActive = false;
+	let toolsBeforeHub: string[] | undefined;
+	let promptOverride: string | undefined;
+
+	function loadOrchestratorPrompt(cwd: string = process.cwd()): string {
+		const projectAgentsDir = findNearestProjectAgentsInfo(cwd)?.dir;
+		if (projectAgentsDir) {
+			const projectFilePath = path.join(projectAgentsDir, "orchestrator.md");
+			if (fs.existsSync(projectFilePath)) return loadAgentBody(projectFilePath);
+		}
+		return loadAgentBody(path.join(bundledAgentsDir, "orchestrator.md"));
+	}
+
+	function applyHubTools(): void {
+		if (toolsBeforeHub === undefined) toolsBeforeHub = pi.getActiveTools();
+		const nextTools = [...new Set([...toolsBeforeHub.filter((tool) => !EDITING_TOOLS.has(tool)), "subagent"])];
+		pi.setActiveTools(nextTools);
+	}
+
+	function restoreTools(): void {
+		if (toolsBeforeHub) pi.setActiveTools(toolsBeforeHub);
+		toolsBeforeHub = undefined;
+	}
+
+	function enableHub(ctx: ExtensionContext, prompt?: string): void {
+		hubActive = true;
+		promptOverride = prompt;
+		applyHubTools();
+		ctx.ui.setStatus("hub", ctx.ui.theme.fg("warning", "hub"));
+		ctx.ui.notify("Hub mode enabled. Main-session editing tools disabled.", "info");
+	}
+
+	function disableHub(ctx: ExtensionContext): void {
+		hubActive = false;
+		promptOverride = undefined;
+		restoreTools();
+		ctx.ui.setStatus("hub", undefined);
+		ctx.ui.notify("Hub mode disabled. Editing tools restored.", "info");
+	}
+
+	pi.registerCommand("hub", {
+		description: "Toggle hub orchestration mode; disables main-session editing tools",
+		handler: async (args, ctx) => {
+			const command = args.trim().toLowerCase();
+			if (command === "off" || (hubActive && command !== "on")) disableHub(ctx);
+			else enableHub(ctx, loadOrchestratorPrompt(ctx.cwd));
+		},
+	});
+
+	pi.registerCommand("orchestrate", {
+		description: "Bootstrap project-specific agents, then run the orchestrator workflow for an optional goal",
+		handler: async (args, ctx) => {
+			const goal = args.trim();
+			if (!ctx.isIdle()) {
+				ctx.ui.notify("Wait for the current turn to finish before starting orchestration.", "warning");
+				return;
+			}
+			enableHub(ctx, loadOrchestratorPrompt(ctx.cwd));
+			if (goal) {
+				pi.sendUserMessage(`First ensure this repository has durable project-scoped agents based on the repo's overall stack and architecture, not on this single task. If suitable project agents do not exist yet, bootstrap and get approval to create them before implementation. Then orchestrate this goal through the hub-and-spoke loop:\n\n${goal}`);
+				return;
+			}
+			pi.sendUserMessage("Bootstrap durable project-scoped agents for this repository based on its overall stack, architecture, and recurring work. Do not derive the agent set from a one-off task. If suitable project agents already exist, report that coverage and stop.");
+		},
+	});
+
+	pi.on("before_agent_start", async (event, ctx) => {
+		if (!hubActive) return;
+		const dynamicHubPrompt = `${HUB_PROMPT}${formatProjectAgentGuidance(ctx.cwd)}`;
+		return {
+			systemPrompt: `${event.systemPrompt}\n\n${dynamicHubPrompt}\n\n${promptOverride ?? ""}`,
+		};
+	});
+
+	pi.on("tool_call", async (event) => {
+		if (!hubActive) return;
+		if (EDITING_TOOLS.has(event.toolName)) {
+			return {
+				block: true,
+				reason: "Hub mode: main-session editing tools are disabled. Delegate file changes through subagent.",
+			};
+		}
+		if (event.toolName === "bash" && isMutatingBashCommand(String(event.args?.command ?? ""))) {
+			return {
+				block: true,
+				reason: "Hub mode: mutating bash commands are disabled in the main session. Delegate repository changes through subagent.",
+			};
+		}
+	});
+
+	pi.on("session_shutdown", async () => {
+		hubActive = false;
+		promptOverride = undefined;
+		toolsBeforeHub = undefined;
+	});
+}

package/extensions/subagent/agents.ts

@@ -0,0 +1,159 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CONFIG_DIR_NAME, parseFrontmatter } from "@earendil-works/pi-coding-agent";
+
+export type AgentScope = "user" | "project" | "both";
+
+export interface AgentConfig {
+	name: string;
+	description: string;
+	tools?: string[];
+	model?: string;
+	systemPrompt: string;
+	source: "user" | "project";
+	filePath: string;
+}
+
+export interface AgentDiscoveryResult {
+	agents: AgentConfig[];
+	projectAgentsDir: string | null;
+}
+
+export interface ProjectAgentsInfo {
+	dir: string;
+	agentNames: string[];
+}
+
+function realpathIfPossible(p: string): string {
+	try {
+		return fs.realpathSync.native(p);
+	} catch {
+		return p;
+	}
+}
+
+const packageDir = realpathIfPossible(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../.."));
+export const bundledAgentsDir = path.join(packageDir, "agents");
+
+function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig[] {
+	const agents: AgentConfig[] = [];
+	if (!fs.existsSync(dir)) return agents;
+
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return agents;
+	}
+
+	for (const entry of entries) {
+		if (!entry.name.endsWith(".md")) continue;
+		if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+
+		const filePath = path.join(dir, entry.name);
+		let content: string;
+		try {
+			content = fs.readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+
+		const { frontmatter, body } = parseFrontmatter<Record<string, string>>(content);
+		if (!frontmatter.name || !frontmatter.description) continue;
+
+		const tools = frontmatter.tools
+			?.split(",")
+			.map((t: string) => t.trim())
+			.filter(Boolean);
+
+		agents.push({
+			name: frontmatter.name,
+			description: frontmatter.description,
+			tools: tools && tools.length > 0 ? tools : undefined,
+			model: frontmatter.model,
+			systemPrompt: body,
+			source,
+			filePath,
+		});
+	}
+
+	return agents;
+}
+
+function isDirectory(p: string): boolean {
+	try {
+		return fs.statSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+function normalizeSearchStart(cwd: string): string {
+	const resolved = realpathIfPossible(path.resolve(cwd));
+	return isDirectory(resolved) ? resolved : path.dirname(resolved);
+}
+
+export function findNearestProjectAgentsDir(cwd: string): string | null {
+	let currentDir = normalizeSearchStart(cwd);
+	while (true) {
+		const candidate = path.join(currentDir, CONFIG_DIR_NAME, "agents");
+		if (isDirectory(candidate)) return realpathIfPossible(candidate);
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+
+export function findNearestProjectAgentsInfo(cwd: string): ProjectAgentsInfo | null {
+	const dir = findNearestProjectAgentsDir(cwd);
+	if (!dir) return null;
+
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return { dir, agentNames: [] };
+	}
+
+	const agentNames = entries
+		.filter((entry) => (entry.isFile() || entry.isSymbolicLink()) && entry.name.endsWith(".md"))
+		.map((entry) => entry.name.replace(/\.md$/, ""))
+		.sort();
+
+	return { dir, agentNames };
+}
+
+export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
+	const projectAgentsDir = findNearestProjectAgentsDir(cwd);
+	const bundledAgents = scope === "project" ? [] : loadAgentsFromDir(bundledAgentsDir, "user");
+	const projectAgents = scope === "user" || !projectAgentsDir ? [] : loadAgentsFromDir(projectAgentsDir, "project");
+	const agentMap = new Map<string, AgentConfig>();
+
+	if (scope === "both") {
+		for (const agent of bundledAgents) agentMap.set(agent.name, agent);
+		for (const agent of projectAgents) agentMap.set(agent.name, agent);
+	} else if (scope === "user") {
+		for (const agent of bundledAgents) agentMap.set(agent.name, agent);
+	} else {
+		for (const agent of projectAgents) agentMap.set(agent.name, agent);
+	}
+
+	return { agents: Array.from(agentMap.values()), projectAgentsDir };
+}
+
+export function formatAgentSourceLabel(source: AgentConfig["source"] | "unknown"): string {
+	if (source === "user") return "user (bundled/package)";
+	if (source === "project") return "project";
+	return "unknown";
+}
+
+export function formatAgentList(agents: AgentConfig[], maxItems: number): { text: string; remaining: number } {
+	if (agents.length === 0) return { text: "none", remaining: 0 };
+	const listed = agents.slice(0, maxItems);
+	const remaining = agents.length - listed.length;
+	return {
+		text: listed.map((a) => `${a.name} (${formatAgentSourceLabel(a.source)}): ${a.description}`).join("; "),
+		remaining,
+	};
+}