@hcflabs/pi-subagent 27.11.0 → 28.1.0

package/README.md

@@ -108,7 +108,11 @@ When Pi runs in a parent directory that holds many repositories, set `repo` to s
 
 The worker opens in the current Herdr workspace with the Repository target as its working directory. Change reports and stale-read checks use that checkout, and each result names its `repo`. A write request reserves the checkout of each target at one time, so writers in different repositories can run together. When Pi runs in a parent directory that is not a Git repository, each Main call that can write covers the whole parent. Such a call waits while a direct writer owns the checkout of any Repository target in it. Main can still read files and use `subagent_repos`.
 
-Isolated mode does not accept `repo` yet.
+An isolated request accepts one `repo` for the whole graph. Tasks cannot select another repository. The request then uses the Repository target as its checkout. State, worker worktrees, validation, and promotion belong to that repository. The Pi working directory does not change.
+
+Your Herdr workspace can belong to another checkout or to none. Herdr opens the primary workspace of the target when it opens the first worker worktree, and it does not close that workspace later. Pass the same `repo` to `subagent_status`, `subagent_resume`, `subagent_stage`, `subagent_integrate`, and `subagent_abort`.
+
+Run `/subagent` in a parent directory that is not a Git repository. It lists the isolated requests of each Repository target below it, with their `repo`. `/subagent recover` recovers each Repository target that has saved requests. `/subagent prune` still needs a Git checkout.
 
 To continue a finished worker, add `"continueFrom": "D7.1"` with the same `role`. This opens a new tab with the saved conversation and a new reference. Continue the newest reference from the original checkout and workspace. For a worker that ran with `repo`, select the same `repo`. For eligibility and stop behavior, see [Continue or stop one direct worker](./docs/orchestration.md#continue-or-stop-one-direct-worker).
 
@@ -153,7 +157,7 @@ Use isolated mode for checked implementation. An isolated request has one durabl
 }
 ```
 
-`dependsOn` controls scheduling. `contextFrom` also schedules dependencies and supplies completed text outputs in order. Do not repeat a task in both fields. Changesets require focused checks; graphs with changesets require final checks. The canonical root `package.json` must have a test script. The runner adds `pnpm test` to final checks if absent.
+`dependsOn` controls scheduling. `contextFrom` also schedules dependencies and supplies completed text outputs in order. Do not repeat a task in both fields. Changesets require focused checks; graphs with changesets require final checks. Admission selects one Full suite for the repository and adds it to the final checks if absent. See [Full suite](#full-suite).
 
 Workers use Main's pinned committed branch, HEAD, and tree, not staged, unstaged, or untracked edits. Branch or HEAD changes block new waves. Candidates must be committed with no tracked or untracked changes. Ignored generated files permit candidacy but prevent automatic cleanup.
 
@@ -174,6 +178,24 @@ Reuse assumes that checks use only tracked content. Ignored files, for example `
 
 The extension sends follow-ups when a candidate becomes ready, a worker needs attention, and the wave finishes. A missed follow-up does not authorize replay. Read [Isolated contract](./docs/orchestration.md#isolated-contract) and [Exact integration actions](./docs/orchestration.md#exact-integration-actions) for graph, judgment, revision, refresh, and release details.
 
+### Full suite
+
+Each isolated request with a changeset task must pass one Full suite on the combined tip before promotion. Admission selects it in this order:
+
+1. The `repoSuites` entry for the repository in the config file.
+2. `pnpm test`, when the root `package.json` has a non-empty `scripts.test`.
+3. `make test`, when the root `GNUmakefile`, `makefile`, or `Makefile` declares a literal `test` target, such as `test:` or `test::`.
+
+If no source applies, the request fails before it saves state. A read or parse error also fails. It never counts as an absent source. The extension reads the Makefile as text and never runs Make to find targets, because Make can run repository code. Generated, included, or pattern targets are not found. Use `repoSuites` for them:
+
+```json
+{ "repoSuites": { "/home/me/code/service": { "command": "uv", "args": ["run", "pytest", "-q"] } } }
+```
+
+The key is the absolute path of the primary checkout. Two keys for the same checkout block the request. The command runs without a shell. To use a shell, name it as the command.
+
+Admission saves the selected suite and its source with the request. Validation, resume, and recovery use the saved suite, so a later config change does not change an admitted request. Validation rejects a combined tip that changes the selected `package.json` test script or Makefile. A dry run shows the selected suite.
+
 ### Inspect work
 
 Open `/subagent` to browse direct work on this session branch and isolated requests in the current canonical Git checkout, including other sessions. The menu groups rows under **Direct**, **Isolated**, and **Orphaned** headers. Each isolated row shows the request ID, the status, and a short goal summary. **Refresh** or a header reloads saved status without recovery or mutation. Invalid state IDs stay preserved with a warning. Direct recovery remains available outside Git or without isolated inventory.
@@ -217,6 +239,7 @@ Package-owned: `~/.pi/agent/config/pi-subagent/config.json`. Missing files silen
 | `timeout.idleMinutes` | Direct worker and ephemeral child idle timeout | Positive; within Node's timer range | `10` |
 | `timeout.maxMinutes` | Ephemeral child hard runtime | Greater than idle; within Node's timer range | `30` |
 | `roleDefaults` | Shared resources for built-in and user Roles | Object with `extensions`, `tools`, or `skills` arrays; same validation as Role fields | — |
+| `repoSuites` | Full suite for isolated changesets in one repository | Object keyed by the absolute path of the primary checkout. Each value is `{ "command": "<executable>", "args": [...] }` | — |
 
 `roleDefaults` entries precede Role entries; merging removes duplicates before resource resolution. Use it for a provider extension that every child needs. Limits come only from this file. Requests cannot override or replenish them. Durable requests keep recorded policy; a lower current correction limit can tighten recovery. There is no whole-run timeout.
 
@@ -225,6 +248,7 @@ The extension reports each new problem once per session. It reads config at laun
 - Unknown keys warn and are ignored. A likely misspelling, such as `maxToken` for missing `maxTokens`, counts as invalid for that key.
 - Invalid `maxSubagents`, `maxTurns`, `maxCorrections`, or `timeout` values warn and use finite defaults. If maximum timeout does not exceed idle timeout, the whole `timeout` uses defaults.
 - Unknown or invalid `roleDefaults` keys warn; only those keys are ignored, so Roles receive fewer default resources.
+- An invalid `repoSuites` value blocks delegation. One bad entry blocks the whole value, so a bad entry cannot select a different Full suite.
 - Invalid or misspelled `maxTokens` blocks delegation. Malformed JSON, invalid UTF-8, files above 64 KiB, and unreadable files also block delegation. The extension does not fall back to unlimited tokens.
 
 `/subagent` remains available during a block. Correct the file to enable delegation. The next worker or isolated Role launch fails while the block remains; running workers retain their original limits. If the problem existed at session start, also run `/reload`, because that session took default execution limits.
@@ -281,7 +305,7 @@ The executor accepts concurrency, turn/token, idle/hard-runtime limits, and abor
 
 Private durable state lives under `config/pi-subagent/state/`. Isolated worker sessions use mode `0600` under `config/pi-subagent/leases/`; worker umask stays unchanged. Reads stop at 16 MiB. Larger sessions require inspection and cannot prove completion.
 
-Sessions are removed only after exact worker-tab cleanup. They can contain prompts and answers: do not share them. State v5 rejects v4 and older files without migration. Preserve old state and recover its work manually.
+Sessions are removed only after exact worker-tab cleanup. They can contain prompts and answers: do not share them. State v6 rejects v5 and older files without migration. An unfinished v4 or v5 request blocks new isolated work in its repository. Finish or recover isolated requests with the earlier version before you upgrade. Preserve old state and recover its work manually.
 
 ## Limits and recovery
 

package/dist/full-suite.d.ts

@@ -0,0 +1,34 @@
+import type { AdmittedFullSuite, CheckCommand } from "./schema.ts";
+export type { AdmittedFullSuite };
+/** Make reads the first of these files that exists. */
+declare const MAKEFILE_NAMES: readonly ["GNUmakefile", "makefile", "Makefile"];
+/** The root `package.json` test script, or `undefined` when the file or the script is absent. A malformed file throws. */
+export declare function packageTestScript(root: string): string | undefined;
+/**
+ * Return true when the Makefile text declares a literal `test` target, for example `test:` or `test check::`.
+ * This is a static check. It never runs Make, because Make can run repository code while it reads a file.
+ * Generated, included, or pattern targets are not found. Configure `repoSuites` for them.
+ */
+export declare function declaresMakeTest(text: string): boolean;
+/** The Makefile that Make would read in `root`, with its content hash. `undefined` when no Makefile exists. */
+export declare function makefileIdentity(root: string): {
+    file: (typeof MAKEFILE_NAMES)[number];
+    text: string;
+    sha256: string;
+} | undefined;
+/**
+ * Select the Full suite for `root`. The order is: the configured suite, then `pnpm test` when the root
+ * `package.json` has a non-empty `scripts.test`, then `make test` when the root Makefile declares `test`.
+ * A read or parse error throws. It never counts as an absent source.
+ */
+export declare function resolveFullSuite(root: string, configured?: CheckCommand): AdmittedFullSuite;
+/** Throw when the checkout at `root` changed the source of an admitted Full suite. A configured suite has no source file. */
+export declare function assertFullSuiteSource(suite: AdmittedFullSuite, root: string): void;
+export declare const sameCheck: (left: CheckCommand, right: CheckCommand) => boolean;
+/** A human-readable source label for plans and status. */
+export declare function describeFullSuite(suite: AdmittedFullSuite): string;
+/**
+ * The `repoSuites` entry for the primary checkout `primary`. Keys are compared by real path.
+ * Two keys for the same checkout throw, because the choice between them is not defined.
+ */
+export declare function configuredSuiteFor(repoSuites: Readonly<Record<string, CheckCommand>>, primary: string): CheckCommand | undefined;

package/dist/full-suite.js

@@ -0,0 +1,142 @@
+import { createHash } from "node:crypto";
+import { readdirSync, readFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+/** Make reads the first of these files that exists. */
+const MAKEFILE_NAMES = ["GNUmakefile", "makefile", "Makefile"];
+const MANIFEST_MAX_BYTES = 1024 * 1024;
+function readOptional(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return undefined;
+        throw new Error(`Full suite detection cannot read ${path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    if (Buffer.byteLength(text, "utf8") > MANIFEST_MAX_BYTES)
+        throw new Error(`Full suite detection refuses ${path}: the file is larger than 1 MiB.`);
+    return text;
+}
+/** The root `package.json` test script, or `undefined` when the file or the script is absent. A malformed file throws. */
+export function packageTestScript(root) {
+    const path = join(root, "package.json");
+    const text = readOptional(path);
+    if (text === undefined)
+        return undefined;
+    let manifest;
+    try {
+        manifest = JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`Full suite detection cannot parse ${path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    if (!manifest || typeof manifest !== "object" || Array.isArray(manifest))
+        throw new Error(`Full suite detection found no JSON object in ${path}.`);
+    const scripts = manifest.scripts;
+    if (scripts === undefined)
+        return undefined;
+    if (!scripts || typeof scripts !== "object" || Array.isArray(scripts))
+        throw new Error(`Full suite detection found a malformed scripts field in ${path}.`);
+    const test = scripts.test;
+    if (test === undefined)
+        return undefined;
+    if (typeof test !== "string")
+        throw new Error(`Full suite detection found a test script that is not text in ${path}.`);
+    return test.trim() ? test : undefined;
+}
+/**
+ * Return true when the Makefile text declares a literal `test` target, for example `test:` or `test check::`.
+ * This is a static check. It never runs Make, because Make can run repository code while it reads a file.
+ * Generated, included, or pattern targets are not found. Configure `repoSuites` for them.
+ */
+export function declaresMakeTest(text) {
+    let continued = false;
+    for (const line of text.split(/\r?\n/)) {
+        const previous = continued;
+        continued = /(^|[^\\])(\\\\)*\\$/.test(line);
+        // Recipe lines start with a tab. Continuation lines belong to the line before them.
+        if (previous || line.startsWith("\t"))
+            continue;
+        const rule = /^([^#:=]+?)::?(?![=:])/.exec(line);
+        if (!rule)
+            continue;
+        if (rule[1].trim().split(/\s+/).includes("test"))
+            return true;
+    }
+    return false;
+}
+/** The Makefile that Make would read in `root`, with its content hash. `undefined` when no Makefile exists. */
+export function makefileIdentity(root) {
+    // Compare exact names. A case-insensitive file system would otherwise report Makefile as makefile.
+    let names;
+    try {
+        names = new Set(readdirSync(root));
+    }
+    catch (error) {
+        throw new Error(`Full suite detection cannot list ${root}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    for (const file of MAKEFILE_NAMES) {
+        if (!names.has(file))
+            continue;
+        const text = readOptional(join(root, file));
+        if (text !== undefined)
+            return { file, text, sha256: createHash("sha256").update(text).digest("hex") };
+    }
+    return undefined;
+}
+/**
+ * Select the Full suite for `root`. The order is: the configured suite, then `pnpm test` when the root
+ * `package.json` has a non-empty `scripts.test`, then `make test` when the root Makefile declares `test`.
+ * A read or parse error throws. It never counts as an absent source.
+ */
+export function resolveFullSuite(root, configured) {
+    if (configured)
+        return { check: { command: configured.command, args: [...configured.args] }, source: { kind: "config" } };
+    const testScript = packageTestScript(root);
+    if (testScript !== undefined)
+        return { check: { command: "pnpm", args: ["test"] }, source: { kind: "package-json", testScript } };
+    const makefile = makefileIdentity(root);
+    if (makefile && declaresMakeTest(makefile.text)) {
+        return { check: { command: "make", args: ["test"] }, source: { kind: "makefile", file: makefile.file, sha256: makefile.sha256 } };
+    }
+    throw new Error(`No Full suite is available for ${root}. Configure repoSuites in config/pi-subagent/config.json, add a package.json scripts.test, or add a Makefile test target.`);
+}
+/** Throw when the checkout at `root` changed the source of an admitted Full suite. A configured suite has no source file. */
+export function assertFullSuiteSource(suite, root) {
+    const { source } = suite;
+    if (source.kind === "package-json" && packageTestScript(root) !== source.testScript) {
+        throw new Error("Combined tip changed the admitted root package.json test script.");
+    }
+    if (source.kind === "makefile") {
+        const makefile = makefileIdentity(root);
+        if (makefile?.file !== source.file || makefile.sha256 !== source.sha256)
+            throw new Error(`Combined tip changed the admitted root ${source.file}.`);
+    }
+}
+export const sameCheck = (left, right) => left.command === right.command && left.args.length === right.args.length && left.args.every((arg, index) => arg === right.args[index]);
+/** A human-readable source label for plans and status. */
+export function describeFullSuite(suite) {
+    const command = [suite.check.command, ...suite.check.args].join(" ");
+    return suite.source.kind === "config" ? `${command} (from repoSuites config)`
+        : suite.source.kind === "package-json" ? `${command} (from package.json scripts.test)`
+            : `${command} (from ${suite.source.file} test target)`;
+}
+/**
+ * The `repoSuites` entry for the primary checkout `primary`. Keys are compared by real path.
+ * Two keys for the same checkout throw, because the choice between them is not defined.
+ */
+export function configuredSuiteFor(repoSuites, primary) {
+    const matches = Object.entries(repoSuites).filter(([key]) => {
+        try {
+            return realpathSync.native(key) === primary;
+        }
+        catch {
+            return key === primary;
+        }
+    });
+    if (matches.length > 1)
+        throw new Error(`repoSuites has ${matches.length} entries for ${primary}: ${matches.map(([key]) => key).join(", ")}. Keep one entry.`);
+    return matches[0]?.[1];
+}

package/dist/herdr-runtime.d.ts

@@ -38,9 +38,15 @@ export declare class HerdrHostRuntime implements HostRuntime {
     private readonly lsofCommand;
     private readonly executionBudget?;
     constructor(options: HerdrHostRuntimeOptions);
-    /** Fail-closed Herdr caller/capability gate. This method creates no state or host resource. */
+    /**
+     * Fail-closed Herdr caller/capability gate. This method creates no state or host resource.
+     * Without `targeted`, the caller's workspace must be the checkout `root`. With `targeted`, `root` is a
+     * Repository target, and the caller's workspace can belong to any checkout or to none.
+     * Herdr opens the primary workspace of the target when it opens an owned worktree.
+     */
     preflightHost(input: {
         root: string;
+        targeted?: boolean;
     }, context: OperationContext): Promise<void>;
     planHostAllocation(input: {
         readonly requestId: ExecuteRequest["id"];

package/dist/herdr-runtime.js

@@ -270,7 +270,12 @@ export class HerdrHostRuntime {
         this.lsofCommand = options.lsofCommand ?? "lsof";
         this.executionBudget = options.executionBudget;
     }
-    /** Fail-closed Herdr caller/capability gate. This method creates no state or host resource. */
+    /**
+     * Fail-closed Herdr caller/capability gate. This method creates no state or host resource.
+     * Without `targeted`, the caller's workspace must be the checkout `root`. With `targeted`, `root` is a
+     * Repository target, and the caller's workspace can belong to any checkout or to none.
+     * Herdr opens the primary workspace of the target when it opens an owned worktree.
+     */
     async preflightHost(input, context) {
         context.signal.throwIfAborted();
         if (this.env.HERDR_ENV !== "1")
@@ -306,6 +311,11 @@ export class HerdrHostRuntime {
         const workspaceId = exactString(pane.workspace_id, "Herdr current workspace_id");
         const workspaceResponse = await this.herdr.json(["workspace", "get", workspaceId], this.processOptions(root, context, HERDR_OPERATION_CAP_MS));
         const workspace = parseWorkspaceInfo(workspaceResponse, workspaceId);
+        if (input.targeted) {
+            // The worker worktrees open from the primary checkout of the target, not from the caller's workspace.
+            await this.repositoryIdentity(root, context);
+            return;
+        }
         const worktree = record(workspace.worktree, "Herdr current workspace worktree");
         const checkout = await realpath(exactString(worktree.checkout_path, "Herdr current checkout_path"));
         if (checkout !== root)

package/dist/index.d.ts

@@ -94,6 +94,16 @@ export interface ResolvedRoleSkills {
 export declare function parseRoleName(value: unknown, source?: string): RoleName;
 /** Validate `config.json` `roleDefaults` with the same rules as Role fields; `label` prefixes errors. */
 export declare function parseRoleDefaults(value: unknown, label?: string): RoleDefaults;
+/** A configured Full suite: one executable and its argument list. No shell runs unless the executable is a shell. */
+export interface RepoSuite {
+    command: string;
+    args: string[];
+}
+/**
+ * Strict `repoSuites`: any bad entry makes the whole value invalid, and the field disables delegation.
+ * Dropping one bad entry could select a different Full suite without notice.
+ */
+export declare function parseRepoSuites(raw: unknown): Record<string, RepoSuite>;
 export interface SubagentConfig {
     maxSubagents: number;
     maxTurns: number;
@@ -104,6 +114,8 @@ export interface SubagentConfig {
         maxMinutes: number;
     };
     roleDefaults: RoleDefaults;
+    /** Full suite overrides for isolated changesets, keyed by absolute primary checkout path. */
+    repoSuites: Record<string, RepoSuite>;
 }
 export declare const DEFAULT_SUBAGENT_CONFIG: Readonly<SubagentConfig>;
 /**
@@ -121,6 +133,7 @@ export declare function createSubagentConfigStore(agentDir?: string): import("@h
         maxMinutes: number;
     }>;
     roleDefaults: import("@hcflabs/pi-config-store").Field<RoleDefaults>;
+    repoSuites: import("@hcflabs/pi-config-store").Field<Record<string, RepoSuite>>;
 }>>;
 /**
  * Report `roleDefaults` issues at each session start, and return a function that reports them after a lazy

package/dist/index.js

@@ -194,6 +194,41 @@ const roleDefaultsField = (raw, report) => {
     }
     return defaults;
 };
+const MAX_REPO_SUITES = 200;
+const MAX_SUITE_ARGS = 128;
+const MAX_SUITE_TEXT = 16_000;
+/**
+ * Strict `repoSuites`: any bad entry makes the whole value invalid, and the field disables delegation.
+ * Dropping one bad entry could select a different Full suite without notice.
+ */
+export function parseRepoSuites(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new Error("must be a JSON object keyed by absolute primary checkout paths");
+    const entries = Object.entries(raw);
+    if (entries.length > MAX_REPO_SUITES)
+        throw new Error(`has ${entries.length} entries; the limit is ${MAX_REPO_SUITES}`);
+    const suites = {};
+    for (const [key, value] of entries) {
+        const label = JSON.stringify(key);
+        if (!isAbsolute(key) || key.length > 4096 || /[\u0000-\u001f\u007f]/.test(key))
+            throw new Error(`key ${label} must be an absolute path without control characters`);
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error(`${label} must be an object with command and args`);
+        for (const field of Object.keys(value)) {
+            if (field !== "command" && field !== "args")
+                throw new Error(`${label} has unknown key ${JSON.stringify(field)}; expected command and args`);
+        }
+        const { command, args } = value;
+        if (typeof command !== "string" || !command.trim() || command !== command.trim() || command.length > MAX_SUITE_TEXT || /[\u0000-\u001f\u007f]/.test(command)) {
+            throw new Error(`${label}.command must be one executable name or path without spaces at the ends or control characters`);
+        }
+        if (!Array.isArray(args) || args.length > MAX_SUITE_ARGS || args.some((arg) => typeof arg !== "string" || arg.length > MAX_SUITE_TEXT || arg.includes("\0"))) {
+            throw new Error(`${label}.args must be a list of at most ${MAX_SUITE_ARGS} strings without NUL`);
+        }
+        suites[key] = { command, args: [...args] };
+    }
+    return suites;
+}
 export const DEFAULT_SUBAGENT_CONFIG = Object.freeze({
     maxSubagents: 5,
     maxTurns: DEFAULT_MAX_TURNS,
@@ -201,6 +236,7 @@ export const DEFAULT_SUBAGENT_CONFIG = Object.freeze({
     maxCorrections: 1,
     timeout: Object.freeze({ idleMinutes: 10, maxMinutes: 30 }),
     roleDefaults: Object.freeze({}),
+    repoSuites: Object.freeze({}),
 });
 const timeoutMinutes = parsers.number({ greaterThan: 0, max: 2_147_483_647 / 60_000 });
 const timeoutField = (raw, report) => {
@@ -229,6 +265,7 @@ export function createSubagentConfigStore(agentDir = getAgentDir()) {
             maxCorrections: field(parsers.integer({ min: 0 }), DEFAULT_SUBAGENT_CONFIG.maxCorrections),
             timeout: field(timeoutField, DEFAULT_SUBAGENT_CONFIG.timeout),
             roleDefaults: field(roleDefaultsField, DEFAULT_SUBAGENT_CONFIG.roleDefaults),
+            repoSuites: field((raw) => parseRepoSuites(raw), DEFAULT_SUBAGENT_CONFIG.repoSuites, { onInvalid: "disable" }),
         },
     });
 }

package/dist/launch-runtime.d.ts

@@ -16,6 +16,7 @@ export interface LaunchRuntimeOptions {
         request: ExecuteRequest;
         cwd: string;
         root: string;
+        targeted?: boolean;
     }, context: OperationContext): Promise<void>;
     inspectMainBase(input: {
         root: string;
@@ -44,6 +45,7 @@ export declare class RoleLaunchRuntime implements CoordinatorRuntime {
         request: ExecuteRequest;
         cwd: string;
         dryRun?: boolean;
+        targeted?: boolean;
     }, context: OperationContext): Promise<{
         root: string;
         main: WorkspaceIdentity;

package/dist/launch-runtime.js

@@ -140,12 +140,15 @@ export class RoleLaunchRuntime {
         const root = await realpath(resolvedRoot);
         if (root !== resolvedRoot)
             throw new Error("Pi Subagent root resolver returned a non-canonical path.");
+        // A Repository target must still be its own Git top-level directory before the host gate runs.
+        if (input.targeted && root !== await realpath(input.cwd))
+            throw new Error(`Repository target ${input.cwd} now resolves to ${root}; nothing was saved. Retry the request.`);
         const rootInfo = await lstat(root);
         if (!rootInfo.isDirectory())
             throw new Error("Pi Subagent root must be an existing local directory.");
         context.signal?.throwIfAborted();
         if (!input.dryRun && input.request.tasks.some((task) => task.kind === "changeset")) {
-            await this.options.preflightHost?.({ request: input.request, cwd: input.cwd, root }, context);
+            await this.options.preflightHost?.({ request: input.request, cwd: input.cwd, root, ...(input.targeted ? { targeted: true } : {}) }, context);
         }
         const main = await this.options.inspectMainBase({ root }, context);
         const required = new Map();

package/dist/runner.d.ts

@@ -2,7 +2,7 @@ import { type DiscardGuards, type DiscardPlan } from "./discard.ts";
 import { type EphemeralSubagentExecutor } from "./ephemeral.ts";
 import type { PruneOwnership } from "./prune.ts";
 import { IntegrationGit } from "./integration-git.ts";
-import { type AllocationKind, type CheckCommand, type ChangesetTaskRequest, type CleanupKind, type ExecuteRequest, type ExecutionPolicySnapshot, type HostAllocationIntent, type HostAllocationPlan, type ModelClass, type ReviewEvidence, type ResumeRequest, type RunState, type TaskAttempt, type TaskRequest, type TaskState, type WorktreeAllocationIntent, type WorktreeAllocationPlan, type WorkspaceIdentity } from "./schema.ts";
+import { type AdmittedFullSuite, type AllocationKind, type CheckCommand, type ChangesetTaskRequest, type CleanupKind, type ExecuteRequest, type ExecutionPolicySnapshot, type HostAllocationIntent, type HostAllocationPlan, type ModelClass, type ReviewEvidence, type ResumeRequest, type RunState, type TaskAttempt, type TaskRequest, type TaskState, type WorktreeAllocationIntent, type WorktreeAllocationPlan, type WorkspaceIdentity } from "./schema.ts";
 import { FileRunStore } from "./store.ts";
 /** One durable follow-up per attempt; this instruction permits a worker commit, never discarded work. */
 export declare const COMMIT_NUDGE_INSTRUCTION = "Your turn ended with uncommitted changes in your worktree. Commit the intended changes now so the worktree is clean, or explain in your reply why they must not be committed. Do not discard work.";
@@ -100,6 +100,8 @@ export type ResolvedRoute = Pick<VerifiedLaunch, "role" | "modelClass" | "model"
 /** A dry-run result: the normalized request and the resolved routes; no state exists for it. */
 export interface ExecutePlan {
     request: ExecuteRequest;
+    /** The Full suite for a request with changeset tasks. */
+    fullSuite?: AdmittedFullSuite;
     root: string;
     main: WorkspaceIdentity;
     routes: readonly ResolvedRoute[];
@@ -117,11 +119,15 @@ export declare function withTransientLaunch<Launch extends VerifiedLaunch, Resul
 export interface CoordinatorRuntime {
     now(): number;
     randomToken(): string;
-    /** `dryRun` skips checks that call Herdr; every other check runs. */
+    /**
+     * `dryRun` skips checks that call Herdr; every other check runs.
+     * `targeted` means that `cwd` is a Repository target, so the caller's Herdr workspace can belong to another checkout.
+     */
     preflight(input: {
         request: ExecuteRequest;
         cwd: string;
         dryRun?: boolean;
+        targeted?: boolean;
     }, context: OperationContext): Promise<{
         root: string;
         main: WorkspaceIdentity;
@@ -311,9 +317,11 @@ export declare class IsolatedRunner {
     private readonly integrationGit;
     private readonly textExecutor;
     private readonly currentPolicy;
+    /** The configured `repoSuites`, read at admission only. */
+    private readonly repoSuites;
     private readonly productiveLifecycles;
     private readonly followupControls;
-    constructor(coordinatorRuntime: CoordinatorRuntime, hostRuntime: HostRuntime, gitRuntime: GitRuntime, store: FileRunStore | undefined, textExecutor: EphemeralSubagentExecutor, policy?: ExecutionPolicySnapshot, currentPolicy?: () => ExecutionPolicySnapshot, integrationGit?: IntegrationGit);
+    constructor(coordinatorRuntime: CoordinatorRuntime, hostRuntime: HostRuntime, gitRuntime: GitRuntime, store: FileRunStore | undefined, textExecutor: EphemeralSubagentExecutor, policy?: ExecutionPolicySnapshot, currentPolicy?: () => ExecutionPolicySnapshot, integrationGit?: IntegrationGit, repoSuites?: () => Readonly<Record<string, CheckCommand>>);
     listRequests(root: string): Promise<{
         requests: Array<{
             id: string;
@@ -357,8 +365,13 @@ export declare class IsolatedRunner {
     /** Every execute check before durable state; a dry run also skips the Herdr host preflight. */
     private admitExecute;
     /** Dry run of execute: no state, lock, lease, worktree, or Herdr call. */
-    plan(value: unknown, cwd: string, outerSignal?: AbortSignal): Promise<ExecutePlan>;
-    execute(value: unknown, cwd: string, outerSignal?: AbortSignal): Promise<RunResponse>;
+    /** `options.targeted` marks `cwd` as a Repository target that the caller selected with `repo`. */
+    plan(value: unknown, cwd: string, outerSignal?: AbortSignal, options?: {
+        targeted?: boolean;
+    }): Promise<ExecutePlan>;
+    execute(value: unknown, cwd: string, outerSignal?: AbortSignal, options?: {
+        targeted?: boolean;
+    }): Promise<RunResponse>;
     resume(value: unknown, root: string, outerSignal?: AbortSignal): Promise<RunResponse>;
     /** Main selects an exact retained candidate; only the owned integration checkout is writable. */
     stage(value: unknown, root: string, outerSignal?: AbortSignal): Promise<RunResponse>;
@@ -382,6 +395,20 @@ export declare class IsolatedRunner {
             tasks: never[];
         }[];
     }>;
+    /** Orphaned requests of every primary checkout in one state scan, each with the primary checkout that owns it. */
+    listAllOrphanRequests(): Promise<{
+        invalidIds: string[];
+        requests: {
+            id: string;
+            name: string;
+            status: string;
+            directory: string;
+            root: string;
+            orphaned: true;
+            tasks: never[];
+            primary: string;
+        }[];
+    }>;
     private discardGuards;
     discardPlan(cwd: string, id: string, directory: string | undefined, guards: DiscardGuards): Promise<DiscardPlan>;
     /** Command-only explicit discard. No tool calls this method. */