@gaodefa/daocore 2026.5.51 → 2026.5.53

package/dist/agent-command-DKqx29vm.d.ts

@@ -0,0 +1,105 @@
+import { Cn as AgentDefaultsConfig, r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { t as PluginManifestRecord } from "./manifest-registry-BytIqZ_A.js";
+import { o as VerboseLevel, r as ThinkLevel } from "./thinking.shared-DZFlsfdo.js";
+import { m as EmbeddedPiRunMeta, v as MessagingToolSend } from "./params-CZRWWXHe.js";
+import { o as SessionEntry } from "./types-BdMfZf_9.js";
+import { t as ModelCatalogEntry } from "./model-catalog.types-BnioQy7H.js";
+import { n as RuntimeEnv } from "./runtime-Bxifh4bY.js";
+import { t as CliDeps } from "./deps.types-C8BV1CgG.js";
+import { a as OutboundSessionContext } from "./delivery-queue-DitW7GIi.js";
+import { l as projectOutboundPayloadPlanForJson } from "./deliver-DtSJvo0O.js";
+import { s as AcpSessionResolution, t as AcpSessionManager } from "./manager.core-DKeUsAcV.js";
+import { n as AgentCommandOpts, r as AgentCommandResultMetaOverrides, t as AgentCommandIngressOpts } from "./types-DwvSRNfE.js";
+
+//#region src/agents/command/delivery.d.ts
+type AgentCommandDeliveryPayloadStatus = "sent" | "suppressed" | "failed";
+type AgentCommandDeliveryPayloadOutcome = {
+  index: number;
+  status: AgentCommandDeliveryPayloadStatus;
+  reason?: string;
+  resultCount?: number;
+  sentBeforeError?: boolean;
+  stage?: string;
+  error?: string;
+  hookEffect?: {
+    cancelReason?: string;
+    metadata?: Record<string, unknown>;
+  };
+};
+type AgentCommandDeliveryStatus = {
+  requested: true;
+  attempted: boolean;
+  status: "sent" | "suppressed" | "partial_failed" | "failed"; /** `partial` means at least one payload was sent before a later payload failed. */
+  succeeded: true | false | "partial";
+  error?: true;
+  errorMessage?: string; /** Free-form lowercase_snake reason from durable delivery or preflight validation. */
+  reason?: string;
+  resultCount?: number;
+  sentBeforeError?: true;
+  payloadOutcomes?: AgentCommandDeliveryPayloadOutcome[];
+};
+type AgentCommandDeliveryResult = {
+  payloads: ReturnType<typeof projectOutboundPayloadPlanForJson>;
+  meta: EmbeddedPiRunMeta & AgentCommandResultMetaOverrides;
+  didSendViaMessagingTool?: boolean;
+  messagingToolSentTexts?: string[];
+  messagingToolSentMediaUrls?: string[];
+  messagingToolSentTargets?: MessagingToolSend[];
+  deliverySucceeded?: boolean;
+  deliveryStatus?: AgentCommandDeliveryStatus;
+};
+//#endregion
+//#region src/agents/agent-runtime-config.d.ts
+declare function resolveAgentRuntimeConfig(runtime: RuntimeEnv, params?: {
+  runtimeTargetsChannelSecrets?: boolean;
+}): Promise<{
+  loadedRaw: DaoCoreConfig;
+  sourceConfig: DaoCoreConfig;
+  cfg: DaoCoreConfig;
+}>;
+//#endregion
+//#region src/agents/agent-command.d.ts
+declare function prepareAgentCommandExecution(opts: AgentCommandOpts, runtime: RuntimeEnv): Promise<{
+  body: string;
+  transcriptBody: string;
+  cfg: DaoCoreConfig;
+  configuredThinkingCatalog: ModelCatalogEntry[];
+  normalizedSpawned: {
+    spawnedBy?: string;
+    groupId?: string;
+    groupChannel?: string;
+    groupSpace?: string;
+    workspaceDir?: string;
+  };
+  agentCfg: AgentDefaultsConfig | undefined;
+  thinkOverride: ThinkLevel | undefined;
+  thinkOnce: ThinkLevel | undefined;
+  verboseOverride: VerboseLevel | undefined;
+  timeoutMs: number;
+  sessionId: string;
+  sessionKey: string | undefined;
+  sessionEntry: SessionEntry | undefined;
+  sessionStore: Record<string, SessionEntry> | undefined;
+  storePath: string;
+  isNewSession: boolean;
+  persistedThinking: ThinkLevel | undefined;
+  persistedVerbose: VerboseLevel | undefined;
+  sessionAgentId: string;
+  outboundSession: OutboundSessionContext | undefined;
+  workspaceDir: string;
+  agentDir: string;
+  modelManifestContext: {
+    manifestPlugins: readonly PluginManifestRecord[];
+  };
+  runId: string;
+  acpManager: AcpSessionManager;
+  acpResolution: AcpSessionResolution | null;
+}>;
+declare function agentCommand(opts: AgentCommandOpts, runtime?: RuntimeEnv, deps?: CliDeps): Promise<AgentCommandDeliveryResult>;
+declare function agentCommandFromIngress(opts: AgentCommandIngressOpts, runtime?: RuntimeEnv, deps?: CliDeps): Promise<AgentCommandDeliveryResult>;
+declare const testing: {
+  resolveAgentRuntimeConfig: typeof resolveAgentRuntimeConfig;
+  prepareAgentCommandExecution: typeof prepareAgentCommandExecution;
+};
+//#endregion
+export { agentCommandFromIngress as n, testing as r, agentCommand as t };

package/dist/agent-components.runtime-Drdzm2-F.js

@@ -0,0 +1,10 @@
+import { t as createReplyReferencePlanner } from "./reply-reference-OJ849bWH.js";
+import { c as resolveTextChunkLimit, s as resolveChunkMode } from "./chunk-DeZRGIEM.js";
+import { f as parsePluginBindingApprovalCustomId, i as buildPluginBindingResolvedText, m as resolvePluginConversationBindingApproval } from "./conversation-binding-Ce5V8uhy.js";
+import { t as finalizeInboundContext } from "./inbound-context-Cg0uCtqQ.js";
+import { t as dispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher-CGPKPaP5.js";
+import { t as recordInboundSession } from "./session-DDNzwYpl.js";
+import "./reply-runtime-SSrAwVeQ.js";
+import "./conversation-runtime-Das7yftQ.js";
+import { r as dispatchPluginInteractiveHandler } from "./plugin-runtime-TPqTSJyy.js";
+export { buildPluginBindingResolvedText, createReplyReferencePlanner, dispatchPluginInteractiveHandler, dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, parsePluginBindingApprovalCustomId, recordInboundSession, resolveChunkMode, resolvePluginConversationBindingApproval, resolveTextChunkLimit };

package/dist/agent-components.runtime.js

@@ -1 +1 @@
-export * from "./agent-components.runtime-CP2KCzTj.js";
+export * from "./agent-components.runtime-Drdzm2-F.js";

package/dist/agent-harness-CGtBwZh6.d.ts

@@ -0,0 +1,146 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { o as ModelCompatConfig } from "./types.models-BXrRAuSB.js";
+import { a as SourceReplyDeliveryMode } from "./get-reply-options.types-BXrapyJ-.js";
+import { f as ExecToolDefaults } from "./params-CZRWWXHe.js";
+import { n as InboundEventKind } from "./input-provenance-DgsxhTbk.js";
+import { t as DiagnosticTraceContext } from "./diagnostic-trace-context-DcbwO2-o.js";
+import { n as SkillSnapshot } from "./skills-BRkHvK1T.js";
+import { s as AuthProfileStore } from "./types-dSHooml1.js";
+import { r as AnyAgentTool } from "./common-BDN0bXby.js";
+import { Oi as ToolOutcomeObserver } from "./types-DHSQkzyq2.js";
+import { t as ModelAuthMode } from "./model-auth-CHSCk61_.js";
+import { r as SandboxContext } from "./types-kd_AtXCR.js";
+import { t as ProcessToolDefaults } from "./bash-tools.process-BKy5qLNB.js";
+import { TSchema } from "typebox";
+import { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { AgentMessage, AgentToolResult, AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
+
+//#region src/agents/tool-search.d.ts
+type CatalogSource = "daocore" | "mcp" | "client";
+type CatalogTool = AnyAgentTool | ToolDefinition;
+type ToolSearchCatalogToolExecutor = (params: {
+  tool: CatalogTool;
+  toolName: string;
+  toolCallId: string;
+  parentToolCallId?: string;
+  input: unknown;
+  signal?: AbortSignal;
+  onUpdate?: AgentToolUpdateCallback<unknown>;
+}) => Promise<AgentToolResult<unknown>>;
+type ToolSearchCatalogEntry = {
+  id: string;
+  source: CatalogSource;
+  sourceName?: string;
+  name: string;
+  label?: string;
+  description: string;
+  parameters?: unknown;
+  tool: CatalogTool;
+};
+type ToolSearchCatalogSession = {
+  entries: ToolSearchCatalogEntry[];
+  searchCount: number;
+  describeCount: number;
+  callCount: number;
+};
+type ToolSearchCatalogRef = {
+  current?: ToolSearchCatalogSession;
+};
+//#endregion
+//#region src/agents/pi-tools.d.ts
+type DaoCoreCodingToolConstructionPlan = {
+  includeBaseCodingTools: boolean;
+  includeShellTools: boolean;
+  includeChannelTools: boolean;
+  includeDaoCoreTools: boolean;
+  includePluginTools: boolean;
+};
+declare function createDaoCoreCodingTools(options?: {
+  agentId?: string;
+  exec?: ExecToolDefaults & ProcessToolDefaults;
+  messageProvider?: string;
+  agentAccountId?: string;
+  messageTo?: string;
+  messageThreadId?: string | number;
+  sandbox?: SandboxContext | null;
+  sessionKey?: string;
+  /**
+   * The actual live run session key. When the tool set is constructed with a
+   * sandbox/policy session key, this allows `session_status({sessionKey:"current"})`
+   * to resolve to the live run session instead of the stale sandbox key.
+   */
+  runSessionKey?: string; /** Ephemeral session UUID — regenerated on /new and /reset. */
+  sessionId?: string; /** Stable run identifier for this agent invocation. */
+  runId?: string; /** Diagnostic trace context for hook/log correlation during this run. */
+  trace?: DiagnosticTraceContext; /** What initiated this run (for trigger-specific tool restrictions). */
+  trigger?: string; /** Stable cron job identifier populated for cron-triggered runs. */
+  jobId?: string; /** Relative workspace path that memory-triggered writes may append to. */
+  memoryFlushWritePath?: string;
+  agentDir?: string;
+  workspaceDir?: string;
+  /**
+   * Workspace directory that spawned subagents should inherit.
+   * When sandboxing uses a copied workspace (`ro` or `none`), workspaceDir is the
+   * sandbox copy but subagents should inherit the real agent workspace instead.
+   * Defaults to workspaceDir when not set.
+   */
+  spawnWorkspaceDir?: string;
+  config?: DaoCoreConfig;
+  abortSignal?: AbortSignal; /** Disable hook-owned diagnostics when an outer runtime owns tool diagnostics. */
+  emitBeforeToolCallDiagnostics?: boolean;
+  /**
+   * Provider of the currently selected model (used for provider-specific tool quirks).
+   * Example: "anthropic", "openai", "google", "openai-codex".
+   */
+  modelProvider?: string; /** Model id for the current provider (used for model-specific tool gating). */
+  modelId?: string; /** Model API for the current provider (used for provider-native tool arbitration). */
+  modelApi?: string; /** Model context window in tokens (used to scale read-tool output budget). */
+  modelContextWindowTokens?: number; /** Resolved runtime model compatibility hints. */
+  modelCompat?: ModelCompatConfig; /** If false, keep DaoCore web_search even when a provider-native search tool is active. */
+  suppressManagedWebSearch?: boolean;
+  /**
+   * Auth mode for the current provider. We only need this for Anthropic OAuth
+   * tool-name blocking quirks.
+   */
+  modelAuthMode?: ModelAuthMode; /** Current channel ID for auto-threading (Slack). */
+  currentChannelId?: string; /** Normalized conversation id exposed to tool hooks. Defaults to currentChannelId. */
+  hookChannelId?: string; /** Current thread timestamp for auto-threading (Slack). */
+  currentThreadTs?: string; /** Current inbound message id for action fallbacks (e.g. Telegram react). */
+  currentMessageId?: string | number; /** Group id for channel-level tool policy resolution. */
+  groupId?: string | null; /** Group channel label (e.g. #general) for channel-level tool policy resolution. */
+  groupChannel?: string | null; /** Group space label (e.g. guild/team id) for channel-level tool policy resolution. */
+  groupSpace?: string | null; /** Trusted provider role ids for the requester in this group turn. */
+  memberRoleIds?: string[]; /** Parent session key for subagent group policy inheritance. */
+  spawnedBy?: string | null;
+  senderId?: string | null;
+  senderName?: string | null;
+  senderUsername?: string | null;
+  senderE164?: string | null; /** Reply-to mode for Slack auto-threading. */
+  replyToMode?: "off" | "first" | "all" | "batched"; /** Mutable ref to track if a reply was sent (for "first" mode). */
+  hasRepliedRef?: {
+    value: boolean;
+  }; /** Allow plugin tools for this run to late-bind the gateway subagent. */
+  allowGatewaySubagentBinding?: boolean; /** Runtime-scoped explicit allowlist used to materialize matching plugin tools. */
+  runtimeToolAllowlist?: string[]; /** If true, the model has native vision capability */
+  modelHasVision?: boolean; /** Require explicit message targets (no implicit last-route sends). */
+  requireExplicitMessageTarget?: boolean; /** Visible source replies must be sent through the message tool when set to message_tool_only. */
+  sourceReplyDeliveryMode?: SourceReplyDeliveryMode;
+  inboundEventKind?: InboundEventKind; /** If true, omit the message tool from the tool list. */
+  disableMessageTool?: boolean; /** Keep the message tool available even when the selected profile omits it. */
+  forceMessageTool?: boolean; /** Include the heartbeat response tool for structured heartbeat outcomes. */
+  enableHeartbeatTool?: boolean; /** Keep the heartbeat response tool available even when the selected profile omits it. */
+  forceHeartbeatTool?: boolean; /** If false, build plugin tools only while preserving the shared policy pipeline. */
+  includeCoreTools?: boolean; /** Include Tool Search control tools when enabled for this run. */
+  includeToolSearchControls?: boolean; /** Executes cataloged tools through the active PI run lifecycle. */
+  toolSearchCatalogExecutor?: ToolSearchCatalogToolExecutor; /** Runtime-local Tool Search catalog ref shared with PI attempt compaction. */
+  toolSearchCatalogRef?: ToolSearchCatalogRef; /** Limits which tool families are materialized before the shared policy pipeline runs. */
+  toolConstructionPlan?: DaoCoreCodingToolConstructionPlan; /** Trusted sender identity bit for command/channel-action auth; does not filter model tools. */
+  senderIsOwner?: boolean; /** Auth profiles already loaded for this run; used for prompt-time tool availability. */
+  authProfileStore?: AuthProfileStore; /** Callback invoked when sessions_yield tool is called. */
+  onYield?: (message: string) => Promise<void> | void; /** Optional instrumentation callback for tool preparation stage timing. */
+  recordToolPrepStage?: (name: string) => void; /** Live observer called after wrapped tool outcomes are recorded. */
+  onToolOutcome?: ToolOutcomeObserver; /** Runtime-only resolved skill paths that the read tool may load under workspaceOnly. */
+  skillsSnapshot?: SkillSnapshot;
+}): AnyAgentTool[];
+//#endregion
+export { createDaoCoreCodingTools as t };

package/dist/agent-harness-runtime-Btzminw9.js

@@ -0,0 +1,180 @@
+import { c as redactToolDetail } from "./redact-BjrmHGQ6.js";
+import "./errors-D_oyTIw2.js";
+import { y as truncateUtf16Safe } from "./utils-CNnMhEDp.js";
+import "./version-QmPt05QD.js";
+import "./agent-scope-Dx1S0aWX.js";
+import { t as createSubsystemLogger } from "./subsystem-CppbuBPw.js";
+import "./registry-Crj56k7x.js";
+import { b as listCodexAppServerExtensionFactories } from "./loader-CZqEc_1x.js";
+import { c as joinPresentTextSegments, t as getGlobalHookRunner } from "./hook-runner-global-RR7B_IHd.js";
+import "./registry-BCmRCXCi.js";
+import "./transcript-CalMl_Y7.js";
+import "./session-write-lock-DvfEpka6.js";
+import { u as queueEmbeddedPiMessageWithOutcome } from "./runs-SleIj69Z.js";
+import "./heartbeat-tool-response-BCz-9pPv.js";
+import "./bootstrap-files-CqPzStB_.js";
+import "./pi-tools.before-tool-call-Cl9Ivz5u.js";
+import "./gateway-Dyc7qEu3.js";
+import "./model-auth-D1amzkLm.js";
+import "./attempt.tool-run-context-DBta4Vhq.js";
+import { r as resolveToolDisplay, t as formatToolDetail } from "./tool-display-B0WPzVuH.js";
+import "./channel-streaming-BBW2i40H.js";
+import "./logger-DYJ7BvAc.js";
+import "./nodes-utils-CIusEv3-.js";
+import "./sandbox-BgrNfelZ.js";
+import "./context-engine-lifecycle-CxxoOuT8.js";
+import "./result-fallback-classifier-B3kvqc2o.js";
+import "./build-CrC0bToI.js";
+import { o as buildAgentHookContext } from "./lifecycle-hook-helpers-DsCr5Yp0.js";
+import "./agent-dir-compat-X9XMR4LI.js";
+import "./native-hook-relay-D1fhxt1n.js";
+//#region src/agents/harness/prompt-compaction-hook-helpers.ts
+const log$1 = createSubsystemLogger("agents/harness");
+async function resolveAgentHarnessBeforePromptBuildResult(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("before_prompt_build") && !hookRunner?.hasHooks("before_agent_start")) return {
+		prompt: params.prompt,
+		developerInstructions: params.developerInstructions
+	};
+	const hookCtx = buildAgentHookContext(params.ctx);
+	const promptEvent = {
+		prompt: params.prompt,
+		messages: params.messages
+	};
+	const promptBuildResult = hookRunner.hasHooks("before_prompt_build") ? await hookRunner.runBeforePromptBuild(promptEvent, hookCtx).catch((error) => {
+		log$1.warn(`before_prompt_build hook failed: ${String(error)}`);
+	}) : void 0;
+	const legacyResult = hookRunner.hasHooks("before_agent_start") ? await hookRunner.runBeforeAgentStart(promptEvent, hookCtx).catch((error) => {
+		log$1.warn(`before_agent_start hook (legacy prompt build path) failed: ${String(error)}`);
+	}) : void 0;
+	const systemPrompt = resolvePromptBuildSystemPrompt({
+		developerInstructions: params.developerInstructions,
+		promptBuildResult,
+		legacyResult
+	});
+	return {
+		prompt: joinPresentTextSegments([
+			promptBuildResult?.prependContext,
+			legacyResult?.prependContext,
+			params.prompt
+		]) ?? params.prompt,
+		developerInstructions: joinPresentTextSegments([
+			promptBuildResult?.prependSystemContext,
+			legacyResult?.prependSystemContext,
+			systemPrompt,
+			promptBuildResult?.appendSystemContext,
+			legacyResult?.appendSystemContext
+		]) ?? systemPrompt
+	};
+}
+function resolvePromptBuildSystemPrompt(params) {
+	if (typeof params.promptBuildResult?.systemPrompt === "string") return params.promptBuildResult.systemPrompt;
+	if (typeof params.legacyResult?.systemPrompt === "string") return params.legacyResult.systemPrompt;
+	return params.developerInstructions;
+}
+async function runAgentHarnessBeforeCompactionHook(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("before_compaction")) return;
+	try {
+		await hookRunner.runBeforeCompaction({
+			messageCount: params.messages.length,
+			messages: params.messages,
+			sessionFile: params.sessionFile
+		}, buildAgentHookContext(params.ctx));
+	} catch (error) {
+		log$1.warn(`before_compaction hook failed: ${String(error)}`);
+	}
+}
+async function runAgentHarnessAfterCompactionHook(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("after_compaction")) return;
+	try {
+		await hookRunner.runAfterCompaction({
+			messageCount: params.messages.length,
+			compactedCount: params.compactedCount,
+			sessionFile: params.sessionFile
+		}, buildAgentHookContext(params.ctx));
+	} catch (error) {
+		log$1.warn(`after_compaction hook failed: ${String(error)}`);
+	}
+}
+//#endregion
+//#region src/agents/harness/codex-app-server-extensions.ts
+const log = createSubsystemLogger("agents/harness");
+function createCodexAppServerToolResultExtensionRunner(ctx, factories = listCodexAppServerExtensionFactories()) {
+	const handlers = [];
+	const runtime = { on(event, handler) {
+		if (event === "tool_result") handlers.push(handler);
+	} };
+	const initPromise = (async () => {
+		for (const factory of factories) await factory(runtime);
+	})();
+	return { async applyToolResultExtensions(event) {
+		await initPromise;
+		let current = event.result;
+		for (const handler of handlers) try {
+			const next = await handler({
+				...event,
+				result: current
+			}, ctx);
+			if (next?.result) current = next.result;
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			log.warn(`[codex] tool_result extension failed for ${event.toolName}: ${detail}`);
+		}
+		return current;
+	} };
+}
+//#endregion
+//#region src/plugin-sdk/agent-harness-runtime.ts
+const TOOL_PROGRESS_OUTPUT_MAX_CHARS = 8e3;
+/**
+* @deprecated Active-run queueing is an internal runtime concern. This legacy
+* boolean API only reports immediate queue eligibility and cannot observe async
+* runtime rejection; runtime-owned delivery paths should use acceptance-aware
+* steering instead of public SDK queueing.
+*/
+function queueAgentHarnessMessage(sessionId, text, options) {
+	return queueEmbeddedPiMessageWithOutcome(sessionId, text, options).queued;
+}
+async function loadCodexBundleMcpThreadConfig(params) {
+	const { loadCodexBundleMcpThreadConfig: load } = await import("./codex-mcp-config-DzOPUScO.js");
+	return load(params);
+}
+function inferToolMetaFromArgs(toolName, args, options) {
+	return formatToolDetail(resolveToolDisplay({
+		name: toolName,
+		args,
+		detailMode: options?.detailMode
+	}));
+}
+/**
+* Prepare verbose tool output for user-facing progress messages.
+*/
+function formatToolProgressOutput(output, options) {
+	const trimmed = output.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+	if (!trimmed) return;
+	const redacted = redactToolDetail(trimmed);
+	const maxChars = options?.maxChars ?? 8e3;
+	if (redacted.length <= maxChars) return redacted;
+	return `${truncateUtf16Safe(redacted, maxChars)}\n...(truncated)...`;
+}
+/**
+* Classify terminal harness turns that completed without assistant output that
+* should advance fallback. Deliberate silent replies such as NO_REPLY count as
+* intentional output, while whitespace-only text remains fallback-eligible.
+* This is intentionally SDK-level so plugin harness adapters such as Codex
+* preserve the same DaoCore-owned fallback signals as the built-in PI path
+* without re-implementing terminal-result policy.
+*/
+function classifyAgentHarnessTerminalOutcome(params) {
+	if (!params.turnCompleted || params.promptError !== void 0 && params.promptError !== null || hasVisibleAssistantText(params.assistantTexts)) return;
+	if (params.planText?.trim()) return "planning-only";
+	if (params.reasoningText?.trim()) return "reasoning-only";
+	return "empty";
+}
+function hasVisibleAssistantText(assistantTexts) {
+	return assistantTexts.some((text) => text.trim().length > 0);
+}
+//#endregion
+export { loadCodexBundleMcpThreadConfig as a, resolveAgentHarnessBeforePromptBuildResult as c, inferToolMetaFromArgs as i, runAgentHarnessAfterCompactionHook as l, classifyAgentHarnessTerminalOutcome as n, queueAgentHarnessMessage as o, formatToolProgressOutput as r, createCodexAppServerToolResultExtensionRunner as s, TOOL_PROGRESS_OUTPUT_MAX_CHARS as t, runAgentHarnessBeforeCompactionHook as u };

package/dist/agent-harness-task-runtime-DWiDnwnT.js

@@ -0,0 +1,140 @@
+import { r as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-core-C7o0LP7q.js";
+import "./message-channel-CRza_Xs_.js";
+import { So as AGENT_INTERNAL_EVENT_TYPE_TASK_COMPLETION } from "./protocol-BqIJbb8x.js";
+import { f as listTaskRecords } from "./task-registry-XxKmge32.js";
+import "./runtime-internal-CQ1hy6SS.js";
+import { c as recordTaskRunProgressByRunId, i as createRunningTaskRun, l as setDetachedTaskDeliveryStatusByRunId, o as finalizeTaskRunByRunId } from "./detached-task-runtime-B8jNifvc.js";
+import { n as isInternalAnnounceRequesterSession, o as resolveSubagentCompletionOrigin, r as loadRequesterSessionEntry, t as deliverSubagentAnnouncement } from "./subagent-announce-delivery-16skgjOt.js";
+import { n as formatAgentInternalEventsForPrompt } from "./internal-events-BS1EMi0C.js";
+import { n as buildAnnounceIdempotencyKey } from "./announce-idempotency-DV6_8Blm.js";
+import { t as assertAgentHarnessTaskRuntimeScope } from "./agent-harness-task-runtime-scope-7M8SSTK6.js";
+import { t as resolveAnnounceOrigin } from "./subagent-announce-origin-CB1tkSD0.js";
+//#region src/plugin-sdk/agent-harness-task-runtime.ts
+const AGENT_HARNESS_COMPLETION_SOURCE_TOOL = "agent_harness_task";
+function createAgentHarnessTaskRuntime(params) {
+	const runtime = params.runtime;
+	const requesterSessionKey = assertAgentHarnessTaskRuntimeScope(params.scope).requesterSessionKey;
+	const taskKind = normalizeOptionalString(params.taskKind);
+	const runIdPrefix = normalizeOptionalString(params.runIdPrefix);
+	const assertRunId = (runId) => assertScopedRunId(runId, runIdPrefix);
+	return {
+		createRunningTaskRun(taskParams) {
+			assertRunId(taskParams.runId);
+			return createRunningTaskRun({
+				...taskParams,
+				runtime,
+				...taskKind ? { taskKind } : {},
+				requesterSessionKey,
+				ownerKey: requesterSessionKey,
+				scopeKind: "session"
+			});
+		},
+		recordTaskRunProgressByRunId(taskParams) {
+			assertRunId(taskParams.runId);
+			return recordTaskRunProgressByRunId({
+				...taskParams,
+				runtime,
+				sessionKey: requesterSessionKey
+			});
+		},
+		finalizeTaskRunByRunId(taskParams) {
+			assertRunId(taskParams.runId);
+			return finalizeTaskRunByRunId({
+				...taskParams,
+				runtime,
+				sessionKey: requesterSessionKey
+			});
+		},
+		setDetachedTaskDeliveryStatusByRunId(taskParams) {
+			assertRunId(taskParams.runId);
+			return setDetachedTaskDeliveryStatusByRunId({
+				...taskParams,
+				runtime,
+				sessionKey: requesterSessionKey
+			});
+		},
+		listTaskRecords() {
+			return listTaskRecords().filter((task) => task.runtime === runtime && (!taskKind || task.taskKind === taskKind) && task.scopeKind === "session" && task.ownerKey === requesterSessionKey && (!runIdPrefix || task.runId?.startsWith(runIdPrefix)));
+		}
+	};
+}
+async function deliverAgentHarnessTaskCompletion(params) {
+	const scope = assertAgentHarnessTaskRuntimeScope(params.scope);
+	const requesterSessionKey = scope.requesterSessionKey;
+	const childSessionKey = params.childSessionKey.trim();
+	const childSessionId = params.childSessionId.trim();
+	const taskLabel = params.taskLabel?.trim() || "Agent harness task";
+	const announceType = params.announceType?.trim() || "Agent harness task";
+	const statusLabel = params.statusLabel?.trim() || params.status;
+	const eventStatus = mapHarnessCompletionStatus(params.status);
+	const requesterIsSubagent = isInternalAnnounceRequesterSession(requesterSessionKey);
+	let directOrigin = scope.requesterOrigin;
+	if (!requesterIsSubagent) {
+		const { entry } = loadRequesterSessionEntry(requesterSessionKey);
+		directOrigin = resolveAnnounceOrigin(entry, scope.requesterOrigin);
+	}
+	const completionDirectOrigin = requesterIsSubagent || !directOrigin ? directOrigin : await resolveSubagentCompletionOrigin({
+		childSessionKey,
+		requesterSessionKey,
+		requesterOrigin: directOrigin,
+		childRunId: childSessionKey,
+		spawnMode: "run",
+		expectsCompletionMessage: true
+	});
+	const internalEvents = [{
+		type: AGENT_INTERNAL_EVENT_TYPE_TASK_COMPLETION,
+		source: "subagent",
+		childSessionKey,
+		childSessionId,
+		announceType,
+		taskLabel,
+		status: eventStatus,
+		statusLabel,
+		result: params.result,
+		replyInstruction: params.replyInstruction?.trim() || "Use the completed harness task result to continue or wrap up the parent task. If this is a channel session, send the visible response with the message tool instead of only writing a transcript final answer."
+	}];
+	const prompt = formatAgentInternalEventsForPrompt(internalEvents);
+	return await deliverSubagentAnnouncement({
+		requesterSessionKey,
+		announceId: params.announceId,
+		triggerMessage: prompt,
+		steerMessage: prompt,
+		internalEvents,
+		summaryLine: taskLabel,
+		requesterSessionOrigin: scope.requesterOrigin,
+		requesterOrigin: completionDirectOrigin ?? directOrigin,
+		completionDirectOrigin: completionDirectOrigin ?? directOrigin,
+		directOrigin,
+		sourceSessionKey: childSessionKey,
+		sourceChannel: INTERNAL_MESSAGE_CHANNEL,
+		sourceTool: AGENT_HARNESS_COMPLETION_SOURCE_TOOL,
+		targetRequesterSessionKey: requesterSessionKey,
+		requesterIsSubagent,
+		expectsCompletionMessage: true,
+		bestEffortDeliver: true,
+		directIdempotencyKey: buildAnnounceIdempotencyKey(params.announceId),
+		signal: params.signal
+	});
+}
+function mapHarnessCompletionStatus(status) {
+	if (status === "succeeded") return "ok";
+	return "error";
+}
+function isDurableAgentHarnessCompletionDelivery(delivery) {
+	if (!delivery.delivered) return false;
+	if (delivery.path === "steered") return true;
+	if (delivery.path !== "direct") return false;
+	const phases = Array.isArray(delivery.phases) ? delivery.phases : void 0;
+	if (!phases) return true;
+	return phases.some((phase) => phase.phase === "direct-primary" && phase.delivered && phase.path === "direct");
+}
+function normalizeOptionalString(value) {
+	return value?.trim() || void 0;
+}
+function assertScopedRunId(runId, runIdPrefix) {
+	const normalized = runId.trim();
+	if (!normalized) throw new Error("Agent harness task runtime requires runId");
+	if (runIdPrefix && !normalized.startsWith(runIdPrefix)) throw new Error("Agent harness task runId is outside the configured scope");
+}
+//#endregion
+export { deliverAgentHarnessTaskCompletion as n, isDurableAgentHarnessCompletionDelivery as r, createAgentHarnessTaskRuntime as t };

package/dist/agent-nenZtwAX.js

@@ -0,0 +1,3 @@
+import { n as agentCommandFromIngress } from "./agent-command-DB0sppso.js";
+import "./agent-svdKN_62.js";
+export { agentCommandFromIngress };