@caupulican/pi-adaptative 0.81.41 → 0.81.43

package/dist/bundled-resources/extensions/tmux-agent-manager/index.ts

@@ -405,6 +405,19 @@ const PROVIDER_COMMANDS: Record<Provider, string> = {
 	opencode: "opencode",
 	custom: "",
 };
+function providerSchema(description?: string) {
+	return Type.Union(
+		[
+			Type.Literal("pi"),
+			Type.Literal("codex"),
+			Type.Literal("agy"),
+			Type.Literal("claude"),
+			Type.Literal("opencode"),
+			Type.Literal("custom"),
+		],
+		description === undefined ? {} : { description },
+	);
+}
 const DEFAULT_DEADLINE_SECONDS = 20 * 60;
 const MAX_DEADLINE_SECONDS = 24 * 60 * 60;
 const TEAM_TEMPLATES: TeamTemplate[] = [
@@ -1135,6 +1148,41 @@ function injectPromptToPane(paneId: string, prompt: string, provider: Provider):
 		`tmux prompt submit for ${paneId}`,
 	);
 }
+type AgentTurnArtifacts = {
+	doneMarker: string;
+	blockedMarker: string;
+	resultPath: string;
+	promptPath: string;
+	watcherPath: string;
+};
+function resolveAgentTurnArtifacts(job: FireTaskPlan, agent: FireAgentPlan, turn: number): AgentTurnArtifacts {
+	const markers = turnMarkers(job, agent, turn);
+	return {
+		doneMarker: markers.doneMarker,
+		blockedMarker: markers.blockedMarker,
+		resultPath: turnResultPath(job.jobDir, agent.id, turn, agent.resultPath),
+		promptPath: turnPromptPath(job.jobDir, agent.id, turn, agent.promptPath),
+		watcherPath: turnWatcherPath(job, turn),
+	};
+}
+function writeAgentTurnWatcher(job: FireTaskPlan, agent: FireAgentPlan, artifacts: AgentTurnArtifacts): void {
+	const turnSpec: PaneWatcherJobSpec = {
+		id: job.id,
+		sessionName: job.sessionName,
+		deadlineSeconds: job.deadlineSeconds,
+		agents: [
+			{
+				...agent,
+				doneMarker: artifacts.doneMarker,
+				blockedMarker: artifacts.blockedMarker,
+				resultPath: artifacts.resultPath,
+				promptPath: artifacts.promptPath,
+			},
+		],
+	};
+	fs.writeFileSync(artifacts.watcherPath, makePaneWatcherScript(turnSpec), { mode: 0o700 });
+	fs.chmodSync(artifacts.watcherPath, 0o700);
+}
 /** Write a fresh per-turn prompt + single-agent watcher script and arm `pipe-pane -O` for it. Used by
  * send_followup to open a NEW turn on an already-live pane. Does not inject the prompt text into the
  * pane itself — callers do that separately via injectPromptToPane, after this has armed the watcher,
@@ -1146,33 +1194,25 @@ function dispatchAgentTurn(
 	promptText: string,
 ): { promptPath: string; resultPath: string; watcherPath: string } {
 	if (!agent.paneId) throw new Error(`tmux agent ${agent.name} has no recorded pane id`);
-	const markers = turnMarkers(job, agent, turn);
-	const resultPath = turnResultPath(job.jobDir, agent.id, turn, agent.resultPath);
-	const promptPath = turnPromptPath(job.jobDir, agent.id, turn, agent.promptPath);
-	const watcherPath = turnWatcherPath(job, turn);
-	fs.writeFileSync(promptPath, `${promptText}\n`, { mode: 0o600 });
-	const turnSpec: PaneWatcherJobSpec = {
-		id: job.id,
-		sessionName: job.sessionName,
-		deadlineSeconds: job.deadlineSeconds,
-		agents: [
-			{ ...agent, doneMarker: markers.doneMarker, blockedMarker: markers.blockedMarker, resultPath, promptPath },
-		],
-	};
-	fs.writeFileSync(watcherPath, makePaneWatcherScript(turnSpec), { mode: 0o700 });
-	fs.chmodSync(watcherPath, 0o700);
+	const artifacts = resolveAgentTurnArtifacts(job, agent, turn);
+	fs.writeFileSync(artifacts.promptPath, `${promptText}\n`, { mode: 0o600 });
+	writeAgentTurnWatcher(job, agent, artifacts);
 	const armed = runTmux([
 		"pipe-pane",
 		"-O",
 		"-t",
 		agent.paneId,
-		`sh ${quoteShell(watcherPath)} ${quoteShell(agent.id)}`,
+		`sh ${quoteShell(artifacts.watcherPath)} ${quoteShell(agent.id)}`,
 	]);
 	if (!armed.ok)
 		throw new Error(
 			`Failed to arm completion watcher for turn ${turn}: ${armed.error || armed.stderr || armed.stdout}`,
 		);
-	return { promptPath, resultPath, watcherPath };
+	return {
+		promptPath: artifacts.promptPath,
+		resultPath: artifacts.resultPath,
+		watcherPath: artifacts.watcherPath,
+	};
 }
 /** Session-level reconcile's resume step: re-arm `pipe-pane` for an agent whose current turn is still
  * pending on a pane tmux confirms is alive AND has no pipe already attached (see tmuxPaneHasPipe). Only
@@ -1181,23 +1221,9 @@ function dispatchAgentTurn(
 function rearmAgentWatcher(job: FireTaskPlan, agent: FireAgentPlan): void {
 	if (!agent.paneId) return;
 	const turn = agent.currentTurn ?? 1;
-	const markers = turnMarkers(job, agent, turn);
-	const resultPath = turnResultPath(job.jobDir, agent.id, turn, agent.resultPath);
-	const promptPath = turnPromptPath(job.jobDir, agent.id, turn, agent.promptPath);
-	const watcherPath = turnWatcherPath(job, turn);
-	if (!fs.existsSync(watcherPath)) {
-		const turnSpec: PaneWatcherJobSpec = {
-			id: job.id,
-			sessionName: job.sessionName,
-			deadlineSeconds: job.deadlineSeconds,
-			agents: [
-				{ ...agent, doneMarker: markers.doneMarker, blockedMarker: markers.blockedMarker, resultPath, promptPath },
-			],
-		};
-		fs.writeFileSync(watcherPath, makePaneWatcherScript(turnSpec), { mode: 0o700 });
-		fs.chmodSync(watcherPath, 0o700);
-	}
-	runTmux(["pipe-pane", "-O", "-t", agent.paneId, `sh ${quoteShell(watcherPath)} ${quoteShell(agent.id)}`]);
+	const artifacts = resolveAgentTurnArtifacts(job, agent, turn);
+	if (!fs.existsSync(artifacts.watcherPath)) writeAgentTurnWatcher(job, agent, artifacts);
+	runTmux(["pipe-pane", "-O", "-t", agent.paneId, `sh ${quoteShell(artifacts.watcherPath)} ${quoteShell(agent.id)}`]);
 }
 function stopTmuxSession(
 	sessionName: string,
@@ -2292,16 +2318,7 @@ export default function tmuxAgentManagerExtension(pi: ExtensionAPI) {
 			agents: Type.Optional(
 				Type.Array(
 					Type.Object({
-						provider: Type.Optional(
-							Type.Union([
-								Type.Literal("pi"),
-								Type.Literal("codex"),
-								Type.Literal("agy"),
-								Type.Literal("claude"),
-								Type.Literal("opencode"),
-								Type.Literal("custom"),
-							]),
-						),
+						provider: Type.Optional(providerSchema()),
 						name: Type.Optional(Type.String({ description: "Pane/worker name." })),
 						command: Type.Optional(
 							Type.String({
@@ -2335,19 +2352,7 @@ export default function tmuxAgentManagerExtension(pi: ExtensionAPI) {
 						"Goal this dispatch/grant is scoped to. For grant_dispatch: an unscoped grant (omitted) covers any goal; a scoped grant covers only launches naming the same goalId. For fire_task/send_followup: tags the request for grant-coverage matching.",
 				}),
 			),
-			agent: Type.Optional(
-				Type.Union(
-					[
-						Type.Literal("pi"),
-						Type.Literal("codex"),
-						Type.Literal("agy"),
-						Type.Literal("claude"),
-						Type.Literal("opencode"),
-						Type.Literal("custom"),
-					],
-					{ description: "grant_dispatch: the provider this standing grant authorizes." },
-				),
-			),
+			agent: Type.Optional(providerSchema("grant_dispatch: the provider this standing grant authorizes.")),
 			allowedTools: Type.Optional(
 				Type.Array(Type.String(), {
 					description:

package/dist/bundled-resources/prompts/skillify.md

@@ -10,7 +10,7 @@ $ARGUMENTS
 
 Steps:
 
-1. Use the `skill-architect` skill (bundled in Pi) to design the skill structure. Verify `pi-harness-learning` is available (bundled) for the store-vs-implement decision.
+1. Use the bundled `skill-architect` skill to design the instructions and `skill-creator` to scaffold and validate the provider-neutral package. Verify `pi-harness-learning` is available for the store-vs-implement decision.
 2. Identify the repeatable goal, inputs, outputs, success criteria, and user corrections from the session.
 3. Draft a `SKILL.md` with valid frontmatter: `name` (kebab-case, ≤64 chars) and `description` (≤1024 chars).
 4. Call the `skillify` tool with your draft to validate and audit it. The tool returns validity, errors, near-duplicate audit (prefer refining an existing skill), and proposedPath. If the tool is unavailable, use the installed skill audit/validator or bounded structural checks and disclose the missing optional check rather than blocking.

package/dist/bundled-resources/runtimes/pi-shell-engine/commands/fs.py

@@ -16,18 +16,12 @@ import shutil
 from typing import TYPE_CHECKING
 
 from errors import UnsupportedConstruct
+from paths import resolve_request_path
 
 if TYPE_CHECKING:
     from context import BuiltinContext
 
 
-def _resolve(cwd: str, path: str) -> str:
-    """Resolve `path` against `cwd` without ever touching process cwd."""
-    if os.path.isabs(path):
-        return os.path.normpath(path)
-    return os.path.normpath(os.path.join(cwd, path))
-
-
 def _to_posix(path: str) -> str:
     return path.replace("\\", "/")
 
@@ -55,15 +49,18 @@ def _split_flags(argv: list[str], allowed: set[str], name: str) -> tuple[set[str
 
 
 def ls(ctx: "BuiltinContext") -> int:
-    flags, positional = _split_flags(ctx.argv[1:], {"a", "A", "1", "r"}, "ls")
+    # `-l` is a compatibility no-op: this bounded engine always emits one name per
+    # line, but accepting the ubiquitous `ls -la` spelling keeps the Python tier
+    # aligned with the PowerShell floor when chaining routes the command here.
+    flags, positional = _split_flags(ctx.argv[1:], {"a", "A", "1", "l", "r"}, "ls")
     if len(positional) > 1:
-        if any(os.path.isdir(_resolve(ctx.cwd, p)) for p in positional):
+        if any(os.path.isdir(resolve_request_path(ctx.cwd, p)) for p in positional):
             raise UnsupportedConstruct("unsupported-flag", "ls: only one directory operand is supported")
         ordered = sorted(positional)
         lines = []
         exit_code = 0
         for operand in ordered:
-            abs_operand = _resolve(ctx.cwd, operand)
+            abs_operand = resolve_request_path(ctx.cwd, operand)
             if os.path.isfile(abs_operand):
                 lines.append(operand)
             else:
@@ -72,7 +69,7 @@ def ls(ctx: "BuiltinContext") -> int:
         ctx.stdout.write("".join(line + "\n" for line in lines).encode())
         return exit_code
     target = positional[0] if positional else "."
-    abs_target = _resolve(ctx.cwd, target)
+    abs_target = resolve_request_path(ctx.cwd, target)
     if not os.path.exists(abs_target):
         ctx.stdout.write(f"ls: cannot access '{target}': No such file or directory\n".encode())
         return 1
@@ -128,7 +125,7 @@ def find(ctx: "BuiltinContext") -> int:
         i += 1
     if path is None:
         path = "."
-    abs_root = _resolve(ctx.cwd, path)
+    abs_root = resolve_request_path(ctx.cwd, path)
     if not os.path.exists(abs_root):
         ctx.stdout.write(f"find: '{path}': No such file or directory\n".encode())
         return 1
@@ -163,7 +160,7 @@ def rm(ctx: "BuiltinContext") -> int:
     force = "f" in flags
     exit_code = 0
     for p in paths:
-        abs_p = _resolve(ctx.cwd, p)
+        abs_p = resolve_request_path(ctx.cwd, p)
         if not os.path.lexists(abs_p):
             if not force:
                 ctx.stdout.write(f"rm: cannot remove '{p}': No such file or directory\n".encode())
@@ -187,8 +184,8 @@ def cp(ctx: "BuiltinContext") -> int:
         return 1
     recursive = "r" in flags or "R" in flags
     src, dst = positional
-    abs_src = _resolve(ctx.cwd, src)
-    abs_dst = _resolve(ctx.cwd, dst)
+    abs_src = resolve_request_path(ctx.cwd, src)
+    abs_dst = resolve_request_path(ctx.cwd, dst)
     if not os.path.exists(abs_src):
         ctx.stdout.write(f"cp: cannot stat '{src}': No such file or directory\n".encode())
         return 1
@@ -214,8 +211,8 @@ def mv(ctx: "BuiltinContext") -> int:
         ctx.stdout.write(b"mv: missing file operand\n")
         return 1
     src, dst = positional
-    abs_src = _resolve(ctx.cwd, src)
-    abs_dst = _resolve(ctx.cwd, dst)
+    abs_src = resolve_request_path(ctx.cwd, src)
+    abs_dst = resolve_request_path(ctx.cwd, dst)
     if not os.path.exists(abs_src):
         ctx.stdout.write(f"mv: cannot stat '{src}': No such file or directory\n".encode())
         return 1
@@ -234,7 +231,7 @@ def mkdir(ctx: "BuiltinContext") -> int:
     parents = "p" in flags
     exit_code = 0
     for d in dirs:
-        abs_d = _resolve(ctx.cwd, d)
+        abs_d = resolve_request_path(ctx.cwd, d)
         if parents:
             os.makedirs(abs_d, exist_ok=True)
             continue
@@ -257,7 +254,7 @@ def touch(ctx: "BuiltinContext") -> int:
         return 1
     exit_code = 0
     for f in files:
-        abs_f = _resolve(ctx.cwd, f)
+        abs_f = resolve_request_path(ctx.cwd, f)
         if os.path.exists(abs_f):
             os.utime(abs_f, None)
             continue

package/dist/bundled-resources/runtimes/pi-shell-engine/commands/search.py

@@ -6,41 +6,27 @@ Pure builtins per windows-shell-workpackages-2026-07-19.md §2.2. Regex dialect
 
 from __future__ import annotations
 
-import os
 import re
 
 from context import BuiltinContext
 from errors import UnsupportedConstruct
+from paths import resolve_request_path
+from shell_args import split_leading_short_options
 
 _GREP_FLAGS = set("ivnclwFE")
 
 
-def _resolve(cwd: str, path: str) -> str:
-    """Resolve `path` against `cwd` (see commands/fs.py's `_resolve`: main.py never os.chdir()s
-    to the request cwd, so every relative FILE operand must resolve against ctx.cwd here too)."""
-    if os.path.isabs(path):
-        return os.path.normpath(path)
-    return os.path.normpath(os.path.join(cwd, path))
-
-
 def cmd_grep(ctx: BuiltinContext) -> int:
     args = ctx.argv[1:]
     flags: set[str] = set()
-    idx = 0
-    while idx < len(args):
-        arg = args[idx]
-        if arg == "--":
-            idx += 1
-            break
-        if arg.startswith("-") and arg != "-" and len(arg) > 1:
-            for c in arg[1:]:
-                if c not in _GREP_FLAGS:
-                    raise UnsupportedConstruct("unsupported-flag", f"grep: unsupported flag '-{c}'")
-                flags.add(c)
-            idx += 1
-            continue
-        break
-    remaining = args[idx:]
+    option_args, remaining = split_leading_short_options(args)
+    for option in option_args:
+        for char in option[1:]:
+            if char not in _GREP_FLAGS:
+                raise UnsupportedConstruct(
+                    "unsupported-flag", f"grep: unsupported flag '-{char}'"
+                )
+            flags.add(char)
     if not remaining:
         raise UnsupportedConstruct("unsupported-flag", "grep: PATTERN operand required")
     pattern = remaining[0]
@@ -118,7 +104,7 @@ def cmd_grep(ctx: BuiltinContext) -> int:
     else:
         for name in files:
             try:
-                with open(_resolve(ctx.cwd, name), "rb") as fh:
+                with open(resolve_request_path(ctx.cwd, name), "rb") as fh:
                     data = fh.read()
             except OSError as exc:
                 out_lines_msg = f"grep: {name}: {exc.strerror or exc}"
@@ -246,7 +232,7 @@ def cmd_sed(ctx: BuiltinContext) -> int:
         ctx.stdout.write(transform(ctx.stdin.read()))
         return 0
     for name in files:
-        with open(_resolve(ctx.cwd, name), "rb") as fh:
+        with open(resolve_request_path(ctx.cwd, name), "rb") as fh:
             data = fh.read()
         ctx.stdout.write(transform(data))
     return 0

package/dist/bundled-resources/runtimes/pi-shell-engine/commands/strings.py

@@ -11,124 +11,31 @@ import os
 
 from context import BuiltinContext
 from errors import UnsupportedConstruct
+from escapes import ECHO_ESCAPES, PRINTF_ESCAPES, decode_backslash_escapes
+from paths import resolve_request_path
+from shell_args import split_leading_short_options
 
 
 def _write(ctx: BuiltinContext, data: str) -> None:
     ctx.stdout.write(data.encode("utf-8"))
 
 
-def _decode_backslash_escapes(text: str, *, allow_c: bool) -> tuple[str, bool]:
-    """Decode the echo/printf escape set. Returns (decoded, stop_output_early)."""
-    out: list[str] = []
-    i = 0
-    n = len(text)
-    while i < n:
-        ch = text[i]
-        if ch != "\\" or i + 1 >= n:
-            out.append(ch)
-            i += 1
-            continue
-        nxt = text[i + 1]
-        if nxt == "\\":
-            out.append("\\")
-            i += 2
-        elif nxt == "a":
-            out.append("\a")
-            i += 2
-        elif nxt == "b":
-            out.append("\b")
-            i += 2
-        elif nxt == "c":
-            if allow_c:
-                return "".join(out), True
-            out.append("\\c")
-            i += 2
-        elif nxt == "e":
-            out.append("\x1b")
-            i += 2
-        elif nxt == "f":
-            out.append("\f")
-            i += 2
-        elif nxt == "n":
-            out.append("\n")
-            i += 2
-        elif nxt == "r":
-            out.append("\r")
-            i += 2
-        elif nxt == "t":
-            out.append("\t")
-            i += 2
-        elif nxt == "v":
-            out.append("\v")
-            i += 2
-        elif nxt == "0":
-            j = i + 2
-            digits = ""
-            while j < n and len(digits) < 3 and text[j] in "01234567":
-                digits += text[j]
-                j += 1
-            if digits:
-                out.append(chr(int(digits, 8) & 0xFF))
-                i = j
-            else:
-                out.append("\0")
-                i += 2
-        elif nxt == "x":
-            j = i + 2
-            digits = ""
-            while j < n and len(digits) < 2 and text[j] in "0123456789abcdefABCDEF":
-                digits += text[j]
-                j += 1
-            if digits:
-                out.append(chr(int(digits, 16) & 0xFF))
-                i = j
-            else:
-                out.append("\\x")
-                i += 2
-        else:
-            out.append("\\")
-            out.append(nxt)
-            i += 2
-    return "".join(out), False
-
-
 def cmd_echo(ctx: BuiltinContext) -> int:
     args = ctx.argv[1:]
     newline = True
     interpret = False
-    idx = 0
-    while idx < len(args):
-        arg = args[idx]
-        if arg == "--":
-            idx += 1
-            break
-        if arg == "-n":
-            newline = False
-            idx += 1
-            continue
-        if arg == "-e":
-            interpret = True
-            idx += 1
-            continue
-        if arg == "-E":
-            interpret = False
-            idx += 1
-            continue
-        if arg.startswith("-") and arg != "-" and all(c in "neE" for c in arg[1:]) and len(arg) > 1:
-            for c in arg[1:]:
-                if c == "n":
-                    newline = False
-                elif c == "e":
-                    interpret = True
-                elif c == "E":
-                    interpret = False
-            idx += 1
-            continue
-        break
-    words = args[idx:]
+    option_args, words = split_leading_short_options(args, "neE")
+    for option in option_args:
+        for char in option[1:]:
+            if char == "n":
+                newline = False
+            elif char == "e":
+                interpret = True
+            else:
+                interpret = False
     text = " ".join(words)
     if interpret:
-        decoded, stop = _decode_backslash_escapes(text, allow_c=True)
+        decoded, stop = decode_backslash_escapes(text, ECHO_ESCAPES)
         text = decoded
         if stop:
             _write(ctx, text)
@@ -139,11 +46,6 @@ def cmd_echo(ctx: BuiltinContext) -> int:
     return 0
 
 
-def _printf_format_escapes(fmt: str) -> str:
-    decoded, _ = _decode_backslash_escapes(fmt, allow_c=False)
-    return decoded
-
-
 def _printf_one(fmt: str, args: list[str]) -> tuple[str, list[str], bool]:
     """Process one FORMAT pass, consuming from args as %-conversions are hit."""
     out: list[str] = []
@@ -210,7 +112,7 @@ def cmd_printf(ctx: BuiltinContext) -> int:
     if not args:
         raise UnsupportedConstruct("unsupported-flag", "printf: FORMAT operand required")
     fmt_raw = args[0]
-    fmt = _printf_format_escapes(fmt_raw)
+    fmt, _ = decode_backslash_escapes(fmt_raw, PRINTF_ESCAPES)
     remaining = args[1:]
     had_error = False
     if not remaining:
@@ -321,17 +223,9 @@ _INT_BINARY = {"-eq", "-ne", "-lt", "-le", "-gt", "-ge"}
 _PATH_UNARY_OPS = {"-e", "-f", "-d", "-r", "-w", "-x", "-s"}
 
 
-def _resolve(cwd: str, path: str) -> str:
-    """Resolve `path` against `cwd` (see commands/fs.py's `_resolve`: main.py never os.chdir()s
-    to the request cwd, so every relative path operand must resolve against ctx.cwd here too)."""
-    if os.path.isabs(path):
-        return os.path.normpath(path)
-    return os.path.normpath(os.path.join(cwd, path))
-
-
 def _eval_unary(op: str, operand: str, cwd: str) -> bool:
     if op in _PATH_UNARY_OPS:
-        operand = _resolve(cwd, operand)
+        operand = resolve_request_path(cwd, operand)
     if op == "-e":
         return os.path.exists(operand)
     if op == "-f":