@hcflabs/pi-subagent 27.11.0 → 28.1.0

package/dist/runner.js

@@ -1,7 +1,8 @@
-import { readFileSync, realpathSync } from "node:fs";
+import { realpathSync } from "node:fs";
 import { dirname } from "node:path";
 import { inspectDiscard, primaryCheckout, removeDiscardResources } from "./discard.js";
 import { utf8Prefix } from "./ephemeral.js";
+import { assertFullSuiteSource, configuredSuiteFor, resolveFullSuite, sameCheck } from "./full-suite.js";
 import { createChildWorktree, finalizeChildWorktree, inspectWorktreeDirty } from "./worktree.js";
 import { runGit } from "./git-process.js";
 import { IntegrationGit } from "./integration-git.js";
@@ -19,23 +20,8 @@ export const CLEANUP_SAFETY_BUDGET_MS = 30_000;
 export const TERMINATION_SAFETY_BUDGET_MS = 15_000;
 export const STATUS_INSPECTION_BUDGET_MS = 5_000;
 const ALLOCATION_KINDS = ["worktree", "workspace", "worker_tab", "agent"];
-const FULL_SUITE = { command: "pnpm", args: ["test"] };
 const MAX_RETAINED_INTEGRATION_GENERATIONS = 2;
-function requireRootSuite(root) {
-    let manifest;
-    try {
-        manifest = JSON.parse(readFileSync(`${root}/package.json`, "utf8"));
-    }
-    catch {
-        throw new Error("Canonical root package.json with a test script is required for isolated changesets.");
-    }
-    if (!manifest || typeof manifest !== "object" || !('scripts' in manifest)
-        || !manifest.scripts || typeof manifest.scripts !== "object"
-        || !('test' in manifest.scripts) || typeof manifest.scripts.test !== "string"
-        || !manifest.scripts.test.trim())
-        throw new Error("Canonical root test script is missing.");
-    return manifest.scripts.test;
-}
+const MAX_FINAL_CHECKS = 32;
 /** Run one launch action and surface cleanup failure, including after action failure or abort. */
 export async function withTransientLaunch(handle, operation) {
     let failed = false;
@@ -616,12 +602,15 @@ export class IsolatedRunner {
     integrationGit;
     textExecutor;
     currentPolicy;
+    /** The configured `repoSuites`, read at admission only. */
+    repoSuites;
     productiveLifecycles = new Map();
     followupControls = new Map();
     constructor(coordinatorRuntime, hostRuntime, gitRuntime, store = new FileRunStore(), textExecutor, policy = {
         maxSubagents: 5, maxTurns: 50, childIdleMs: 600_000, childMaxMs: 1_800_000,
         maxCorrections: 1,
-    }, currentPolicy = () => policy, integrationGit = new IntegrationGit()) {
+    }, currentPolicy = () => policy, integrationGit = new IntegrationGit(), repoSuites = () => ({})) {
+        this.repoSuites = repoSuites;
         this.coordinatorRuntime = coordinatorRuntime;
         this.hostRuntime = hostRuntime;
         this.gitRuntime = gitRuntime;
@@ -825,19 +814,30 @@ export class IsolatedRunner {
             throw error;
     }
     /** Every execute check before durable state; a dry run also skips the Herdr host preflight. */
-    async admitExecute(value, cwd, scope, dryRun) {
+    async admitExecute(value, cwd, scope, dryRun, targeted) {
         const request = parseExecuteRequest(value);
         const policy = Object.freeze({ ...this.currentPolicy() });
         const canonicalCwd = realpathSync.native(cwd);
-        const prepared = await scope.call(async (context) => await this.coordinatorRuntime.preflight({ request, cwd: canonicalCwd, ...(dryRun ? { dryRun } : {}) }, context));
+        const prepared = await scope.call(async (context) => await this.coordinatorRuntime.preflight({
+            request, cwd: canonicalCwd, ...(dryRun ? { dryRun } : {}), ...(targeted ? { targeted } : {}),
+        }, context));
         const root = realpathSync.native(prepared.root);
         if (root !== prepared.root)
             throw new Error("Preflight repository root must be canonical.");
+        // A Repository target is its own root. A different root means the checkout changed after the target check.
+        if (targeted && root !== canonicalCwd)
+            throw new Error(`Repository target ${canonicalCwd} now resolves to ${root}; nothing was saved. Retry the request.`);
+        let fullSuite;
         if (request.tasks.some((task) => task.kind === "changeset")) {
-            requireRootSuite(root);
-            if (!request.finalChecks.some((check) => check.command === FULL_SUITE.command
-                && check.args.length === 1 && check.args[0] === FULL_SUITE.args[0])) {
-                request.finalChecks = [FULL_SUITE, ...request.finalChecks];
+            // Main is clean and committed here, so the working files are the committed sources.
+            const repoSuites = this.repoSuites();
+            const configured = Object.keys(repoSuites).length ? configuredSuiteFor(repoSuites, await primaryCheckout(root)) : undefined;
+            fullSuite = resolveFullSuite(root, configured);
+            if (!request.finalChecks.some((check) => sameCheck(check, fullSuite.check))) {
+                if (request.finalChecks.length >= MAX_FINAL_CHECKS) {
+                    throw new Error(`The Full suite ${formatCheckCommand(fullSuite.check)} cannot be added: the request already has ${MAX_FINAL_CHECKS} final checks.`);
+                }
+                request.finalChecks = [fullSuite.check, ...request.finalChecks];
             }
         }
         const preparedMain = runtimeIdentity(prepared.main, "Preflight Main identity");
@@ -846,22 +846,24 @@ export class IsolatedRunner {
         if (this.hasAnyActiveControl(root)) {
             throw new Error("Another Pi Subagent request has active changeset work in this repository.");
         }
-        return { request, policy, root, preparedMain, routes: prepared.routes ?? [] };
+        return { request, policy, root, preparedMain, routes: prepared.routes ?? [], ...(fullSuite ? { fullSuite } : {}) };
     }
     /** Dry run of execute: no state, lock, lease, worktree, or Herdr call. */
-    async plan(value, cwd, outerSignal) {
-        const { request, root, preparedMain, routes } = await this.admitExecute(value, cwd, new ProductiveScope(outerSignal), true);
-        return { request, root, main: preparedMain, routes };
+    /** `options.targeted` marks `cwd` as a Repository target that the caller selected with `repo`. */
+    async plan(value, cwd, outerSignal, options = {}) {
+        const { request, root, preparedMain, routes, fullSuite } = await this.admitExecute(value, cwd, new ProductiveScope(outerSignal), true, options.targeted === true);
+        return { request, root, main: preparedMain, routes, ...(fullSuite ? { fullSuite } : {}) };
     }
-    async execute(value, cwd, outerSignal) {
+    async execute(value, cwd, outerSignal, options = {}) {
         const scope = new ProductiveScope(outerSignal);
-        const { request, policy, root, preparedMain } = await this.admitExecute(value, cwd, scope, false);
+        const { request, policy, root, preparedMain, fullSuite } = await this.admitExecute(value, cwd, scope, false, options.targeted === true);
         return await this.withProductiveRun(root, async (lifecycle) => {
             const createdAt = this.coordinatorRuntime.now();
             const state = {
                 version: RUN_STATE_VERSION,
                 request,
                 policy,
+                ...(fullSuite ? { fullSuite } : {}),
                 correctionCount: 0,
                 root,
                 requestStartMain: preparedMain,
@@ -1478,12 +1480,12 @@ export class IsolatedRunner {
                 generation.status = "validating";
                 await this.saveProductive(handle); // Record the exact validation intent before running checks.
                 try {
-                    if (!request.finalChecks.some((check) => check.command === FULL_SUITE.command
-                        && check.args.length === 1 && check.args[0] === FULL_SUITE.args[0]))
-                        throw new Error("Canonical full-suite command was not recorded at admission.");
-                    if (requireRootSuite(generation.worktree.path) !== requireRootSuite(root)) {
-                        throw new Error("Combined tip changed the admitted canonical root test script.");
+                    const fullSuite = state.fullSuite;
+                    if (!fullSuite || !request.finalChecks.some((check) => sameCheck(check, fullSuite.check))) {
+                        throw new Error("The Full suite was not recorded at admission.");
                     }
+                    // The saved suite runs as admitted. A later config edit does not change it.
+                    assertFullSuiteSource(fullSuite, generation.worktree.path);
                     await this.requireExactIntegration(handle, generation, receipts, scope);
                     const sources = stagedCheckSources(generation, state.integration.candidates);
                     const checks = await this.runCheckBatch(handle, request.finalChecks, action.expectedTip, "final", scope, undefined, generation.worktree.path, request.finalChecks.map((check) => reusableCheckSource(check, action.expectedTip, sources)));
@@ -1792,6 +1794,14 @@ export class IsolatedRunner {
                 directory: dirname(handle.path), root: handle.state.root, orphaned: true, tasks: [],
             })) };
     }
+    /** Orphaned requests of every primary checkout in one state scan, each with the primary checkout that owns it. */
+    async listAllOrphanRequests() {
+        const { states, invalidIds, primaries } = await this.store.listOrphans();
+        return { invalidIds, requests: states.map((handle) => ({
+                id: handle.state.request.id, name: handle.state.request.goal, status: inventoryStatus(handle.state, true),
+                directory: dirname(handle.path), root: handle.state.root, orphaned: true, tasks: [], primary: primaries.get(handle),
+            })) };
+    }
     discardGuards(directory, root, guards) {
         return { ...guards, blocked: async () => {
                 if (this.productiveLifecycles.has(root))

package/dist/schema.d.ts

@@ -1,5 +1,5 @@
 import { Type, type Static } from "typebox";
-export declare const RUN_STATE_VERSION = 5;
+export declare const RUN_STATE_VERSION = 6;
 export declare const MAX_TASKS = 8;
 export declare const MAX_EXECUTE_REQUEST_BYTES: number;
 export declare const MAX_PERSISTED_RUNTIME_TEXT_BYTES: number;
@@ -10,6 +10,24 @@ export declare const CheckCommandSchema: Type.TObject<{
     command: Type.TString;
     args: Type.TArray<Type.TString>;
 }>;
+/** The Full suite fixed at admission, with its source. Validation checks the same source again. */
+export declare const FullSuiteSchema: Type.TObject<{
+    check: Type.TObject<{
+        command: Type.TString;
+        args: Type.TArray<Type.TString>;
+    }>;
+    source: Type.TUnion<[Type.TObject<{
+        kind: Type.TLiteral<"config">;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"package-json">;
+        testScript: Type.TString;
+    }>, Type.TObject<{
+        kind: Type.TLiteral<"makefile">;
+        file: Type.TUnion<[Type.TLiteral<"GNUmakefile">, Type.TLiteral<"makefile">, Type.TLiteral<"Makefile">]>;
+        sha256: Type.TString;
+    }>]>;
+}>;
+export type AdmittedFullSuite = Static<typeof FullSuiteSchema>;
 /** One display form for a check command; quoted args keep argv boundaries visible. */
 export declare function formatCheckCommand({ command, args }: {
     command: string;
@@ -1756,7 +1774,7 @@ export type IntegrationState = Static<typeof IntegrationStateSchema>;
 declare const TerminalRunStatusSchema: Type.TUnion<[Type.TLiteral<"completed">, Type.TLiteral<"final_failed">, Type.TLiteral<"superseded">, Type.TLiteral<"aborted">]>;
 export declare const TERMINAL_RUN_STATUSES: readonly Static<typeof TerminalRunStatusSchema>[];
 declare const RunStateSchema: Type.TObject<{
-    version: Type.TLiteral<5>;
+    version: Type.TLiteral<6>;
     request: Type.TObject<{
         mode: Type.TLiteral<"isolated">;
         id: Type.TString;
@@ -1807,6 +1825,23 @@ declare const RunStateSchema: Type.TObject<{
         childMaxMs: Type.TNumber;
         maxCorrections: Type.TInteger;
     }>;
+    /** Present exactly when the request has a changeset task. */
+    fullSuite: Type.TOptional<Type.TObject<{
+        check: Type.TObject<{
+            command: Type.TString;
+            args: Type.TArray<Type.TString>;
+        }>;
+        source: Type.TUnion<[Type.TObject<{
+            kind: Type.TLiteral<"config">;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"package-json">;
+            testScript: Type.TString;
+        }>, Type.TObject<{
+            kind: Type.TLiteral<"makefile">;
+            file: Type.TUnion<[Type.TLiteral<"GNUmakefile">, Type.TLiteral<"makefile">, Type.TLiteral<"Makefile">]>;
+            sha256: Type.TString;
+        }>]>;
+    }>>;
     correctionCount: Type.TInteger;
     root: Type.TString;
     requestStartMain: Type.TObject<{
@@ -2429,7 +2464,7 @@ declare const RunStateSchema: Type.TObject<{
  */
 export declare const StatusOutputSchema: Type.TObject<{
     state: Type.TObject<{
-        version: Type.TLiteral<5>;
+        version: Type.TLiteral<6>;
         id: Type.TString;
         status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"needs_attention">, Type.TLiteral<"completed">, Type.TLiteral<"final_failed">, Type.TLiteral<"superseded">, Type.TLiteral<"aborted">]>;
         accepted: Type.TBoolean;

package/dist/schema.js

@@ -2,7 +2,7 @@ import { isAbsolute } from "node:path";
 import { parseRoleName } from "./index.js";
 import { Type } from "typebox";
 import { Check, Errors } from "typebox/value";
-export const RUN_STATE_VERSION = 5;
+export const RUN_STATE_VERSION = 6;
 export const MAX_TASKS = 8;
 export const MAX_EXECUTE_REQUEST_BYTES = 256 * 1024;
 export const MAX_PERSISTED_RUNTIME_TEXT_BYTES = 8 * 1024;
@@ -26,6 +26,19 @@ export const CheckCommandSchema = Type.Object({
     command: TextSchema,
     args: Type.Array(Type.String({ maxLength: 16_000 }), { maxItems: 128 }),
 }, { additionalProperties: false });
+/** The Full suite fixed at admission, with its source. Validation checks the same source again. */
+export const FullSuiteSchema = Type.Object({
+    check: CheckCommandSchema,
+    source: Type.Union([
+        Type.Object({ kind: Type.Literal("config") }, { additionalProperties: false }),
+        Type.Object({ kind: Type.Literal("package-json"), testScript: Type.String({ minLength: 1, maxLength: 16_000 }) }, { additionalProperties: false }),
+        Type.Object({
+            kind: Type.Literal("makefile"),
+            file: Type.Union([Type.Literal("GNUmakefile"), Type.Literal("makefile"), Type.Literal("Makefile")]),
+            sha256: Type.String({ pattern: "^[0-9a-f]{64}$" }),
+        }, { additionalProperties: false }),
+    ]),
+}, { additionalProperties: false });
 /** One display form for a check command; quoted args keep argv boundaries visible. */
 export function formatCheckCommand({ command, args }) {
     return [command, ...args.map((arg) => JSON.stringify(arg))].join(" ");
@@ -420,6 +433,8 @@ const RunStateSchema = Type.Object({
     version: Type.Literal(RUN_STATE_VERSION),
     request: ExecuteRequestSchema,
     policy: ExecutionPolicySnapshotSchema,
+    /** Present exactly when the request has a changeset task. */
+    fullSuite: Type.Optional(FullSuiteSchema),
     correctionCount: Type.Integer({ minimum: 0 }),
     root: TextSchema,
     requestStartMain: WorkspaceSchema,
@@ -1015,6 +1030,13 @@ export function parseRunState(value) {
     const state = value;
     const request = parseExecuteRequest(state.request);
     parseIntegrationState(state.integration, request);
+    const changeset = request.tasks.some((task) => task.kind === "changeset");
+    if (changeset !== (state.fullSuite !== undefined))
+        throw new Error("A Full suite must be recorded exactly for a request with changeset tasks.");
+    if (state.fullSuite && !request.finalChecks.some(({ command, args }) => command === state.fullSuite.check.command
+        && args.length === state.fullSuite.check.args.length && args.every((arg, index) => arg === state.fullSuite.check.args[index]))) {
+        throw new Error("The recorded Full suite is not in the request final checks.");
+    }
     if (state.status !== "aborted" && state.integration.generations.some((generation) => generation.supersededFrom === "discarded")) {
         throw new Error("User-discarded generations require an aborted request.");
     }

package/dist/store.d.ts

@@ -47,13 +47,21 @@ export declare class FileRunStore {
     private loadFromValidatedDirectory;
     hasProductiveRunLeaseInDirectory(directory: string): Promise<boolean>;
     withDirectoryLock<T>(directory: string, operation: () => Promise<T>): Promise<T>;
-    /** Missing roots only; repoRoot records the stable primary checkout, not the removed parent. */
+    /**
+     * Missing roots only; repoRoot records the stable primary checkout, not the removed parent.
+     * Without `primary`, return the orphans of every primary checkout, each with its primary.
+     */
     listOrphans(primary: string): Promise<{
         states: RunStateHandle[];
         invalidIds: string[];
     }>;
+    listOrphans(primary?: undefined): Promise<{
+        states: RunStateHandle[];
+        invalidIds: string[];
+        primaries: Map<RunStateHandle, string>;
+    }>;
     private stateEntries;
-    /** Read only version and request status; never migrate or interpret v4 worker evidence. */
+    /** Read only version and request status; never migrate or interpret v4 or v5 worker evidence. */
     assertLegacyAdmissionSafe(root: string): Promise<void>;
     list(root: string): Promise<{
         states: RunStateHandle[];

package/dist/store.js

@@ -18,8 +18,10 @@ const INITIAL_STATE_MAX_BYTES = 2 * 1024 * 1024;
 const STATE_MAX_BYTES = 128 * 1024 * 1024;
 const ADMISSION_MAX_FILES = 256;
 const ADMISSION_MAX_BYTES = STATE_MAX_BYTES;
-const V4_TERMINAL_STATUSES = new Set(["completed", "final_failed", "superseded", "aborted"]);
-const V4_UNFINISHED_STATUSES = new Set(["pending", "running", "needs_attention"]);
+// v4 and v5 use the same request statuses. Admission reads only the version and the status of older files.
+const LEGACY_VERSIONS = new Set([4, 5]);
+const LEGACY_TERMINAL_STATUSES = new Set(["completed", "final_failed", "superseded", "aborted"]);
+const LEGACY_UNFINISHED_STATUSES = new Set(["pending", "running", "needs_attention"]);
 const LOCK_OPTIONS = { realpath: false, stale: 30_000, update: 5_000, retries: 0 };
 const LIFECYCLE_LOCK_OPTIONS = {
     ...LOCK_OPTIONS,
@@ -253,8 +255,8 @@ export class FileRunStore {
             await release();
         }
     }
-    /** Missing roots only; repoRoot records the stable primary checkout, not the removed parent. */
     async listOrphans(primary) {
+        const primaries = new Map();
         const parent = join(extensionConfigDir("pi-subagent", this.agentDir), "state");
         let directories;
         try {
@@ -262,7 +264,7 @@ export class FileRunStore {
         }
         catch (error) {
             if (isMissing(error))
-                return { states: [], invalidIds: [] };
+                return { states: [], invalidIds: [], ...(primary === undefined ? { primaries } : {}) };
             throw error;
         }
         const states = [];
@@ -289,7 +291,14 @@ export class FileRunStore {
                                 throw error;
                         }
                         const worktrees = discardResources(handle.state).flatMap((resource) => resource.worktree ? [resource.worktree] : []);
-                        if (worktrees.length && worktrees.every((item) => item.repoRoot === primary))
+                        const owner = worktrees[0]?.repoRoot;
+                        if (owner === undefined || !worktrees.every((item) => item.repoRoot === owner))
+                            continue;
+                        if (primary === undefined) {
+                            primaries.set(handle, owner);
+                            states.push(handle);
+                        }
+                        else if (owner === primary)
                             states.push(handle);
                     }
                     catch {
@@ -303,7 +312,7 @@ export class FileRunStore {
                 invalidIds.push(directory);
             }
         }
-        return { states, invalidIds };
+        return { states, invalidIds, ...(primary === undefined ? { primaries } : {}) };
     }
     async stateEntries(root) {
         try {
@@ -317,7 +326,7 @@ export class FileRunStore {
             throw error;
         }
     }
-    /** Read only version and request status; never migrate or interpret v4 worker evidence. */
+    /** Read only version and request status; never migrate or interpret v4 or v5 worker evidence. */
     async assertLegacyAdmissionSafe(root) {
         const directory = this.stateDirectory(root);
         await this.assertSafeDestination(root, directory);
@@ -348,12 +357,12 @@ export class FileRunStore {
             }
             if (value.version === RUN_STATE_VERSION)
                 continue;
-            if (value.version !== 4 || !("status" in value) || typeof value.status !== "string"
-                || (!V4_TERMINAL_STATUSES.has(value.status) && !V4_UNFINISHED_STATUSES.has(value.status))) {
+            if (typeof value.version !== "number" || !LEGACY_VERSIONS.has(value.version) || !("status" in value) || typeof value.status !== "string"
+                || (!LEGACY_TERMINAL_STATUSES.has(value.status) && !LEGACY_UNFINISHED_STATUSES.has(value.status))) {
                 throw new Error(`Pi Subagent malformed or unsupported legacy state ${id} blocks safe admission. ${recovery}`);
             }
-            if (V4_UNFINISHED_STATUSES.has(value.status)) {
-                throw new Error(`Pi Subagent unfinished v4 request ${id} (${value.status}) blocks new isolated work. ${recovery}`);
+            if (LEGACY_UNFINISHED_STATUSES.has(value.status)) {
+                throw new Error(`Pi Subagent unfinished v${value.version} request ${id} (${value.status}) blocks new isolated work. ${recovery}`);
             }
         }
     }

package/docs/orchestration.md

@@ -81,7 +81,7 @@ Direct `changeset` is rejected; use isolated mode for checked integration. Resou
 
 ### Dry run
 
-Set `"dryRun": true` on a direct or isolated `delegate_task` request to check it without a launch. The dry run does the same checks as a launch: request shape, Role lookup, route and model with thinking level, Skills, tools, MCP allowlist, Role extensions, config, and `continueFrom` eligibility. For an isolated request, it also checks the task graph and that Main is clean and committed. If the request has a changeset task, it also checks the canonical root `package.json` test script and adds `pnpm test` to the final checks. A failed check gives the same error as a launch.
+Set `"dryRun": true` on a direct or isolated `delegate_task` request to check it without a launch. The dry run does the same checks as a launch: request shape, Role lookup, route and model with thinking level, Skills, tools, MCP allowlist, Role extensions, config, and `continueFrom` eligibility. For an isolated request, it also checks the task graph and that Main is clean and committed. If the request has a changeset task, it also selects the Full suite, adds it to the final checks, and shows it. A failed check gives the same error as a launch.
 
 The result is a bounded plan. It shows each task's Role, resolved `provider/model`, thinking level, access or kind, dependencies, and checks. An isolated plan also shows the final checks. The dry run makes no Herdr call, Herdr tab, session record, saved state, worktree, lease, checkout admission, or follow-up. The plan lists each check it cannot do without such an effect as `Not checked: <reason>`. Examples are the Herdr host preflight, checkout admission, and the stop of a continued agent.
 
@@ -257,7 +257,7 @@ Every task declares `id`, `kind`, `role`, `modelClass`, `requirements`, `deliver
 - A `changeset` task requires focused checks and owns one worktree, Herdr workspace, worker tab, and retained worker.
 - `dependsOn` controls ready waves; dependent tasks can run from a selected staged snapshot only after Main explicitly advances it.
 - `contextFrom` may reference completed text tasks only, implies scheduling dependencies, and preserves declaration order. It must not overlap `dependsOn`.
-- A graph containing changesets requires final checks. The repository root must have a `package.json` test script; admission prepends canonical `pnpm test` if absent from final checks. Combined validation rejects a changed root test script.
+- A graph containing changesets requires final checks. Admission selects one Full suite: the `repoSuites` config entry, then `pnpm test` for a root `package.json` test script, then `make test` for a literal Makefile `test` target. It prepends the suite to the final checks if absent and saves the suite with its source in state v6. Combined validation rejects a changed root test script or Makefile. A config change after admission does not change the saved suite.
 
 Admission and worker-wave dispatch pin Main's exact committed branch, HEAD, and tree without inspecting or modifying its staged, unstaged, or untracked edits. Worker allocation verifies the same committed identity around worktree creation, including resumed waves; staged-dependent waves verify their clean integration snapshot. A dirty Main can therefore produce a checked retained candidate, but branch/HEAD drift stops new waves. The runner executes ready worker tasks concurrently, inspects clean committed candidates, runs preliminary task checks and optional preliminary judgment, then records ready candidates for Main. **It does not automatically integrate them.**