@agentconnect.md/cli 1.15.0-rc.5 → 1.16.0

package/dist/index.js

@@ -7885,6 +7885,27 @@ const MemoryRecallPolicy = object({
 	timeoutMs: number().int().positive().max(MEMORY_RECALL_HARD_LIMITS.timeoutMs).default(MEMORY_RECALL_DEFAULTS.timeoutMs)
 }).strict();
 const MemoryCapturePolicy = object({ mode: _enum(["turn", "manual"]).default("manual") }).strict();
+/**
+* Dreaming — periodic offline consolidation of the MANAGED store
+* (design: docs/designs/memory-dreaming.md). Valid only with
+* `provider: 'managed'`; the daemon stages a rebuilt store per dream and the
+* user (or the gated auto-adopt path) reviews and adopts it. Bounds mirror the
+* design: sessionWindow ≤ 100 mined transcripts, instructions ≤ 4096 chars.
+*/
+const MemoryDreamingPolicy = object({
+	enabled: boolean(),
+	/** How many recent sessions to mine (default 20). */
+	sessionWindow: number().int().min(1).max(100).optional(),
+	/** Cron expression for scheduled dreams (same syntax as agent crons). */
+	schedule: string().min(1).max(128).optional(),
+	/** Operator steering text applied through the whole dream pipeline. */
+	instructions: string().max(4096).optional(),
+	/** Also mine reusable procedures into candidate skills (never auto-installed). */
+	mineSkills: boolean().optional(),
+	/** Adopt the staged store automatically on completion. Admissible only on
+	*  runtimes with a trusted extraction channel; the daemon enforces that. */
+	autoAdopt: boolean().optional()
+}).strict();
 /** Agent-facing provider selection. External bindings carry policy, never endpoints or secrets. */
 const AgentMemoryBinding = union([object({
 	provider: _enum([
@@ -7892,8 +7913,15 @@ const AgentMemoryBinding = union([object({
 		"native",
 		"managed"
 	]),
-	autoDistill: boolean().optional()
-}).strict(), object({
+	autoDistill: boolean().optional(),
+	dreaming: MemoryDreamingPolicy.optional()
+}).strict().superRefine((binding, ctx) => {
+	if (binding.dreaming && binding.provider !== "managed") ctx.addIssue({
+		code: "custom",
+		path: ["dreaming"],
+		message: "dreaming is only supported with the managed memory provider"
+	});
+}), object({
 	provider: literal("external"),
 	connectionId: string().uuid(),
 	recall: MemoryRecallPolicy.default({
@@ -8152,9 +8180,9 @@ const IntegrationChannels = object({
 * Agent lifecycle (protocol §4.4, §7.4, §8).
 *
 * There is no CP→daemon prompt-delivery frame: the daemon prompts an agent from
-* its own ingress (platform adapters, and webchat over its own `webchat/*`
-* frames), never the CP. The old `agent/prompt` + per-agent `seq` machinery was
-* reserved infrastructure with no live caller and has been removed.
+* its own ingress (platform adapters or relay `rd/*` delivery), never the CP.
+* The old `agent/prompt` + per-agent `seq` machinery was reserved infrastructure
+* with no live caller and has been removed.
 */
 /**
 * Where the agent runs. Two modes; the **path is always daemon-generated** —
@@ -8214,7 +8242,7 @@ discriminatedUnion("kind", [
 ]);
 /**
 * The editable agent definition the CP owns and the daemon needs to run it:
-* prompt + runtime selection. Raft ships this in the launch config and the
+* prompt + runtime selection. The launch protocol carries this config and the
 * daemon synthesizes the system prompt locally; `description` IS the prompt.
 */
 const AgentSpec = object({
@@ -8233,8 +8261,10 @@ const AgentSpec = object({
 		"medium",
 		"high"
 	]).optional(),
+	showFooter: boolean().optional(),
 	fastMode: boolean().optional(),
 	permissionMode: string().nullable().optional(),
+	allowRuntimeChangesInChat: boolean().optional(),
 	pause: boolean().optional(),
 	workspace: AgentWorkspace.optional(),
 	env: record(string(), string()).optional(),
@@ -8243,6 +8273,8 @@ const AgentSpec = object({
 	mcpServers: array(string()).default([]),
 	callPolicy: _enum(["all", "selected"]).optional(),
 	allowedCallerAgentIds: array(string()).default([]),
+	outboundPolicy: _enum(["all", "selected"]).optional(),
+	allowedTargetAgentIds: array(string()).optional(),
 	introduceOnJoin: boolean().optional(),
 	restrictFileAccess: boolean().optional()
 });
@@ -8325,6 +8357,36 @@ const AgentScopeDenied = object({
 	launchId: string().uuid(),
 	capability: string()
 });
+/** Editor approval queue. The daemon owns the live resolver and durable local
+* history; the Control Plane only proxies this bounded, secret-masked summary. */
+const AgentPermissionRequestRecord = object({
+	id: string().uuid(),
+	agentId: string().uuid(),
+	createdAt: string().datetime(),
+	requesterId: string().nullable(),
+	requesterName: string().nullable(),
+	command: string().max(240),
+	status: _enum([
+		"pending",
+		"allowed",
+		"denied",
+		"expired"
+	]),
+	resolvedAt: string().datetime().nullable()
+});
+const AgentPermissionRequestList = object({
+	agentId: string().uuid(),
+	limit: number().int().min(1).max(100).default(50)
+});
+const AgentPermissionRequestPage = object({
+	agentId: string().uuid(),
+	requests: array(AgentPermissionRequestRecord)
+});
+const AgentPermissionDecision = object({
+	agentId: string().uuid(),
+	requestId: string().uuid(),
+	decision: _enum(["allow", "deny"])
+});
 //#endregion
 //#region ../protocol/dist/frames/mcpserver.js
 /**
@@ -8422,6 +8484,10 @@ const CollabAgentPlacement = object({
 	botAppId: string().optional(),
 	callPolicy: _enum(["all", "selected"]).default("all"),
 	allowedCallerAgentIds: array(string()).default([]),
+	/** Caller-side authorization. Effective A→B access requires A's outbound
+	* policy to admit B and B's inbound call policy to admit A. */
+	outboundPolicy: _enum(["all", "selected"]).default("all"),
+	allowedTargetAgentIds: array(string()).default([]),
 	name: string().optional(),
 	displayName: string().optional()
 });
@@ -8474,7 +8540,7 @@ const GitCommitIdentity = object({
 * `INTERNAL`.
 */
 /**
-* Token capability classes (webhook-triggers-and-github-events.md P2.5 回写).
+* Token capability classes (webhook-triggers-and-github-events.md P2.5 write-back).
 * `contents` is the git data plane (the pre-capabilities behavior); `issues` /
 * `pull_requests` buy the agent `gh` write-back (issue/PR comments), and
 * `actions` buys GitHub Actions inspection/execution. Every
@@ -8653,6 +8719,7 @@ const GithubHookMetadata = object({
 	mergeCommitSha: string().min(1).optional(),
 	isDraft: boolean().optional(),
 	baseChanged: boolean().optional(),
+	explicitReviewRequest: boolean().optional(),
 	reviewCommentId: HookBigIntString.optional(),
 	reviewThreadRootCommentId: HookBigIntString.optional()
 }).superRefine((value, ctx) => {
@@ -9253,6 +9320,143 @@ const MemoryRecordHistoryPage = object({
 	events: array(MemoryPluginHistoryEvent).max(20),
 	nextCursor: OptionalRecordCursor
 }).strict();
+/**
+* Memory dreaming (C→D REQ → REP) — offline consolidation jobs over the
+* MANAGED store (design: docs/designs/memory-dreaming.md).
+*
+* A dream reads a snapshot of `<agent-root>/memory/` plus recent session
+* transcripts and stages a rebuilt store under
+* `<agent-root>/memory-dreams/<dreamId>/`; the live store is never modified by
+* a running dream. The CP relays these frames and persists at most the
+* metadata (`DreamInfo`) — staged bodies transit only as correlated
+* request/reply payloads, exactly like `memory/read` (body-locality).
+*
+* - `memory/dream/start|cancel|adopt|discard`: lifecycle commands; each REP is
+*   the updated `DreamInfo` so the console can refresh without a second read.
+* - `memory/dream/list|get`: job metadata for the history view.
+* - `memory/dream/files` + `memory/dream/file/read`: browse the STAGED output
+*   tree (byte-sliced like `memory/read`; same UTF-8-boundary semantics).
+* - `memory/dream/skill/accept|dismiss`: review actions on mined skill
+*   candidates (skills are never auto-adopted; see the design §7).
+*/
+const DreamStatus = _enum([
+	"pending",
+	"running",
+	"completed",
+	"failed",
+	"canceled",
+	"adopted",
+	"discarded"
+]);
+const DreamTrigger = _enum([
+	"manual",
+	"schedule",
+	"auto"
+]);
+/** Review state of one mined skill candidate (design §7). */
+const DreamSkillInfo = object({
+	name: string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/, "skill name must be lowercase kebab-case"),
+	description: string().max(1024),
+	state: _enum([
+		"proposed",
+		"accepted",
+		"dismissed"
+	])
+}).strict();
+/** Dream job metadata (never staged bodies). The only dream shape the CP may persist. */
+const DreamInfo = object({
+	dreamId: string().min(1).max(128),
+	agentId: string().min(1),
+	status: DreamStatus,
+	trigger: DreamTrigger,
+	sessionIds: array(string().min(1)).max(100),
+	snapshotDigest: string().min(1).max(128),
+	instructions: string().max(4096).optional(),
+	skills: array(DreamSkillInfo).max(16).optional(),
+	usage: object({
+		inputBytes: number().int().nonnegative(),
+		outputBytes: number().int().nonnegative()
+	}).strict().optional(),
+	error: object({
+		type: string().min(1).max(128),
+		message: string().max(2048)
+	}).strict().optional(),
+	createdAt: string(),
+	endedAt: string().optional()
+}).strict();
+/** C→D REQ: start a dream for one agent (managed provider only). */
+const DreamStartReq = object({
+	agentId: string().min(1),
+	trigger: DreamTrigger.default("manual"),
+	/** Per-run overrides of the agent's configured dreaming policy. */
+	sessionWindow: number().int().min(1).max(100).optional(),
+	instructions: string().max(4096).optional()
+}).strict();
+/** D→C REP (corr = the req id): the created/updated dream job. Shared by every
+*  lifecycle command so the console always renders from one shape. */
+const DreamState = object({ dream: DreamInfo }).strict();
+/** C→D REQ: cancel a pending|running dream. */
+const DreamCancelReq = object({
+	agentId: string().min(1),
+	dreamId: string().min(1)
+}).strict();
+/** C→D REQ: list dream jobs for one agent (newest first; bounded). */
+const DreamListReq = object({
+	agentId: string().min(1),
+	limit: number().int().positive().max(50).default(20)
+}).strict();
+/** D→C REP (corr = the req id). */
+const DreamListPage = object({
+	agentId: string().min(1),
+	dreams: array(DreamInfo).max(50)
+}).strict();
+/** C→D REQ: fetch one dream job's metadata. */
+const DreamGetReq = DreamCancelReq;
+/** C→D REQ: adopt a completed dream's staged store (atomic swap + backup). */
+const DreamAdoptReq = object({
+	agentId: string().min(1),
+	dreamId: string().min(1),
+	/** Adopt even when the live store changed since the snapshot (fence override). */
+	force: boolean().default(false)
+}).strict();
+/** C→D REQ: discard a terminal dream's staged output. */
+const DreamDiscardReq = DreamCancelReq;
+/** C→D REQ: list the STAGED output files of one dream (review surface). */
+const DreamFilesReq = DreamCancelReq;
+/** D→C REP (corr = the req id): staged store listing (or `exists:false`). */
+const DreamFilesPage = object({
+	agentId: string(),
+	dreamId: string(),
+	exists: boolean(),
+	entries: array(MemoryEntry)
+}).strict();
+/** C→D REQ: read one byte slice of a STAGED dream file (semantics of `memory/read`). */
+const DreamFileReadReq = object({
+	agentId: string().min(1),
+	dreamId: string().min(1),
+	path: string().default(MEMORY_INDEX),
+	offset: number().int().nonnegative().default(0),
+	limit: number().int().positive().max(65536).default(65536)
+}).strict();
+/** D→C REP (corr = the req id): the staged file slice (fields as `memory/read/content`). */
+const DreamFileReadContent = object({
+	agentId: string(),
+	dreamId: string(),
+	path: string(),
+	exists: boolean(),
+	size: number().int().nonnegative().optional(),
+	mtime: string().optional(),
+	content: string().optional(),
+	offset: number().int().nonnegative().optional(),
+	nextOffset: number().int().nonnegative().optional(),
+	truncated: boolean().optional()
+}).strict();
+/** C→D REQ: accept or dismiss one mined skill candidate (design §7). */
+const DreamSkillReviewReq = object({
+	agentId: string().min(1),
+	dreamId: string().min(1),
+	name: string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/)
+}).strict();
 //#endregion
 //#region ../protocol/dist/frames/telemetry.js
 /**
@@ -9345,6 +9549,13 @@ const EffortOption = object({
 	name: string().optional(),
 	description: string().optional()
 });
+/** One runtime permission-mode choice. The display metadata is forwarded
+*  verbatim from the runtime's ACP `category: "mode"` select option. */
+const PermissionModeOption = object({
+	value: string(),
+	name: string().optional(),
+	description: string().optional()
+});
 /**
 * A runtime's discovered model × config capability matrix. One shape shared by
 * the wire, the CP's `runtime_profile.modelCatalog` JSONB column, and the DTO —
@@ -9359,10 +9570,7 @@ const RuntimeModelCatalog = object({
 		fastMode: boolean().optional()
 	})).max(128),
 	defaultModel: string().optional(),
-	permissionModes: array(object({
-		value: string(),
-		name: string().optional()
-	})).optional(),
+	permissionModes: array(PermissionModeOption).optional(),
 	defaultPermissionMode: string().optional(),
 	source: _enum(["native", "acp"]),
 	observedAt: string().datetime()
@@ -9428,6 +9636,9 @@ const FRAME_SCHEMAS = {
 	"agent/activate": AgentActivate,
 	"agent/activity": AgentActivity,
 	"agent/scope-denied": AgentScopeDenied,
+	"agent/permission-requests": AgentPermissionRequestList,
+	"agent/permission-requests/page": AgentPermissionRequestPage,
+	"agent/permission-decision": AgentPermissionDecision,
 	"route/assign": RouteAssign,
 	"route/assign/ack": RouteAssignAck,
 	"route/update": RouteUpdate,
@@ -9506,6 +9717,26 @@ const FRAME_SCHEMAS = {
 	"memory/record/delete/result": MemoryRecordDeleteResult,
 	"memory/record/history": MemoryRecordHistoryReq,
 	"memory/record/history/page": MemoryRecordHistoryPage,
+	"memory/dream/start": DreamStartReq,
+	"memory/dream/start/ok": DreamState,
+	"memory/dream/cancel": DreamCancelReq,
+	"memory/dream/cancel/ok": DreamState,
+	"memory/dream/list": DreamListReq,
+	"memory/dream/list/page": DreamListPage,
+	"memory/dream/get": DreamGetReq,
+	"memory/dream/get/result": DreamState,
+	"memory/dream/adopt": DreamAdoptReq,
+	"memory/dream/adopt/ok": DreamState,
+	"memory/dream/discard": DreamDiscardReq,
+	"memory/dream/discard/ok": DreamState,
+	"memory/dream/files": DreamFilesReq,
+	"memory/dream/files/page": DreamFilesPage,
+	"memory/dream/file/read": DreamFileReadReq,
+	"memory/dream/file/read/content": DreamFileReadContent,
+	"memory/dream/skill/accept": DreamSkillReviewReq,
+	"memory/dream/skill/accept/ok": DreamState,
+	"memory/dream/skill/dismiss": DreamSkillReviewReq,
+	"memory/dream/skill/dismiss/ok": DreamState,
 	"config/push": object({ keys: record(string(), unknown()) }),
 	"daemon/restart": object({
 		reason: string(),
@@ -9588,6 +9819,9 @@ discriminatedUnion("type", [
 	frame("agent/activate", FRAME_SCHEMAS["agent/activate"]),
 	frame("agent/activity", FRAME_SCHEMAS["agent/activity"]),
 	frame("agent/scope-denied", FRAME_SCHEMAS["agent/scope-denied"]),
+	frame("agent/permission-requests", FRAME_SCHEMAS["agent/permission-requests"]),
+	frame("agent/permission-requests/page", FRAME_SCHEMAS["agent/permission-requests/page"]),
+	frame("agent/permission-decision", FRAME_SCHEMAS["agent/permission-decision"]),
 	frame("route/assign", FRAME_SCHEMAS["route/assign"]),
 	frame("route/assign/ack", FRAME_SCHEMAS["route/assign/ack"]),
 	frame("route/update", FRAME_SCHEMAS["route/update"]),
@@ -9662,6 +9896,26 @@ discriminatedUnion("type", [
 	frame("memory/record/delete/result", FRAME_SCHEMAS["memory/record/delete/result"]),
 	frame("memory/record/history", FRAME_SCHEMAS["memory/record/history"]),
 	frame("memory/record/history/page", FRAME_SCHEMAS["memory/record/history/page"]),
+	frame("memory/dream/start", FRAME_SCHEMAS["memory/dream/start"]),
+	frame("memory/dream/start/ok", FRAME_SCHEMAS["memory/dream/start/ok"]),
+	frame("memory/dream/cancel", FRAME_SCHEMAS["memory/dream/cancel"]),
+	frame("memory/dream/cancel/ok", FRAME_SCHEMAS["memory/dream/cancel/ok"]),
+	frame("memory/dream/list", FRAME_SCHEMAS["memory/dream/list"]),
+	frame("memory/dream/list/page", FRAME_SCHEMAS["memory/dream/list/page"]),
+	frame("memory/dream/get", FRAME_SCHEMAS["memory/dream/get"]),
+	frame("memory/dream/get/result", FRAME_SCHEMAS["memory/dream/get/result"]),
+	frame("memory/dream/adopt", FRAME_SCHEMAS["memory/dream/adopt"]),
+	frame("memory/dream/adopt/ok", FRAME_SCHEMAS["memory/dream/adopt/ok"]),
+	frame("memory/dream/discard", FRAME_SCHEMAS["memory/dream/discard"]),
+	frame("memory/dream/discard/ok", FRAME_SCHEMAS["memory/dream/discard/ok"]),
+	frame("memory/dream/files", FRAME_SCHEMAS["memory/dream/files"]),
+	frame("memory/dream/files/page", FRAME_SCHEMAS["memory/dream/files/page"]),
+	frame("memory/dream/file/read", FRAME_SCHEMAS["memory/dream/file/read"]),
+	frame("memory/dream/file/read/content", FRAME_SCHEMAS["memory/dream/file/read/content"]),
+	frame("memory/dream/skill/accept", FRAME_SCHEMAS["memory/dream/skill/accept"]),
+	frame("memory/dream/skill/accept/ok", FRAME_SCHEMAS["memory/dream/skill/accept/ok"]),
+	frame("memory/dream/skill/dismiss", FRAME_SCHEMAS["memory/dream/skill/dismiss"]),
+	frame("memory/dream/skill/dismiss/ok", FRAME_SCHEMAS["memory/dream/skill/dismiss/ok"]),
 	frame("config/push", FRAME_SCHEMAS["config/push"]),
 	frame("daemon/restart", FRAME_SCHEMAS["daemon/restart"]),
 	frame("daemon/upgrade", FRAME_SCHEMAS["daemon/upgrade"]),
@@ -9678,7 +9932,7 @@ discriminatedUnion("type", [
 * (`frames/relay-cp.ts` / `frames/relay-daemon.ts` over their OWN maps) all
 * decode the same envelope shape but accept disjoint frame families — a relay
 * socket must answer a daemon↔CP frame with `UNKNOWN_FRAME`, and vice versa
-* (shared-bot-relay.md §8 "独立帧 union，不混入 daemon 协议").
+* (shared-bot-relay.md §8 "standalone frame union, not mixed into the daemon protocol").
 */
 /** Soft cap per frame — 256 KiB (protocol §1). Over this → FRAME_TOO_LARGE. */
 const MAX_FRAME_BYTES = 256 * 1024;