one-code-extension 0.4.1 → 0.5.0

package/extensions/lib/persisted-output.ts

@@ -12,25 +12,48 @@
  * The model then reads or greps the file for the parts it actually needs.
  */
 
-import { mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { closeSync, mkdirSync, openSync, readSync, statSync, writeFileSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
 import { join } from "node:path";
+import { oneCodeStateDir } from "./paths.ts";
+import { privateSessionTempDir } from "./scratchpad.ts";
 
 /**
  * Where a session's oversized outputs are persisted — the session dir,
  * matching Claude Code's `<session-dir>/tool-results/<id>.txt`. A session-less
- * run (`--no-session`) has no such dir, so a temp folder serves; the model gets
- * the path either way. Shared by every producer that would otherwise truncate:
- * cutting text loses context, a file keeps it one `read` away.
+ * run (`--no-session`, every workflow agent, a subagent of a session-less
+ * parent) has no such dir, so the session's own private temp dir serves
+ * (`<tmp>/onecode-<uid>/<project-slug>/<session-id>`, 0700, beside its
+ * scratchpad). Until 2026-09-27 that fallback was one shared
+ * `<tmp>/one-code` with no uid or session in its name, which the gate then
+ * treated as working space: every session-less run on the machine, any
+ * project and any user, read the others' outputs with no prompt. When the
+ * temp dir cannot be made private, `~/.onecode/tmp/<session-id>` serves. The
+ * model gets the path either way. Shared by every producer that would
+ * otherwise truncate: cutting text loses context, a file keeps it one `read`
+ * away.
  */
-export function sessionResultsDir(ctx: { sessionManager?: { getSessionDir?: () => string | undefined } } | undefined): string {
+export function sessionResultsDir(
+	ctx: { cwd?: string; sessionManager?: { getSessionDir?: () => string | undefined; getSessionId?: () => string } } | undefined,
+): string {
+	let sessionId: string | undefined;
 	try {
 		const dir = ctx?.sessionManager?.getSessionDir?.();
 		if (dir) return dir;
+		sessionId = ctx?.sessionManager?.getSessionId?.();
 	} catch {
-		// fall through to the temp folder
+		// fall through to the private temp folder
 	}
-	return join(tmpdir(), "one-code");
+	const id = (sessionId || `process-${process.pid}`).replace(/[^A-Za-z0-9._-]/g, "_");
+	const temp = privateSessionTempDir(ctx?.cwd ?? process.cwd(), id);
+	if (temp) return temp;
+	const fallback = join(oneCodeStateDir(), "tmp", id);
+	try {
+		mkdirSync(fallback, { recursive: true, mode: 0o700 });
+	} catch {
+		// persistIfLarge names the failed write in its own result.
+	}
+	return fallback;
 }
 
 /** Claude Code persists around this size; pi's bash truncation uses 50KB too. */
@@ -76,6 +99,35 @@ export function persistIfLarge(text: string, options: PersistOptions): string {
 		saved = `Output too large (${formatSize(size)}) and could not be saved to ${file}: ${(error as Error).message}. Only this preview survives — re-run with a narrower query if more is needed.`;
 	}
 
+	return persistedBlock(saved, preview, previewBytes);
+}
+
+/**
+ * The block for output already whole in a file (a monitor's spool): its path,
+ * its size and a preview, the same shape `persistIfLarge` returns, without
+ * reading or copying the file.
+ */
+export function persistedFileBlock(file: string, size: number, preview: string, previewBytes: number = PREVIEW_BYTES): string {
+	return persistedBlock(`Output too large (${formatSize(size)}). Full output saved to: ${file}`, preview, previewBytes);
+}
+
+/** Preview an existing spool without reading or copying the whole output. */
+export function persistedFilePreview(path: string): string | undefined {
+	let fd: number | undefined;
+	try {
+		const { size } = statSync(path);
+		fd = openSync(path, "r");
+		const head = Buffer.alloc(Math.min(size, PREVIEW_BYTES));
+		const read = readSync(fd, head, 0, head.length, 0);
+		return persistedFileBlock(path, size, new StringDecoder("utf8").write(head.subarray(0, read)));
+	} catch {
+		return undefined;
+	} finally {
+		if (fd !== undefined) closeSync(fd);
+	}
+}
+
+function persistedBlock(saved: string, preview: string, previewBytes: number): string {
 	return [
 		"<persisted-output>",
 		saved,

package/extensions/lib/pi-ai-estimate.ts

@@ -20,7 +20,8 @@
  * (which pi-ai re-exports from its entry point, so it needs no vendoring — unlike
  * the estimate/clamp helpers under `/utils/estimate` and `/api/simple-options`,
  * which have no bare re-export). The two exported helpers
- * are byte-identical to upstream; the one adaptation is the internal
+ * are byte-identical to upstream (pi-ai 1.1.0 changed only `CHARS_PER_TOKEN`,
+ * which `charsPerToken` picks for the running pi); the one adaptation is the internal
  * `estimateContextTokens`, narrowed to accept only `Context` (the sole shape we
  * call it with) rather than upstream's `Context | Message[]` overload — the
  * Message[] branch would be dead code here. `test/unit/pi-ai-estimate.test.ts`
@@ -48,8 +49,22 @@
  */
 
 import { getSystemMessageText, type Api, type Context, type ImageContent, type Message, type Model, type TextContent, type Usage } from "@earendil-works/pi-ai";
+import { VERSION as PI_VERSION } from "@earendil-works/pi-coding-agent";
+import { compareVersions } from "./pi-version.ts";
 
-const CHARS_PER_TOKEN = 4;
+/**
+ * pi-ai's characters per token: 4 through pi-ai 1.0.x, 3.5 from pi-ai 1.1.0.
+ * pi-ai's entry point looks the same on both, so the running pi's version
+ * stands in: pi 0.x keeps pi-ai 0.x and pi 1.1.0 requires pi-ai ^1.1.0, but
+ * pi 1.0.x can float onto either (pi ships no shrinkwrap since 1.0.1). There
+ * 3.5 wins, as it predicts less output room than pi gives, never more.
+ */
+export function charsPerToken(piVersion: string | undefined): number {
+	const order = piVersion === undefined ? undefined : compareVersions(piVersion, "1.0.0");
+	return order !== undefined && order < 0 ? 4 : 3.5;
+}
+
+const CHARS_PER_TOKEN = charsPerToken(PI_VERSION);
 const ESTIMATED_IMAGE_CHARS = 4800;
 const CONTEXT_SAFETY_TOKENS = 4096;
 const MIN_MAX_TOKENS = 1;
@@ -73,7 +88,8 @@ function estimateTextAndImageContentChars(content: string | Array<TextContent |
 	return chars;
 }
 
-function estimateTextTokens(text: string): number {
+/** pi-ai's chars-per-token estimate for plain text. */
+export function estimateTextTokens(text: string): number {
 	return Math.ceil(text.length / CHARS_PER_TOKEN);
 }
 

package/extensions/lib/pi-version.ts

@@ -8,11 +8,17 @@
  * version to the range this release was verified against and warns — softly,
  * never blocking — when outside it. The bundled `one-code` app pins pi inside
  * the range, so it never warns.
+ *
+ * The minimum is the oldest pi the extension set loads on: 0.84.3 first
+ * exports `createPowerShellToolDefinition`, and on anything older the
+ * PowerShell extension fails at load, which stops pi before any warning can
+ * show. The peer range in package.json and the guide name the same floor
+ * (pi-version.test.ts), and CI runs `test/e2e/pi-floor-smoke.mjs` against it.
  */
 
 /** Inclusive minimum and exclusive maximum pi version this release is tested against. */
-export const TESTED_PI_MIN = "0.83.0";
-export const TESTED_PI_MAX_EXCLUSIVE = "0.87.0";
+export const TESTED_PI_MIN = "0.84.3";
+export const TESTED_PI_MAX_EXCLUSIVE = "1.4.0";
 
 /** Dotted-numeric parse; undefined for anything that is not plain x.y.z numbers. */
 export function parseVersion(version: string): number[] | undefined {
@@ -52,3 +58,16 @@ export function piVersionWarning(runningPiVersion: string | undefined): string |
 		`(or pin pi inside the tested range).`
 	);
 }
+
+/**
+ * Whether the running pi ships built-in extensions that can replace ours'
+ * names (`builtin:tool-search`, `builtin:mcp`; lib/replaced-builtins.mjs).
+ * A version check, not a feature test: nothing an extension can see tells a
+ * pi with the built-ins from one without, and an unparseable version reads
+ * as no.
+ */
+export function piHasBuiltinExtensions(runningPiVersion: string | undefined, firstVersion: string): boolean {
+	if (!runningPiVersion) return false;
+	const order = compareVersions(runningPiVersion, firstVersion);
+	return order !== undefined && order >= 0;
+}

package/extensions/lib/plan-mode-channels.ts

@@ -1,11 +1,26 @@
 /**
- * Bus channels between plan-mode and permissions. They live here, not in
- * either extension, because permissions cannot import plan-mode (plan-mode
- * already imports `permissions/modes.ts`) and a string literal typed in two
- * places is the one way a channel rename silently disconnects a listener.
+ * Bus channels between plan-mode and permissions, and the session entry that
+ * records the plan file (also read by the post-compaction file restore). They
+ * live here, not in either extension, because permissions cannot import
+ * plan-mode (plan-mode already imports `permissions/modes.ts`) and a string
+ * literal typed in two places is the one way a rename silently disconnects a
+ * reader.
  */
 
-/** Request a permission-mode change (`{ mode }`); permissions applies it. */
+/** Request a permission-mode change (`{ mode, toolCallId? }`); permissions applies it and anchors a tool-driven switch to its result. */
 export const MODE_CHANNEL = "one-code:set-permission-mode";
 /** Announces plan mode's one writable file (`{ path }`); the permissions matcher consumes it. */
 export const PLAN_FILE_CHANNEL = "one-code:plan-file-path";
+/** Session entry type persisting plan mode's allocated path across resume/branch (`{ path }`). */
+export const PLAN_FILE_ENTRY = "one-code:plan-mode-file";
+
+/** The plan file the branch's latest plan-file entry records, if any. */
+export function planFileOnBranch(entries: readonly { type: string; customType?: string; data?: unknown }[]): string | undefined {
+	let path: string | undefined;
+	for (const entry of entries) {
+		if (entry.type !== "custom" || entry.customType !== PLAN_FILE_ENTRY) continue;
+		const recorded = (entry.data as { path?: unknown } | undefined)?.path;
+		if (typeof recorded === "string") path = recorded;
+	}
+	return path;
+}

package/extensions/lib/plugins.ts

@@ -36,6 +36,7 @@ import { readEnabledPlugins } from "./claude-settings.ts";
 import { readOverrides } from "./plugin-overrides.ts";
 import { pluginRoot } from "./plugin-root.ts";
 import { isSkillEnabled, readSkillStates, skillOverrideKey } from "./skill-overrides.ts";
+import { claudeSourcesOn } from "./config-mode.ts";
 import { claudeUserDir } from "./paths.ts";
 
 export interface PluginManifest {
@@ -144,7 +145,12 @@ export function loadInstalledPlugins(pluginsDir: string, cwd?: string): Installe
 	const plugins: InstalledPlugin[] = [];
 	for (const [key, entries] of Object.entries(registry.plugins)) {
 		if (!Array.isArray(entries) || entries.length === 0) continue;
-		const entry = entries.find((e) => e.installPath && existsSync(e.installPath) && entryAppliesToCwd(e, cwd));
+		const entry = entries.find((e) =>
+			e && typeof e === "object" && !Array.isArray(e) &&
+			typeof e.installPath === "string" && e.installPath.length > 0 &&
+			(e.projectPath === undefined || typeof e.projectPath === "string") &&
+			existsSync(e.installPath) && entryAppliesToCwd(e, cwd),
+		);
 		if (!entry?.installPath) continue;
 
 		const { name, marketplace } = splitPluginKey(key);
@@ -158,7 +164,7 @@ export function loadInstalledPlugins(pluginsDir: string, cwd?: string): Installe
 			name: validPluginName(manifest?.name) ?? name,
 			marketplace,
 			path: entry.installPath,
-			version: entry.version,
+			version: typeof entry.version === "string" ? entry.version : undefined,
 			description: typeof manifest?.description === "string" ? manifest.description : undefined,
 			rawEnabled: typeof entry.enabled === "boolean" ? entry.enabled : undefined,
 		});
@@ -166,12 +172,12 @@ export function loadInstalledPlugins(pluginsDir: string, cwd?: string): Installe
 	return plugins.sort((a, b) => a.name.localeCompare(b.name));
 }
 
-/** A manifest `name` usable as a namespace: a non-empty string free of path separators, colons and whitespace. */
+/** A manifest `name` usable as a namespace and plugin identifier. */
 export function validPluginName(value: unknown): string | undefined {
 	if (typeof value !== "string") return undefined;
 	const trimmed = value.trim();
-	if (trimmed.length === 0) return undefined;
-	if (/[/\\:\s]/.test(trimmed)) return undefined;
+	if (trimmed.length === 0 || trimmed === "." || trimmed.includes("..")) return undefined;
+	if (/[/\\:@\s\p{Cc}\p{Cf}]/u.test(trimmed)) return undefined;
 	return trimmed;
 }
 
@@ -244,8 +250,8 @@ export function findPluginCommands(plugin: Pick<Plugin, "name">, commandsDir: st
 
 /** The two roots + settings locations discovery reads from. */
 export interface DiscoverRoots {
-	/** Claude Code's plugins dir (`~/.claude/plugins`) — read-only. */
-	claudePluginsDir: string;
+	/** Claude Code's plugins dir (`~/.claude/plugins`) — read-only; unset in independent mode (lib/config-mode.ts). */
+	claudePluginsDir?: string;
 	/** One Code's plugin root (`<agentDir>/plugins`) — ours to write. */
 	oneCodeRoot: string;
 	cwd: string;
@@ -255,7 +261,7 @@ export interface DiscoverRoots {
 /** The standard roots; wiring passes `getAgentDir()` (pure modules can't). */
 export function defaultDiscoverRoots(agentDir: string, cwd: string = process.cwd(), home: string = os.homedir()): DiscoverRoots {
 	return {
-		claudePluginsDir: join(claudeUserDir(home), "plugins"),
+		claudePluginsDir: claudeSourcesOn() ? join(claudeUserDir(home), "plugins") : undefined,
 		oneCodeRoot: pluginRoot(agentDir),
 		cwd,
 		home,
@@ -330,20 +336,23 @@ export function invalidatePluginsCache(): void {
 }
 
 export function discoverPlugins(roots: DiscoverRoots): DiscoveredPlugins {
-	const key = [roots.claudePluginsDir, roots.oneCodeRoot, roots.cwd, roots.home].join("\n");
+	const claudeDir = roots.claudePluginsDir;
+	const key = [claudeDir ?? "", roots.oneCodeRoot, roots.cwd, roots.home].join("\n");
 	if (box.current?.key === key) return box.current.result;
 
-	const ccEnabled = readEnabledPlugins(roots.cwd, roots.home);
+	const ccEnabled = claudeDir ? readEnabledPlugins(roots.cwd, roots.home) : {};
 	const overrides = readOverrides(roots.oneCodeRoot);
 	const skillOverrides = readSkillStates(roots.oneCodeRoot);
 
-	const claudePlugins: Plugin[] = loadInstalledPlugins(roots.claudePluginsDir, roots.cwd).map((p) => ({
-		...p,
-		originRoot: "claude" as const,
-		enabled: claudePluginEnabled(p.id, ccEnabled, overrides),
-		overridden: p.id in overrides,
-		dataRoot: join(roots.claudePluginsDir, "data"),
-	}));
+	const claudePlugins: Plugin[] = claudeDir
+		? loadInstalledPlugins(claudeDir, roots.cwd).map((p) => ({
+				...p,
+				originRoot: "claude" as const,
+				enabled: claudePluginEnabled(p.id, ccEnabled, overrides),
+				overridden: p.id in overrides,
+				dataRoot: join(claudeDir, "data"),
+			}))
+		: [];
 
 	const oneCodePlugins: Plugin[] = loadInstalledPlugins(roots.oneCodeRoot, roots.cwd).map((p) => ({
 		...p,

package/extensions/lib/powershell-parse-script.ts

@@ -0,0 +1,208 @@
+/**
+ * The PowerShell side of the parse server (lib/powershell-parser.ts): a short
+ * bootstrap passed on the command line, and the walker script it reads from
+ * stdin and runs.
+ *
+ * The walker calls PowerShell's own `Parser::ParseInput` on each request and
+ * writes back every syntax-tree node, so the gate judges the line exactly as
+ * the PowerShell that runs it reads it (decisions/windows.md "The PowerShell
+ * pre-gate reads PowerShell's own parse"). All judgement stays in TypeScript;
+ * the walker only reports.
+ *
+ * Wire protocol, one line each way, ASCII only because every payload is
+ * base64: Windows PowerShell 5.1 reads and writes its console in the OEM code
+ * page, which would garble exactly the Unicode dashes and quotes a gate must
+ * see.
+ *
+ * - The first stdin line is the walker script (base64 UTF-8). The walker
+ *   answers with a ready record, id 0: `{ id, ready, edition, version, language }`.
+ * - Each later stdin line is `<id> <base64 UTF-8 command>`. The walker answers
+ *   `{ id, nodes, errors }`, or `{ id, failure }` when the walk itself threw.
+ * - Each stdout line is base64 UTF-8 JSON. EOF on stdin ends the walker.
+ *
+ * `nodes` is the tree in pre-order, root first. Each node carries its .NET
+ * type name, its parent's index (-1 for the root), its extent as UTF-16
+ * offsets into the command (the same units as a JS string index), and a few
+ * fields for the types a gate reads (see `nodeFields`). `errors` lists each
+ * parse error's ErrorId; PowerShell runs nothing from a line that has one.
+ *
+ * Pure: two string constants, no pi imports, shared with the BI fork.
+ */
+
+/**
+ * Passed after `-Command`. It reads the first stdin line and runs it as the
+ * walker. It holds no double quote, so no platform's argument quoting can
+ * change it.
+ */
+export const POWERSHELL_PARSE_BOOTSTRAP =
+	"$s=[Console]::In.ReadLine();if($null -ne $s){. ([ScriptBlock]::Create([Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($s))))}";
+
+/** The walker, sent as the first stdin line. Plain ASCII; no backtick, so it survives a template literal unchanged. */
+export const POWERSHELL_PARSE_WALKER = String.raw`
+$ErrorActionPreference = 'Stop'
+$utf8 = New-Object System.Text.UTF8Encoding $false
+$out = [Console]::Out
+
+# Command lookup must never load or run a module: autoloading is off, and the
+# built-in modules the gate's cmdlets live in are imported from $PSHOME by
+# path, so a same-named module earlier on PSModulePath cannot stand in. The
+# walker only reports what a name resolves to (type, module, path); the gate
+# enforces which of those it trusts (powershell-tree.ts).
+$PSModuleAutoLoadingPreference = 'None'
+foreach ($module in 'Microsoft.PowerShell.Management', 'Microsoft.PowerShell.Utility', 'Microsoft.PowerShell.Security') {
+	$manifest = "$PSHOME/Modules/$module"
+	if ([System.IO.Directory]::Exists($manifest)) { try { Import-Module -Name $manifest } catch {} }
+}
+$binderType = 'System.Management.Automation.Language.StaticParameterBinder' -as [type]
+
+function Send-Record($record) {
+	$json = ConvertTo-Json -InputObject $record -Depth 5 -Compress
+	$out.WriteLine([Convert]::ToBase64String($utf8.GetBytes($json)))
+	$out.Flush()
+}
+
+function Get-NodeFields($node) {
+	$f = @{}
+	switch ($node.GetType().Name) {
+		'CommandAst' { $f.operator = [string]$node.InvocationOperator; $f.name = $node.GetCommandName() }
+		'CommandParameterAst' { $f.name = $node.ParameterName }
+		'StringConstantExpressionAst' { $f.value = $node.Value; $f.kind = [string]$node.StringConstantType }
+		'ExpandableStringExpressionAst' { $f.value = $node.Value; $f.kind = [string]$node.StringConstantType }
+		'ConstantExpressionAst' { $f.value = [string]$node.Value }
+		'VariableExpressionAst' { $f.name = $node.VariablePath.UserPath; $f.splatted = $node.Splatted }
+		'FileRedirectionAst' { $f.from = [string]$node.FromStream; $f.append = $node.Append }
+		'MergingRedirectionAst' { $f.from = [string]$node.FromStream; $f.to = [string]$node.ToStream }
+		'BinaryExpressionAst' { $f.operator = [string]$node.Operator }
+		'UnaryExpressionAst' { $f.operator = [string]$node.TokenKind }
+		'AssignmentStatementAst' { $f.operator = [string]$node.Operator }
+		'PipelineChainAst' { $f.operator = [string]$node.Operator; $f.background = $node.Background }
+		'PipelineAst' { if ($node.PSObject.Properties['Background']) { $f.background = $node.Background } }
+		'TypeExpressionAst' { $f.name = $node.TypeName.FullName }
+		'TypeConstraintAst' { $f.name = $node.TypeName.FullName }
+		'MemberExpressionAst' { $f.static = $node.Static }
+		'InvokeMemberExpressionAst' { $f.static = $node.Static }
+	}
+	$f
+}
+
+Send-Record @{
+	id = 0
+	ready = $true
+	edition = [string]$PSVersionTable.PSEdition
+	version = [string]$PSVersionTable.PSVersion
+	language = [string]$ExecutionContext.SessionState.LanguageMode
+}
+
+while ($null -ne ($line = [Console]::In.ReadLine())) {
+	$space = $line.IndexOf(' ')
+	if ($space -lt 1) { continue }
+	$id = [int]$line.Substring(0, $space)
+	try {
+		$command = $utf8.GetString([Convert]::FromBase64String($line.Substring($space + 1)))
+		$tokens = $null
+		$parseErrors = $null
+		$ast = [System.Management.Automation.Language.Parser]::ParseInput($command, [ref]$tokens, [ref]$parseErrors)
+		$all = @($ast.FindAll({ $true }, $true))
+		$index = New-Object 'System.Collections.Generic.Dictionary[System.Object,int]'
+		$nodes = New-Object System.Collections.ArrayList
+		$asts = New-Object System.Collections.ArrayList
+		foreach ($node in $all) {
+			if ($index.ContainsKey($node)) { continue }
+			$parent = -1
+			if ($null -ne $node.Parent -and $index.ContainsKey($node.Parent)) { $parent = $index[$node.Parent] }
+			$record = Get-NodeFields $node
+			$record.type = $node.GetType().Name
+			$record.parent = $parent
+			$record.start = $node.Extent.StartOffset
+			$record.end = $node.Extent.EndOffset
+			$index[$node] = $nodes.Count
+			[void]$nodes.Add($record)
+			[void]$asts.Add($node)
+		}
+		# Second pass, once every node has its index: what each static command
+		# name resolves to in this PowerShell, and for a cmdlet how PowerShell's
+		# own binder assigns its arguments to parameters.
+		for ($i = 0; $i -lt $nodes.Count; $i++) {
+			if ($nodes[$i].type -ne 'CommandAst' -or $null -eq $nodes[$i].name) { continue }
+			$command = $asts[$i]
+			$info = $null
+			try { $info = $ExecutionContext.InvokeCommand.GetCommand($nodes[$i].name, 'All') } catch {}
+			if ($null -eq $info) { continue }
+			if ($info -is [System.Management.Automation.AliasInfo]) {
+				$nodes[$i].alias = $true
+				$info = $info.ResolvedCommand
+				if ($null -eq $info) { continue }
+			}
+			$nodes[$i].commandType = [string]$info.CommandType
+			$nodes[$i].resolvedName = $info.Name
+			if ($info -is [System.Management.Automation.ApplicationInfo]) { $nodes[$i].resolvedName = $info.Path }
+			$nodes[$i].module = [string]$info.ModuleName
+			if ($info -isnot [System.Management.Automation.CmdletInfo]) { continue }
+			if ($null -eq $binderType) { $nodes[$i].bindingUnavailable = $true; continue }
+			try {
+				# An aliased command is bound as a copy spelled with the cmdlet's name,
+				# so the binding never depends on how an edition's binder treats an
+				# alias; each bound value is mapped back by extent.
+				$bindAst = $command
+				$origin = 0
+				$nameEnd = 0
+				$delta = 0
+				if ($nodes[$i].alias) {
+					$nameExtent = $command.CommandElements[0].Extent
+					$relative = $nameExtent.StartOffset - $command.Extent.StartOffset
+					$text = $command.Extent.Text
+					$copy = $text.Substring(0, $relative) + $info.Name + $text.Substring($relative + $nameExtent.Text.Length)
+					$bindAst = [System.Management.Automation.Language.Parser]::ParseInput($copy, [ref]$null, [ref]$null).Find({ param($n) $n -is [System.Management.Automation.Language.CommandAst] }, $false)
+					$origin = $command.Extent.StartOffset
+					$nameEnd = $relative + $info.Name.Length
+					$delta = $info.Name.Length - $nameExtent.Text.Length
+				}
+				# The node of the original command a bound value stands for, or -1:
+				# the value itself, or the node with the same (mapped) extent and type.
+				# The binder builds values of its own for a remaining-arguments
+				# parameter (Write-Output a b: an array of copies).
+				$original = {
+					param($ast)
+					if ([object]::ReferenceEquals($bindAst, $command) -and $index.ContainsKey($ast)) { return $index[$ast] }
+					$start = $ast.Extent.StartOffset
+					$end = $ast.Extent.EndOffset
+					if (-not [object]::ReferenceEquals($bindAst, $command)) {
+						if ($start -ge $nameEnd) { $start -= $delta }
+						if ($end -ge $nameEnd) { $end -= $delta }
+						$start += $origin
+						$end += $origin
+					}
+					$type = $ast.GetType().Name
+					for ($j = $i + 1; $j -lt $nodes.Count -and $nodes[$j].start -lt $command.Extent.EndOffset; $j++) {
+						if ($nodes[$j].start -eq $start -and $nodes[$j].end -eq $end -and $nodes[$j].type -eq $type) { return $j }
+					}
+					return -1
+				}
+				$bound = $binderType::BindCommand($bindAst, $true)
+				$nodes[$i].bindings = @(foreach ($key in $bound.BoundParameters.Keys) {
+					$result = $bound.BoundParameters[$key]
+					$record = @{ parameter = [string]$key; value = -1 }
+					if ($null -ne $result.Value) {
+						$record.value = & $original $result.Value
+						# -2 marks a value the binder built: its elements, if an array,
+						# are mapped one by one.
+						if ($record.value -lt 0) {
+							$record.value = -2
+							if ($result.Value -is [System.Management.Automation.Language.ArrayLiteralAst]) {
+								$record.elements = @(foreach ($element in $result.Value.Elements) { & $original $element })
+							}
+						}
+					}
+					$record
+				})
+				$nodes[$i].bindingErrors = @(foreach ($key in $bound.BindingExceptions.Keys) { [string]$key })
+			} catch {
+				$nodes[$i].bindingUnavailable = $true
+			}
+		}
+		Send-Record @{ id = $id; nodes = @($nodes); errors = @($parseErrors | ForEach-Object { $_.ErrorId }) }
+	} catch {
+		Send-Record @{ id = $id; failure = $_.Exception.Message }
+	}
+}
+`;