@narumitw/pi-subagents 2.0.1 → 2.0.3

package/dist/chunks/in-process-transport-TEYAWSEC.ts

@@ -0,0 +1,38 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  InProcessTransport,
+  buildCurrentTurnPrompt,
+  copyRegisteredProviders,
+  createInProcessServices,
+  createSdkChildSession,
+  resolveChildModel,
+  seedChildSessionManager,
+  validateInProcessTools
+} from "./chunk-UVFVHIOP.ts";
+import "./chunk-EWWXFU7N.ts";
+import "./chunk-G6VZTCFH.ts";
+import "./chunk-G3RSMSXJ.ts";
+import "./chunk-RTCVYIZA.ts";
+import "./chunk-ONDTY4EL.ts";
+import "./chunk-PSK43Y6A.ts";
+import "./chunk-RSUXZD6S.ts";
+import "./chunk-7QPPBBXZ.ts";
+import "./chunk-QBORTI4W.ts";
+import "./chunk-7OBINKFM.ts";
+import "./chunk-DPPVEQAM.ts";
+import "./chunk-SWGQLFSD.ts";
+import "./chunk-I2FAK44T.ts";
+import "./chunk-H3FP6DLR.ts";
+import "./chunk-RRR66UWR.ts";
+export {
+  InProcessTransport,
+  buildCurrentTurnPrompt,
+  copyRegisteredProviders,
+  createInProcessServices,
+  createSdkChildSession,
+  resolveChildModel,
+  seedChildSessionManager,
+  validateInProcessTools
+};
+//# sourceMappingURL=in-process-transport-TEYAWSEC.ts.map

package/dist/chunks/in-process-transport-TEYAWSEC.ts.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/chunks/inspect-UOQQ3KNL.ts

@@ -0,0 +1,619 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  inspectSessionWorkflows
+} from "./chunk-OVPHFGKO.ts";
+import {
+  resolveConsultTools
+} from "./chunk-UMBPMVJW.ts";
+import {
+  resolvePiInvocation
+} from "./chunk-IGAMVWFN.ts";
+import {
+  INSPECT_ACTIONS,
+  SubagentInspectParams,
+  registerSubagentInspect
+} from "./chunk-F4L2UVSK.ts";
+import "./chunk-HOP5FXDT.ts";
+import {
+  discoverAgents,
+  projectCapabilityManifest
+} from "./chunk-PSK43Y6A.ts";
+import "./chunk-RSUXZD6S.ts";
+import "./chunk-7QPPBBXZ.ts";
+import {
+  inspectBlockingParallelLimitSettings,
+  inspectCompletionDeliverySettings,
+  inspectConsultResourceSettings,
+  inspectCwdPolicySettings,
+  inspectDelegationWorkflowSettings,
+  inspectStatefulLimitSettings,
+  inspectStatefulTransportSettings,
+  inspectSubagentSettings,
+  resolveDelegationWorkflow
+} from "./chunk-QBORTI4W.ts";
+import "./chunk-7OBINKFM.ts";
+import "./chunk-DPPVEQAM.ts";
+import "./chunk-BFK2Z4ZF.ts";
+import {
+  boundText,
+  boundedPrivateText,
+  safeDisplayPath,
+  safeTerminalLine
+} from "./chunk-SWGQLFSD.ts";
+import {
+  DEFAULT_MAX_CONTEXT_BYTES,
+  buildContextSnapshot
+} from "./chunk-H3FP6DLR.ts";
+
+// src/inspect.ts
+import * as path from "node:path";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+var MAX_DETAILS_LIST_BYTES = 40 * 1024;
+function validateInspectParams(params) {
+  const values = parameterRecord(params);
+  const rawAction = values.action;
+  if (typeof rawAction !== "string" || !INSPECT_ACTIONS.includes(rawAction)) {
+    throw new Error(`subagent_inspect action must be one of: ${INSPECT_ACTIONS.join(", ")}`);
+  }
+  const action = rawAction;
+  const allowed = {
+    list_agents: ["action", "agentScope", "limit"],
+    get_agent: ["action", "agent", "agentScope"],
+    list_runs: ["action", "includeClosed", "limit"],
+    get_run: ["action", "agentId"],
+    list_workflows: ["action", "limit"],
+    get_workflow: ["action", "workflowId"],
+    list_models: ["action", "limit"],
+    preview_context: ["action", "context", "contextEntryIds"],
+    status: ["action"],
+    diagnose: ["action"]
+  };
+  const unexpected = Object.keys(values).find(
+    (key) => values[key] !== void 0 && !allowed[action].includes(key)
+  );
+  if (unexpected)
+    throw new Error(`subagent_inspect action "${action}" does not accept ${unexpected}`);
+  if (action === "list_agents" || action === "get_agent") {
+    const agentScope = optionalAgentScope(values.agentScope);
+    if (action === "get_agent") {
+      return { action, agent: requiredString(values.agent, action, "agent"), agentScope };
+    }
+    return { action, agentScope, limit: optionalLimit(values.limit, 32) };
+  }
+  if (action === "list_runs") {
+    if (values.includeClosed !== void 0 && typeof values.includeClosed !== "boolean") {
+      throw new Error('subagent_inspect action "list_runs" requires includeClosed to be boolean');
+    }
+    return {
+      action,
+      includeClosed: values.includeClosed === true,
+      limit: optionalLimit(values.limit, 50)
+    };
+  }
+  if (action === "get_run") {
+    return { action, agentId: requiredString(values.agentId, action, "agentId") };
+  }
+  if (action === "list_workflows") {
+    return { action, limit: optionalLimit(values.limit, 50) };
+  }
+  if (action === "get_workflow") {
+    return { action, workflowId: requiredString(values.workflowId, action, "workflowId") };
+  }
+  if (action === "list_models") {
+    return { action, limit: optionalLimit(values.limit, 50) };
+  }
+  if (action === "preview_context") {
+    const context = optionalContextMode(values.context);
+    const contextEntryIds = optionalStringArray(values.contextEntryIds, "contextEntryIds");
+    return {
+      action,
+      context: values.context === void 0 && contextEntryIds ? "all" : context,
+      ...contextEntryIds ? { contextEntryIds } : {}
+    };
+  }
+  return { action };
+}
+async function executeSubagentInspect(params, ctx, runtime) {
+  const operation = validateInspectParams(params);
+  if (operation.action === "list_agents" || operation.action === "get_agent") {
+    assertTrustedScope(operation.agentScope, ctx);
+    const settings2 = inspectSubagentSettings().settings;
+    const discovery = discoverAgents(ctx.cwd, operation.agentScope, settings2);
+    const agents = [...discovery.agents].sort(
+      (left, right) => left.name === right.name ? left.source.localeCompare(right.source) : left.name.localeCompare(right.name)
+    );
+    if (operation.action === "list_agents") {
+      const selected = boundedProjection(
+        agents,
+        operation.limit,
+        (agent2) => projectAgent(agent2, ctx, false)
+      );
+      return inspectResult({
+        action: operation.action,
+        agents: selected.items,
+        returned: selected.items.length,
+        omitted: selected.omitted + (discovery.omittedAgentDefinitions ?? 0),
+        discoveryIncomplete: discovery.metadataDiscoveryIncomplete === true
+      });
+    }
+    const agent = agents.find((candidate) => candidate.name === operation.agent);
+    if (!agent) {
+      throw new Error(`Unknown subagent definition: ${boundedPrivateText(operation.agent, 256)}`);
+    }
+    return inspectResult({ action: operation.action, agent: projectAgent(agent, ctx) });
+  }
+  if (operation.action === "list_runs") {
+    const runs = runtime.listRunInspection(operation.includeClosed);
+    const selected = boundedProjection(runs, operation.limit, projectRunSummary);
+    return inspectResult({
+      action: operation.action,
+      runs: selected.items,
+      returned: selected.items.length,
+      omitted: selected.omitted
+    });
+  }
+  if (operation.action === "get_run") {
+    const run = runtime.getRunInspection(operation.agentId);
+    if (!run) {
+      throw new Error(`Unknown retained run: ${boundedPrivateText(operation.agentId, 256)}`);
+    }
+    return inspectResult({ action: operation.action, run: projectRun(run, ctx) });
+  }
+  if (operation.action === "list_workflows" || operation.action === "get_workflow") {
+    const owner = ctx.sessionManager.getSessionId?.() ?? ctx.sessionManager.getSessionFile?.() ?? `ephemeral:${ctx.cwd}`;
+    const inspected = inspectSessionWorkflows(owner, {
+      maxStoredWorkflows: operation.action === "list_workflows" ? operation.limit : 64
+    });
+    if (operation.action === "list_workflows") {
+      const selected = boundedProjection(
+        inspected.workflows,
+        operation.limit,
+        projectWorkflowSummary
+      );
+      return inspectResult({
+        action: operation.action,
+        workflows: selected.items,
+        returned: selected.items.length,
+        omitted: inspected.omitted + selected.omitted,
+        invalid: inspected.invalid
+      });
+    }
+    const workflow = inspected.workflows.find(
+      (candidate) => candidate.workflowId === operation.workflowId
+    );
+    if (!workflow) {
+      throw new Error(
+        `Unknown persisted workflow: ${boundedPrivateText(operation.workflowId, 256)}`
+      );
+    }
+    return inspectResult({ action: operation.action, workflow: projectWorkflow(workflow) });
+  }
+  if (operation.action === "list_models") {
+    return inspectResult({ action: operation.action, ...projectModels(ctx, operation.limit) });
+  }
+  if (operation.action === "preview_context") {
+    const snapshot = buildContextSnapshot(
+      ctx.sessionManager.getBranch(),
+      operation.context,
+      DEFAULT_MAX_CONTEXT_BYTES,
+      operation.contextEntryIds
+    );
+    return inspectResult({
+      action: operation.action,
+      preview: {
+        mode: operation.context,
+        turns: snapshot.turns,
+        sourceCount: snapshot.sourceIds.length,
+        bytes: Buffer.byteLength(snapshot.text, "utf8"),
+        truncated: snapshot.truncated
+      }
+    });
+  }
+  if (operation.action === "status") {
+    return inspectResult({ action: operation.action, status: projectStatus(runtime) });
+  }
+  const settings = inspectSubagentSettings();
+  const userDiscovery = discoverAgents(ctx.cwd, "user", settings.settings);
+  const modelCount = availableModelCount(ctx);
+  const runtimeStatus = runtime.getRuntimeStatus();
+  const rpcCapability = inspectRpcCapability();
+  const inProcessCapability = await inspectInProcessCapability();
+  const checks = [
+    {
+      name: "settings",
+      status: settings.error ? "fail" : "pass",
+      message: settings.error ? boundedPrivateText(settings.error, 2 * 1024) : "Settings are valid or absent."
+    },
+    {
+      name: "agent-discovery",
+      status: userDiscovery.metadataDiscoveryIncomplete || (userDiscovery.omittedAgentDefinitions ?? 0) > 0 ? "warning" : "pass",
+      message: `${userDiscovery.agents.length} user-scope definitions available.`
+    },
+    {
+      name: "models",
+      status: modelCount > 0 ? "pass" : "fail",
+      message: `${modelCount} session-usable models available.`
+    },
+    {
+      name: "runtime",
+      status: runtimeStatus.enabled && !runtimeStatus.initialized ? "warning" : "pass",
+      message: runtimeStatus.initialized ? "Stateful runtime initialized." : "Stateful runtime not initialized."
+    },
+    {
+      name: "in-process-sdk",
+      status: inProcessCapability.error ? "fail" : "pass",
+      message: inProcessCapability.error ? boundedPrivateText(inProcessCapability.error, 2 * 1024) : "Required public Pi in-process session APIs are available."
+    },
+    {
+      name: "rpc-cli",
+      status: rpcCapability.error ? "fail" : "pass",
+      message: rpcCapability.error ? boundedPrivateText(rpcCapability.error, 2 * 1024) : "The exact loaded Pi CLI is available for persistent RPC transport."
+    },
+    {
+      name: "consultation",
+      status: runtime.getBlockingEnabled() && modelCount > 0 ? "pass" : "fail",
+      message: runtime.getBlockingEnabled() ? modelCount > 0 ? "Read-only consultation is supported." : "Consultation has no available model." : "Blocking delegation is disabled, so consultation is not registered."
+    }
+  ];
+  return inspectResult({
+    action: operation.action,
+    checks,
+    ok: checks.every((check) => check.status !== "fail")
+  });
+}
+function projectAgent(agent, ctx, includeTools = true) {
+  const tools = agent.tools === void 0 ? void 0 : projectToolNames(agent.tools);
+  return {
+    name: boundedPrivateText(agent.name, 256),
+    description: boundedPrivateText(agent.description, 256),
+    source: agent.source,
+    scope: agent.source === "project" ? "project" : "user",
+    path: agent.source === "project" ? safeTerminalLine(
+      path.posix.join(CONFIG_DIR_NAME, "agents", path.basename(agent.filePath))
+    ) : safeDisplayPath(agent.filePath, ctx.cwd),
+    model: agent.model ? boundedPrivateText(agent.model, 256) : void 0,
+    thinkingLevel: agent.thinkingLevel,
+    capabilityManifest: projectCapabilityManifest(agent.capabilityManifest),
+    ...includeTools ? { tools, toolCount: agent.tools?.length } : { toolCount: agent.tools?.length },
+    consultTools: resolveConsultTools(agent.tools)
+  };
+}
+function projectRunSummary(run) {
+  return {
+    id: boundedPrivateText(run.id, 256),
+    agent: boundedPrivateText(run.agent, 256),
+    state: run.state,
+    createdAt: run.createdAt,
+    updatedAt: run.updatedAt,
+    historyCount: run.historyCount,
+    unreadMessages: run.unreadMessages,
+    turnGeneration: run.turnGeneration,
+    pendingCompletionCount: run.pendingCompletionCount
+  };
+}
+function projectRun(run, ctx) {
+  return {
+    ...projectRunSummary(run),
+    cwd: safeDisplayPath(run.cwd, ctx.cwd),
+    workspaceMode: run.workspaceMode ?? "shared",
+    thinkingLevel: run.thinkingLevel,
+    timeoutMs: run.timeoutMs,
+    currentTimeoutMs: run.currentTimeoutMs,
+    idleTimeoutMs: run.idleTimeoutMs,
+    currentIdleTimeoutMs: run.currentIdleTimeoutMs,
+    maxTurns: run.maxTurns,
+    currentMaxTurns: run.currentMaxTurns,
+    maxToolCalls: run.maxToolCalls,
+    currentMaxToolCalls: run.currentMaxToolCalls,
+    context: {
+      turns: run.contextTurns ?? 0,
+      sources: run.contextSources ?? 0,
+      bytes: run.contextBytes ?? 0,
+      truncated: run.contextTruncated === true
+    },
+    contract: run.contract ? {
+      version: run.contract.version,
+      level: run.contract.level,
+      taskId: boundedPrivateText(run.contract.taskId, 256),
+      enforcement: run.contract.enforcement,
+      dependencies: run.contract.dependencies.length,
+      acceptanceCriteria: run.contract.acceptanceCriteria.length,
+      requiredEvidence: run.contract.requiredEvidence.length
+    } : void 0,
+    resultFormat: run.resultFormat ?? "text",
+    structuredResult: run.structuredResult,
+    termination: run.termination,
+    outcome: run.outcome,
+    capabilityGrant: run.capabilityGrant ? {
+      version: run.capabilityGrant.version,
+      id: run.capabilityGrant.id,
+      executionPlanId: run.capabilityGrant.executionPlanId,
+      taskGeneration: run.capabilityGrant.taskGeneration,
+      issuedAt: run.capabilityGrant.issuedAt,
+      expiresAt: run.capabilityGrant.expiresAt,
+      state: run.capabilityGrant.state,
+      revokedAt: run.capabilityGrant.revokedAt,
+      revocationReason: run.capabilityGrant.revocationReason
+    } : void 0,
+    executionPlan: run.executionPlan ? {
+      ...run.executionPlan,
+      target: {
+        ...run.executionPlan.target,
+        cwd: safeDisplayPath(run.executionPlan.target.cwd, ctx.cwd),
+        trust: { ...run.executionPlan.target.trust, sourcePath: void 0 }
+      }
+    } : void 0,
+    semanticSnapshot: run.semanticSnapshot ? {
+      version: run.semanticSnapshot.version,
+      digest: run.semanticSnapshot.digest,
+      components: { ...run.semanticSnapshot.components }
+    } : void 0,
+    semanticCompatibility: run.semanticCompatibility,
+    telemetry: run.telemetry,
+    currentRunId: run.currentRunId,
+    currentTurnGeneration: run.currentTurnGeneration,
+    currentTask: run.currentTask ? boundedPrivateText(run.currentTask, 2 * 1024) : void 0,
+    error: run.error ? boundedPrivateText(run.error, 2 * 1024) : void 0,
+    target: run.target ? {
+      cwd: safeDisplayPath(run.target.cwd, ctx.cwd),
+      boundary: run.target.boundary,
+      trust: {
+        kind: run.target.trust.kind,
+        projectTrusted: run.target.trust.projectTrusted,
+        sourcePath: run.target.trust.sourcePath ? safeDisplayPath(run.target.trust.sourcePath, ctx.cwd) : void 0,
+        warning: run.target.trust.warning ? boundedPrivateText(run.target.trust.warning, 512) : void 0
+      }
+    } : void 0,
+    policy: run.policy ? {
+      inherited: projectToolNames(run.policy.inherited),
+      overridden: projectToolNames(run.policy.overridden),
+      unsupported: projectToolNames(run.policy.unsupported)
+    } : void 0
+  };
+}
+function projectWorkflowSummary(workflow) {
+  return {
+    workflowId: boundedPrivateText(workflow.workflowId, 256),
+    generation: workflow.generation,
+    itemCount: workflow.items.length,
+    states: Object.fromEntries(
+      [...new Set(workflow.items.map((item) => item.state))].sort().map((state) => [state, workflow.items.filter((item) => item.state === state).length])
+    )
+  };
+}
+function projectWorkflow(workflow) {
+  const projected = boundedProjection(workflow.items, 64, (item) => ({
+    id: boundedPrivateText(item.id, 256),
+    state: item.state,
+    generation: item.generation,
+    taskGeneration: item.taskGeneration,
+    dependencies: item.dependencies.map((value) => boundedPrivateText(value, 256)),
+    assignedAgentId: item.assignedAgentId ? boundedPrivateText(item.assignedAgentId, 256) : void 0,
+    acceptedExecutionPlanId: item.acceptedExecutionPlanId,
+    artifacts: item.artifacts.map((artifact) => ({
+      id: boundedPrivateText(artifact.id, 256),
+      kind: boundedPrivateText(artifact.kind, 256),
+      version: boundedPrivateText(artifact.version, 256),
+      producerTaskId: artifact.producerTaskId ? boundedPrivateText(artifact.producerTaskId, 256) : void 0,
+      generation: artifact.generation,
+      verified: artifact.verified
+    })),
+    verificationAccepted: item.verificationAccepted,
+    acceptanceStateVersion: item.acceptanceStateVersion,
+    acceptanceRequired: item.acceptanceRequired,
+    acceptanceState: item.acceptanceState,
+    reworkCount: item.reworkCount,
+    maxReworkCycles: item.maxReworkCycles,
+    acceptanceReceipt: item.acceptanceReceipt ? {
+      version: item.acceptanceReceipt.version,
+      decision: item.acceptanceReceipt.decision,
+      targetTaskId: boundedPrivateText(item.acceptanceReceipt.targetTaskId, 256),
+      targetTaskGeneration: item.acceptanceReceipt.targetTaskGeneration,
+      targetExecutionPlanId: item.acceptanceReceipt.targetExecutionPlanId,
+      verifierTaskId: boundedPrivateText(item.acceptanceReceipt.verifierTaskId, 256),
+      verifierTaskGeneration: item.acceptanceReceipt.verifierTaskGeneration,
+      verifierExecutionPlanId: item.acceptanceReceipt.verifierExecutionPlanId,
+      verifierAgent: boundedPrivateText(item.acceptanceReceipt.verifierAgent, 256),
+      beforeTreeIdentity: item.acceptanceReceipt.beforeTreeIdentity,
+      afterTreeIdentity: item.acceptanceReceipt.afterTreeIdentity,
+      patchDigest: item.acceptanceReceipt.patchDigest,
+      changedPathCount: item.acceptanceReceipt.changedPaths.length,
+      checkCount: item.acceptanceReceipt.checks.length,
+      requiredEvidenceCount: item.acceptanceReceipt.requiredEvidenceIds.length,
+      createdAt: item.acceptanceReceipt.createdAt,
+      sourceTruncated: item.acceptanceReceipt.sourceTruncated
+    } : void 0,
+    acceptanceReceiptHistoryCount: item.acceptanceReceiptHistory.length,
+    stagedTreeIdentity: item.stagedTreeIdentity ? {
+      version: item.stagedTreeIdentity.version,
+      kind: item.stagedTreeIdentity.kind,
+      digest: item.stagedTreeIdentity.digest
+    } : void 0,
+    verificationReceipt: item.verificationReceipt ? {
+      version: item.verificationReceipt.version,
+      decision: item.verificationReceipt.decision,
+      targetTaskId: boundedPrivateText(item.verificationReceipt.targetTaskId, 256),
+      targetTaskGeneration: item.verificationReceipt.targetTaskGeneration,
+      targetExecutionPlanId: item.verificationReceipt.targetExecutionPlanId,
+      verifierTaskId: boundedPrivateText(item.verificationReceipt.verifierTaskId, 256),
+      verifierTaskGeneration: item.verificationReceipt.verifierTaskGeneration,
+      verifierExecutionPlanId: item.verificationReceipt.verifierExecutionPlanId,
+      treeIdentity: item.verificationReceipt.treeIdentity,
+      summary: boundedPrivateText(item.verificationReceipt.summary, 8 * 1024),
+      evidenceCount: item.verificationReceipt.evidence.length,
+      limitationCount: item.verificationReceipt.limitations.length,
+      createdAt: item.verificationReceipt.createdAt,
+      truncated: item.verificationReceipt.truncated
+    } : void 0,
+    outcomeReason: item.outcomeReason ? boundedPrivateText(item.outcomeReason, 2 * 1024) : void 0
+  }));
+  return {
+    ...projectWorkflowSummary(workflow),
+    items: projected.items,
+    omittedItems: projected.omitted
+  };
+}
+function projectModels(ctx, limit) {
+  const scoped = ctx.scopedModels ?? [];
+  const candidates = scoped.length > 0 ? scoped : ctx.modelRegistry.getAvailable().map((model) => ({ model, thinkingLevel: void 0 }));
+  const selected = boundedProjection(candidates, limit, ({ model, thinkingLevel }) => ({
+    provider: boundedPrivateText(model.provider, 256),
+    id: boundedPrivateText(model.id, 256),
+    name: boundedPrivateText(model.name, 256),
+    reasoning: model.reasoning,
+    input: [...model.input],
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+    thinkingLevel,
+    current: ctx.model?.provider === model.provider && ctx.model?.id === model.id
+  }));
+  return {
+    models: selected.items,
+    returned: selected.items.length,
+    omitted: selected.omitted,
+    source: scoped.length > 0 ? "session scope" : "available snapshot"
+  };
+}
+function projectStatus(runtime) {
+  const stateful = runtime.getRuntimeStatus();
+  const workflow = resolveDelegationWorkflow(runtime.getBlockingEnabled(), stateful.enabled);
+  const configured = inspectDelegationWorkflowSettings();
+  const resources = inspectConsultResourceSettings();
+  const cwdPolicy = inspectCwdPolicySettings();
+  const completion = inspectCompletionDeliverySettings();
+  const parallelLimit = inspectBlockingParallelLimitSettings();
+  const detachedLimits = inspectStatefulLimitSettings();
+  const transport = inspectStatefulTransportSettings();
+  const configuredDetachedLimits = detachedLimits.values ? Object.fromEntries(
+    Object.entries(detachedLimits.values).map(([field, snapshot]) => [field, snapshot.value])
+  ) : void 0;
+  const configuredDetachedLimitSources = detachedLimits.values ? Object.fromEntries(
+    Object.entries(detachedLimits.values).map(([field, snapshot]) => [field, snapshot.source])
+  ) : void 0;
+  return {
+    workflow,
+    configuredWorkflow: configured.value,
+    configuredWorkflowSource: configured.source,
+    stateful,
+    statefulLimits: stateful.limits,
+    configuredTransport: transport.value,
+    configuredTransportSource: transport.source,
+    configuredStatefulLimits: configuredDetachedLimits,
+    configuredStatefulLimitSources: configuredDetachedLimitSources,
+    configuredCompletionDelivery: completion.value,
+    configuredCompletionDeliverySource: completion.source,
+    maxParallelTasks: runtime.getMaxParallelTasks(),
+    configuredMaxParallelTasks: parallelLimit.value,
+    configuredMaxParallelTasksSource: parallelLimit.source,
+    consultResources: runtime.getConsultResourcePolicy(),
+    consultationCwdPolicy: runtime.getConsultationCwdPolicy(),
+    configuredConsultationCwdPolicy: cwdPolicy.consultation.value,
+    consultationCwdPolicySource: cwdPolicy.consultation.source,
+    delegationCwdPolicy: runtime.getDelegationCwdPolicy(),
+    configuredDelegationCwdPolicy: cwdPolicy.delegation.value,
+    delegationCwdPolicySource: cwdPolicy.delegation.source,
+    configuredConsultResources: resources.value,
+    consultResourcesSource: resources.source,
+    settingsPath: safeDisplayPath(resources.path, process.cwd()),
+    settingsError: configured.error || resources.error || cwdPolicy.error || completion.error || parallelLimit.error || detachedLimits.error || transport.error ? boundedPrivateText(
+      configured.error ?? resources.error ?? cwdPolicy.error ?? completion.error ?? parallelLimit.error ?? detachedLimits.error ?? transport.error ?? "",
+      2 * 1024
+    ) : void 0
+  };
+}
+async function inspectInProcessCapability() {
+  try {
+    const moduleSpecifier = "@earendil-works/pi-coding-agent";
+    const core = await import(moduleSpecifier);
+    for (const name of [
+      "createAgentSessionServices",
+      "createAgentSessionFromServices",
+      "resolveCliModel"
+    ]) {
+      if (typeof core[name] !== "function") return { error: `Pi core does not export ${name}()` };
+    }
+    return {};
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function inspectRpcCapability() {
+  try {
+    resolvePiInvocation(["--mode", "rpc", "--no-session"]);
+    return {};
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function availableModelCount(ctx) {
+  return (ctx.scopedModels?.length ?? 0) > 0 ? ctx.scopedModels.length : ctx.modelRegistry.getAvailable().length;
+}
+function projectToolNames(tools) {
+  return tools.slice(0, 100).map((tool) => boundedPrivateText(tool, 256));
+}
+function boundedProjection(values, limit, project) {
+  const items = [];
+  for (const value of values.slice(0, limit)) {
+    const next = project(value);
+    if (Buffer.byteLength(JSON.stringify([...items, next]), "utf8") > MAX_DETAILS_LIST_BYTES) break;
+    items.push(next);
+  }
+  return { items, omitted: Math.max(0, values.length - items.length) };
+}
+function inspectResult(details) {
+  const rendered = boundText(JSON.stringify(details, null, 2));
+  return {
+    content: [{ type: "text", text: rendered.text }],
+    details: { ...details, ...rendered.truncated ? { truncated: true } : {} }
+  };
+}
+function assertTrustedScope(scope, ctx) {
+  if ((scope === "project" || scope === "both") && !ctx.isProjectTrusted()) {
+    throw new Error("Project-local subagent definitions require a trusted project");
+  }
+}
+function parameterRecord(params) {
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    throw new Error("subagent_inspect parameters must be an object");
+  }
+  return params;
+}
+function optionalAgentScope(value) {
+  if (value === void 0) return "user";
+  if (value === "user" || value === "project" || value === "both") return value;
+  throw new Error("subagent_inspect agentScope must be user, project, or both");
+}
+function requiredString(value, action, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`subagent_inspect action "${action}" requires ${field}`);
+  }
+  return value;
+}
+function optionalContextMode(value) {
+  if (value === void 0) return "none";
+  if (value === "none" || value === "all" || value === "summary") return value;
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 1) return value;
+  throw new Error("subagent_inspect context must be none, all, summary, or a positive integer");
+}
+function optionalStringArray(value, field) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string" && item.length > 0)) {
+    throw new Error(`subagent_inspect ${field} must be an array of non-empty strings`);
+  }
+  return [...value];
+}
+function optionalLimit(value, defaultValue) {
+  if (value === void 0) return defaultValue;
+  if (!Number.isSafeInteger(value) || value < 1 || value > 100) {
+    throw new Error("subagent_inspect limit must be an integer between 1 and 100");
+  }
+  return value;
+}
+export {
+  SubagentInspectParams,
+  executeSubagentInspect,
+  registerSubagentInspect,
+  validateInspectParams
+};
+//# sourceMappingURL=inspect-UOQQ3KNL.ts.map