@hydraharness/harness-subagent-in-process-driver 0.1.1-rc.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# @hydraharness/harness-subagent-in-process-driver
+
+This package is the shared run driver for the two in-process providers. Spawn passes no session seed; fork passes the parent's completed-turn prefix. Everything else—depth, child creation, optional child customization, result reading, cancellation, and disposal—has one implementation here.
+
+## Start contract
+
+`startInProcessRun(request, options): Promise<SubagentRun>` fulfills only after the child is published in `ctx.agents`. A rejected start has already quiesced the agent factory's unpublished creation transaction, so the caller never receives a half-created handle.
+
+The driver follows this sequence:
+
+1. Validate the parent depth and optional absolute `maxDepth`, then derive child depth as parent depth plus one and persist it in the child session header.
+2. Call `parent.ctx.agents.create` directly, passing the required request signal into the factory's creation transaction.
+3. During that transaction's unpublished setup window, install the requested persona, tool restriction, and structured-output runtime.
+4. Publish the child, retain the returned `AgentHandle`, and drive one task with `child.followup(prompt)` followed by `child.whenIdle()`.
+5. Read the child's own output — its last non-empty assistant message (an empty-content message that records usage is skipped), or its accumulated assistant text when no such message exists — and the final durable turn reason from the complete owned child run, excluding any fork seed.
+
+The child gets the parent's working-directory/session lineage and inherits the parent provider, model, and output-token cap unless `request.agentOptions` overrides them. It gets a fresh flat registration scope: parent ownership does not import parent tool restrictions or establish an authority subset.
+
+This result boundary is valid because the provider owns an isolated child lifecycle from publication through quiescence. Steering submitted during that lifecycle belongs to the child run; the provider does not pretend the initial follow-up alone owns its output.
+
+The driver applies the seam's [delegated policy](../subagent/README.md#delegated-policy) through the shared child-agent helpers: it captures the parent's explicit sandbox override and the `'never'` approval pin before child creation and appends the source-tagged events during unpublished setup, after any fork history and before session publication. See the [delegation-policy decision](../../../.agents/notes/implemented/feature/2026-07-25-subagent-policy-inheritance.md).
+
+## Cancellation and ownership
+
+The required request signal covers both startup and the live run. Before publication, `AgentCreationTransaction` observes it, rolls back, and rejects. The factory detaches that creation-only listener before returning; the driver immediately checks the signal once more before installing a minimal live-run listener, closing the handoff race. After publication, abort cancels the child.
+
+After fulfillment, the caller owns the run. Provider-plugin unload does not revoke it. `dispose()` removes the live abort listener, records cancellation, and delegates to the returned `AgentHandle.dispose()`, whose memoized quiescence transaction stops the loop, removes the agent and session, and unwinds scoped registrations. Cancellation owns every non-completed in-flight outcome and reports `aborted`; an already-completed turn remains completed.
+
+## Spawn and fork inputs
+
+`InProcessRunOptions` is `{ seed?: SessionEvent[] }`. Spawn omits it. Fork supplies a balanced completed-turn prefix and records its length so the result reader never mistakes a seeded parent message for child output.
+
+Depth enforcement is internal to `startInProcessRun`: it reads the parent depth via `delegationDepthOf` (the persisted `SessionHeader.delegationDepth` is authoritative; runtime `AgentOptions.subagentDepth` may deepen but never lower it, so a resumed child keeps its budget), treats absence as top-level depth zero, rejects malformed stored values, and reports an attempted child depth above `maxDepth`. An unrepresentable depth above the safe-integer domain is a `RangeError`. The child depth is written to the child header, so it survives persistence and resume.
+
+## Structured output
+
+`attachStructuredRuntime(childCtx, schema)` installs the whole contract in the child's scope:
+
+- A `structured_output` tool registered with the requested schema validates and stages the model's value.
+- An order-190 system-prompt section tells the child that the tool call is the terminal answer.
+- Both contributions are ordinary child-scoped registrations. An expert `system-prompt/assemble` listener may replace them and therefore owns preserving the structured-output protocol for that child.
+- A `tools/result` observer commits a staged value only after that execution's authoritative final tool result succeeds, including the enclosing `run_code` result for Code Mode sub-dispatch.
+- A monotonic tool guard blocks later calls after capture, and the structured-output execution's `concludeTurn()` marker ends the turn after the result commits.
+
+A clean turn that never commits the required structured value reports `error`; the driver does not re-prompt. All registrations ride the child fiber and disappear with it.
+
+## Model Experience
+
+### Child-agent request
+
+#### What the model sees
+
+The shared driver sends the task verbatim as the child's user message and, when requested, shadows the persona and restricts global tool schemas, lookup, execution, and Code Mode SDK bindings in the unpublished child's fresh scope; parent restrictions are not inherited, and standalone tool-guidance sections remain. Spawn supplies no history; fork supplies its balanced seed.
+
+#### Token effect
+
+Child input is isolated from the parent and grows through the child's own steps. A persona changes repeated prompt text; filtering changes schema or generated SDK cost but not independently registered guidance.
+
+#### KV Cache effect
+
+Independent of the parent request cache. The child's later history is append-only, while persona, tool-filter, generated-SDK, provider, or model changes establish a different child prefix.
+
+### Structured-output system prompt, schema, and results
+
+#### What the model sees
+
+A structured run adds the structured-output instruction below. It also adds a child-scoped `structured_output` definition with exact description `Report your final structured result. Call this exactly once, when your answer is complete; the arguments must match this tool's parameter schema exactly.` and the requested schema. This runtime-only definition is outside the generated shipped [tool package map](../../../docs/tool-catalog.md#tool-package-map). Its canonical acknowledgement is `{ recorded: true }`, rendered as `Structured output recorded.`; a later call becomes ``Error: structured output already recorded: the run is complete, so `<tool>` is not executed``.
+
+##### Structured-output instruction
+
+```markdown
+When you have your final answer, you MUST report it by calling the `structured_output` tool with arguments matching its parameter schema exactly. Do not finish with a plain text answer: only the tool call counts as your result.
+```
+
+#### Token effect
+
+Fixed instruction and capability tokens are paid only by that child. Result text enters the child history, while the captured value alone becomes the parent result.
+
+#### KV Cache effect
+
+Prefix-stable inside the child while the structured-output instruction and schema are unchanged. Changing the schema or capability may invalidate the child's cache from that early segment; results append in child and parent histories.
+
+### Parent start error, indirectly
+
+#### What the model sees
+
+Through `@hydraharness/harness-tool-subagent`, invalid depth state becomes exactly `Error: agent subagentDepth must be a non-negative safe integer`, `Error: subagent child depth exceeds the safe-integer range`, or `Error: subagent depth <attempted> exceeds maxDepth <max>`. A pre-publication cancellation passes its abort reason through the registry's `Error: <message>` wrapper.
+
+#### Token effect
+
+Zero tokens on a successful start; only the failed parent tool call retains this text.
+
+#### KV Cache effect
+
+Append-only; newly visible content follows the reusable request prefix and does not invalidate existing KV-cache entries.
+
+### Parent result, indirectly
+
+#### What the model sees
+
+The driver extracts only the child's own last assistant output or captured structured value; seeded parent messages and intermediate child work do not become the result.
+
+#### Token effect
+
+The parent receives one data-dependent result through the consumer; all other child tokens stay in the child session.
+
+#### KV Cache effect
+
+Append-only; newly visible content follows the reusable request prefix and does not invalidate existing KV-cache entries.
+
+## Known Limitations and Deferred Work
+
+- **Runs expose no `sendMessage`/`resume`** — the optional runtime capabilities are absent on in-process runs.
+- **Structured capture accepts the `defineTool` schema subset only** — unsupported JSON Schema constructs fail before the child is created; a provider needing a broader schema vocabulary requires a different runtime.

package/lib/index.js

@@ -0,0 +1,251 @@
+import { randomUUID } from "node:crypto";
+import { foldConsumedWork } from "@hydraharness/harness-agent";
+import { SessionId } from "@hydraharness/harness-session";
+import { createUserMessage } from "@hydraharness/harness-llm";
+import { appendDelegatedPolicyOverrides, applyChildComposition, assertSubagentMaxDepth, captureDelegatedPolicyOverrides, childSessionMeta, finalAssistantOutput, resolveChildAgentOptions, resolveChildDepth } from "@hydraharness/harness-subagent";
+import { ToolArgsError, validateJsonSchemaValue } from "@hydraharness/harness-tools";
+//#region lib/types/structured.js
+/**
+* Child-scoped structured-output tool, prompt instruction, terminal guard, and authoritative
+* result capture for in-process subagents. Each child registers its real schema on its own
+* scope, so concurrent runs do not interact and disposal leaves no global residue. The prompt
+* contribution is ordinary reconstructed request state.
+*
+* Capture commits only after the authoritative `tools/result` succeeds; Code Mode capture also
+* waits for the enclosing `run_code` result. The terminal result marker and monotonic tool
+* guard prevent later calls from reopening a completed structured run.
+* @module @hydraharness/harness-subagent-in-process-driver/structured
+*/
+/** The model-facing tool name a structured child must call to finish. */
+const STRUCTURED_OUTPUT_TOOL = "structured_output";
+/**
+* The instruction registered as the child's trailing (order-190, the end of
+* the tool-guidance band) scoped prompt section: the demand travels with the
+* tool, as ordinary prompt state of exactly one agent.
+*/
+const STRUCTURED_OUTPUT_INSTRUCTION = `When you have your final answer, you MUST report it by calling the \`${STRUCTURED_OUTPUT_TOOL}\` tool with arguments matching its parameter schema exactly. Do not finish with a plain text answer: only the tool call counts as your result.`;
+/**
+* Attach the scoped capture tool, instruction, and enforcement to a child during
+* its creation window. Child disposal removes every registration.
+* @param childCtx - the child agent's scope context (`setup`'s argument).
+* @param schema - the trusted, already-asserted schema subset to enforce (see
+*   `assertObjectJsonSchema` in @hydraharness/harness-tools).
+* @returns the attachment handle (read `captured()` after the child settles).
+*/
+function attachStructuredRuntime(childCtx, schema) {
+	/**
+	* Validated values staged by the capture tool body, awaiting THEIR OWN
+	* authoritative `tools/result` notification. The execution object's identity
+	* uniquely identifies a trip through the pipeline: adapter call ids may
+	* repeat across steps, but another execution can never reach this WeakMap
+	* entry. This is distinct from the opaque `ToolExecutionToken` used to
+	* correlate nested transports. The final notification always deletes its own
+	* stage, whether the result succeeded or failed.
+	*/
+	const staged = /* @__PURE__ */ new WeakMap();
+	/** Successful nested capture waiting for its enclosing transport to commit. */
+	let pending;
+	let captured;
+	const schemaEntry = {
+		name: STRUCTURED_OUTPUT_TOOL,
+		description: "Report your final structured result. Call this exactly once, when your answer is complete; the arguments must match this tool's parameter schema exactly.",
+		parameters: schema
+	};
+	childCtx.tools.register({
+		...schemaEntry,
+		output: {
+			schema: {
+				type: "object",
+				properties: { recorded: {
+					type: "boolean",
+					const: true
+				} },
+				required: ["recorded"],
+				additionalProperties: false
+			},
+			render: () => [{
+				type: "text",
+				text: "Structured output recorded."
+			}]
+		},
+		execute(args, exec) {
+			const violations = validateJsonSchemaValue(schema, args);
+			if (violations.length > 0) throw new ToolArgsError(violations);
+			staged.set(exec, { value: args });
+			exec.concludeTurn();
+			return Promise.resolve({ recorded: true });
+		}
+	});
+	childCtx.systemPrompt.section({
+		name: `tool:${STRUCTURED_OUTPUT_TOOL}`,
+		order: 190,
+		text: STRUCTURED_OUTPUT_INSTRUCTION
+	});
+	childCtx.tools.guard((exec) => captured === void 0 && pending === void 0 ? void 0 : `structured output already recorded: the run is complete, so \`${exec.name}\` is not executed`);
+	childCtx.on("tools/result", function(exec, result) {
+		if (exec.name === "structured_output") {
+			const entry = staged.get(exec);
+			if (entry === void 0) return;
+			staged.delete(exec);
+			if (result.isError) return;
+			if (exec.parent === void 0) {
+				/* v8 ignore else -- sequential agent-loop dispatch lets the guard block every later supported call */
+				if (captured === void 0) captured = { value: entry.value };
+			} else if (captured === void 0 && pending === void 0) pending = {
+				parent: exec.parent,
+				value: entry.value
+			};
+			return;
+		}
+		if (pending?.parent !== exec.token) return;
+		const entry = pending;
+		pending = void 0;
+		if (result.isError) return;
+		/* v8 ignore else -- Code Mode serializes outer executions, so the guard blocks every later supported call */
+		if (captured === void 0) captured = { value: entry.value };
+	});
+	return { captured: () => captured };
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* Shared driver for in-process ONE-SHOT subagent providers. The agent factory's
+* creation transaction owns unpublished setup and rollback; after publication
+* the returned AgentHandle is the one quiescent lifecycle owner held by the
+* provider's caller.
+*
+* Continuable children never come through here: the continuation manager
+* composes and drives them directly, so this driver owns exactly one turn with
+* one result.
+*
+* @module @hydraharness/harness-subagent-in-process-driver
+*/
+/** Map a session turn outcome to the subagent seam's terminal vocabulary. */
+function toStopReason(reason) {
+	switch (reason?.kind) {
+		case "completed": return "completed";
+		case "max-tokens": return "max-tokens";
+		case "aborted": return "aborted";
+		case "blocked": return "refusal";
+		default: return "error";
+	}
+}
+/** Error used when cancellation wins before the child publication boundary. */
+function prePublicationAbort() {
+	return /* @__PURE__ */ new Error("subagent request was aborted before child publication");
+}
+/** Append one one-shot descriptor inside the child's initial turn before its first request. */
+function attachDescriptorAppend(childCtx, descriptor) {
+	let appended = false;
+	childCtx.on("agent/pre-step", async ({ agent }, next) => {
+		const decision = await next();
+		if (!appended && decision.kind === "enter") {
+			appended = true;
+			agent.session.append("subagent/descriptor", descriptor);
+		}
+		return decision;
+	});
+}
+/**
+* Establish and drive one in-process one-shot child. Fulfillment means the agent
+* is already published in the registry and transfers its turn, cancellation,
+* and disposal work through the returned run. Rejection means the agent
+* factory's unpublished creation transaction reached quiescence without
+* publishing a child. Every start appends its resolved descriptor inside the
+* child's initial turn.
+* @param request - the trusted typed start request, including its required signal.
+* @param options - the optional fork seed.
+* @returns a published holder-owned run.
+*/
+async function startInProcessRun(request, options) {
+	assertSubagentMaxDepth(request.maxDepth);
+	if (request.signal.aborted) throw prePublicationAbort();
+	const parent = request.parent;
+	const childDepth = resolveChildDepth(parent, request.maxDepth);
+	const childId = SessionId(randomUUID());
+	const seed = options.seed;
+	const activationBoundary = seed?.length ?? 0;
+	const inherited = captureDelegatedPolicyOverrides(parent);
+	let structured;
+	const setup = (childCtx) => {
+		appendDelegatedPolicyOverrides(childCtx.agent.session, inherited);
+		applyChildComposition(childCtx, parent, {
+			persona: request.persona,
+			toolFilter: request.toolFilter
+		});
+		if (request.outputSchema !== void 0) structured = attachStructuredRuntime(childCtx, request.outputSchema);
+		attachDescriptorAppend(childCtx, request.descriptor);
+	};
+	return drivePublishedRun(await parent.ctx.agents.create({
+		sessionId: childId,
+		meta: childSessionMeta(parent, childDepth, activationBoundary),
+		...seed !== void 0 ? { seed } : {},
+		agentOptions: resolveChildAgentOptions(parent, request.agentOptions, childDepth),
+		signal: request.signal,
+		setup
+	}), request.signal, request.prompt, childId, activationBoundary, structured);
+}
+/**
+* Wrap a published child in the single run lifecycle that owns signal handoff,
+* one turn, result settlement, and quiescent disposal.
+*/
+function drivePublishedRun(handle, signal, prompt, childId, boundary, structured) {
+	const child = handle.agent;
+	const flags = { cancelled: false };
+	const onAbort = () => {
+		flags.cancelled = true;
+		child.cancel({ kind: "parent" });
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	if (signal.aborted) onAbort();
+	const result = (async () => {
+		try {
+			if (!flags.cancelled) {
+				child.followup(createUserMessage({
+					content: prompt,
+					source: { kind: "user" }
+				}));
+				await child.whenIdle();
+			}
+			return readResult(child, boundary, flags.cancelled, structured ? { captured: structured.captured() } : void 0);
+		} finally {
+			signal.removeEventListener("abort", onAbort);
+		}
+	})();
+	return {
+		id: childId,
+		localAgent: child,
+		result,
+		async dispose() {
+			signal.removeEventListener("abort", onAbort);
+			flags.cancelled = true;
+			const disposal = (await Promise.allSettled([handle.dispose(), result]))[0];
+			if (disposal.status === "rejected") throw disposal.reason;
+		}
+	};
+}
+/** Read one settled child's result from events after its activation boundary. */
+function readResult(child, boundary, cancelled, structured) {
+	const own = child.session.events.slice(boundary);
+	const lastEnd = foldConsumedWork(own).end;
+	const output = finalAssistantOutput(own) ?? [];
+	const recorded = toStopReason(lastEnd?.data.reason);
+	const stopReason = cancelled && recorded !== "completed" ? "aborted" : recorded;
+	if (structured !== void 0) {
+		if (structured.captured !== void 0) return {
+			output,
+			structured: structured.captured.value,
+			stopReason
+		};
+		if (stopReason === "completed") return {
+			output,
+			stopReason: cancelled ? "aborted" : "error"
+		};
+	}
+	return {
+		output,
+		stopReason
+	};
+}
+//#endregion
+export { STRUCTURED_OUTPUT_INSTRUCTION, STRUCTURED_OUTPUT_TOOL, startInProcessRun };

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@hydraharness/harness-subagent-in-process-driver`.
+* @module @hydraharness/harness-subagent-in-process-driver/invariant
+*/
+const PACKAGE_NAME = "@hydraharness/harness-subagent-in-process-driver";
+/** Cordis companion plugin name. */
+const name = "subagent-in-process-driver-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: this package exposes no independent event sequence or mutable data relation
+* beyond contracts enforced at its owning seam.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared driver for in-process ONE-SHOT subagent providers. The agent factory's
+ * creation transaction owns unpublished setup and rollback; after publication
+ * the returned AgentHandle is the one quiescent lifecycle owner held by the
+ * provider's caller.
+ *
+ * Continuable children never come through here: the continuation manager
+ * composes and drives them directly, so this driver owns exactly one turn with
+ * one result.
+ *
+ * @module @hydraharness/harness-subagent-in-process-driver
+ */
+import { type SessionEvent } from '@hydraharness/harness-session';
+import type { ResolvedSubagentStartRequest, SubagentRun } from '@hydraharness/harness-subagent';
+export { STRUCTURED_OUTPUT_TOOL, STRUCTURED_OUTPUT_INSTRUCTION, } from './structured.ts';
+/** Extra inputs the spawn and fork providers supply to the shared driver. */
+export interface InProcessRunOptions {
+    /** Completed-turn seed for fork, or undefined for a fresh spawn. */
+    readonly seed?: SessionEvent[];
+}
+/**
+ * Establish and drive one in-process one-shot child. Fulfillment means the agent
+ * is already published in the registry and transfers its turn, cancellation,
+ * and disposal work through the returned run. Rejection means the agent
+ * factory's unpublished creation transaction reached quiescence without
+ * publishing a child. Every start appends its resolved descriptor inside the
+ * child's initial turn.
+ * @param request - the trusted typed start request, including its required signal.
+ * @param options - the optional fork seed.
+ * @returns a published holder-owned run.
+ */
+export declare function startInProcessRun(request: ResolvedSubagentStartRequest, options: InProcessRunOptions): Promise<SubagentRun>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@hydraharness/harness-subagent-in-process-driver`.
+ * @module @hydraharness/harness-subagent-in-process-driver/invariant
+ */
+import type { Context } from '@hydraharness/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "subagent-in-process-driver-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/structured.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Child-scoped structured-output tool, prompt instruction, terminal guard, and authoritative
+ * result capture for in-process subagents. Each child registers its real schema on its own
+ * scope, so concurrent runs do not interact and disposal leaves no global residue. The prompt
+ * contribution is ordinary reconstructed request state.
+ *
+ * Capture commits only after the authoritative `tools/result` succeeds; Code Mode capture also
+ * waits for the enclosing `run_code` result. The terminal result marker and monotonic tool
+ * guard prevent later calls from reopening a completed structured run.
+ * @module @hydraharness/harness-subagent-in-process-driver/structured
+ */
+import type { Context } from '@hydraharness/cordis';
+import { type ObjectJsonSchema } from '@hydraharness/harness-tools';
+/** The model-facing tool name a structured child must call to finish. */
+export declare const STRUCTURED_OUTPUT_TOOL = "structured_output";
+/**
+ * The instruction registered as the child's trailing (order-190, the end of
+ * the tool-guidance band) scoped prompt section: the demand travels with the
+ * tool, as ordinary prompt state of exactly one agent.
+ */
+export declare const STRUCTURED_OUTPUT_INSTRUCTION: string;
+/** One structured run's live handle: read the captured value once the child settles. */
+export interface StructuredAttachment {
+    /**
+     * The captured value, once the child called the tool with valid arguments
+     * and the authoritative final tool result accepted that call.
+     * @returns the committed value, or undefined while none was accepted.
+     */
+    captured(): {
+        value: unknown;
+    } | undefined;
+}
+/**
+ * Attach the scoped capture tool, instruction, and enforcement to a child during
+ * its creation window. Child disposal removes every registration.
+ * @param childCtx - the child agent's scope context (`setup`'s argument).
+ * @param schema - the trusted, already-asserted schema subset to enforce (see
+ *   `assertObjectJsonSchema` in @hydraharness/harness-tools).
+ * @returns the attachment handle (read `captured()` after the child settles).
+ */
+export declare function attachStructuredRuntime(childCtx: Context, schema: ObjectJsonSchema): StructuredAttachment;
+//# sourceMappingURL=structured.d.ts.map

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@hydraharness/harness-subagent-in-process-driver",
+  "description": "Shared in-process subagent run driver: drives a child agent on ctx.agents (used by the spawn and fork backends)",
+  "version": "0.1.1-rc.6",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MaiHongPhong1902/Hydra-Harness.git",
+    "directory": "packages/subagent/subagent-in-process-driver"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@hydraharness/harness-agent": "^0.1.1-rc.6",
+    "@hydraharness/harness-invariants": "^0.1.1-rc.6",
+    "@hydraharness/harness-llm": "^0.1.1-rc.6",
+    "@hydraharness/harness-session": "^0.1.1-rc.6",
+    "@hydraharness/harness-subagent": "^0.1.1-rc.6",
+    "@hydraharness/harness-system-prompt": "^0.1.1-rc.6",
+    "@hydraharness/harness-tools": "^0.1.1-rc.6",
+    "@hydraharness/cordis": "^4.0.2"
+  },
+  "devDependencies": {
+    "@hydraharness/cordis-plugin-include": "^1.0.7",
+    "@hydraharness/harness-agent": "^0.1.1-rc.6",
+    "@hydraharness/harness-agent-loop": "^0.1.1-rc.6",
+    "@hydraharness/cordis-plugin-loader": "^1.0.3",
+    "@hydraharness/harness-agent-presets": "^0.1.1-rc.6",
+    "@hydraharness/harness-agent-loop-testkit": "^0.1.1-rc.6",
+    "@hydraharness/harness-invariants": "^0.1.1-rc.6",
+    "@hydraharness/harness-fs-sandbox": "^0.1.1-rc.6",
+    "@hydraharness/harness-llm": "^0.1.1-rc.6",
+    "@hydraharness/harness-sandbox-policy": "^0.1.1-rc.6",
+    "@hydraharness/harness-session": "^0.1.1-rc.6",
+    "@hydraharness/harness-subagent": "^0.1.1-rc.6",
+    "@hydraharness/harness-tool-fs": "^0.1.1-rc.6",
+    "@hydraharness/harness-system-prompt": "^0.1.1-rc.6",
+    "@hydraharness/harness-tools": "^0.1.1-rc.6",
+    "@hydraharness/harness-user-approval": "^0.1.1-rc.6",
+    "@hydraharness/cordis": "^4.0.2"
+  }
+}