qlogicagent 2.10.22 → 2.10.23

package/dist/types/orchestration/workflow/workflow-render.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Compact workflow renderer — the "workflow-as-context" feeder (plan D17,
+ * spec workflow-conversational-editing-spec.md §B).
+ *
+ * Every page-chat user turn injects the LATEST workflow as compact, deterministic text (NOT raw
+ * JSON: cheaper tokens, never stale, stable node ids the agent references back in a WorkflowPatch).
+ * This module is the deterministic ENGINE half of that loop — the agent reads this rendering and
+ * emits a `WorkflowPatch` (workflow-patch.ts) against the shown `rev`. Pure function: no gateway,
+ * no LLM, no I/O.
+ *
+ * Determinism (§1.5): node order follows the def's node array (stable, persisted order); param
+ * keys are sorted; expressions (`{{ }}`) render verbatim so the agent can copy them into bindings.
+ * Large graphs truncate with an explicit hint to call `workflow.get` for the full definition.
+ */
+import type { WorkflowDef } from "./node-schema.js";
+import type { TriggerDef } from "./workflow-patch.js";
+/** The minimal shape needed to render (WorkflowRecord satisfies it). */
+export interface RenderableWorkflow {
+    name: string;
+    rev: number;
+    active: boolean;
+    trigger?: TriggerDef | null;
+    def: WorkflowDef;
+}
+export interface RenderOptions {
+    /** Max nodes to list before truncating (default 50). */
+    maxNodes?: number;
+    /** Max rendered length of a single param value before eliding (default 60). */
+    maxValueLen?: number;
+}
+/**
+ * Render a workflow as compact agent-context text. Shape (spec §B):
+ *
+ *   Workflow "晨报" (rev 7, trigger: schedule "0 9 * * *", active)
+ *   nodes:
+ *     n1 [agent]   prompt="抓取今日新闻要点"   out: default
+ *     n3 [if]      cond={{ $json.count > 0 }}   out: true,false
+ *   edges:
+ *     n1.default→n2.default ; n3.true→n4.default
+ */
+export declare function renderWorkflow(wf: RenderableWorkflow, opts?: RenderOptions): string;

package/dist/types/orchestration/workflow/workflow-runtime.d.ts

@@ -0,0 +1,127 @@
+/**
+ * WorkflowRuntime — the automation data-routing driver (M2; plan §M2, spec §A1/§A5).
+ *
+ * Responsibilities (control/data separation, spec §A1):
+ *   - DagScheduler v2 owns CONTROL (ready/skip/loop/ports). The runtime owns DATA:
+ *     for each ready node it collects upstream outputs along data edges (fromPort→toPort),
+ *     resolves param expressions, invokes the registered NodeExecutor, stores outputs, and
+ *     reports completion + firedPorts back to the scheduler.
+ *   - run-from-node + output cache (spec §A5): cache key = hash(kind + resolved params +
+ *     input signature + runIndex). A clean node hits cache (executor skipped); a changed node
+ *     and its dirty downstream recompute. This is content-addressed, so successive run() calls
+ *     after a param change recompute only the dirty subgraph.
+ *   - loop control is runtime-owned (DagScheduler.decideLoop), not a user executor.
+ *   - every node passes an injectable budget/permission gate before executing (plan D15).
+ *
+ * fail-loud: unknown kinds, gate rejections, and executor errors all throw and halt the run.
+ */
+import { DagScheduler } from "../dag-scheduler.js";
+import { type PortMap } from "./data-item.js";
+import { NodeRegistry } from "./node-registry.js";
+import type { RunCheckpoint } from "./run-checkpoint-store.js";
+import type { WorkflowDef, ExecutorHost } from "./node-schema.js";
+/** Gate invoked before each node executes (budget / permission). Throw to halt the run. */
+export interface ExecutionGate {
+    check(nodeId: string, kind: string): void;
+    /**
+     * Optionally raise the gate's remaining allowance so a budget-paused run can resume (D15
+     * "抬预算后 resume"). Gates without a budget may omit this. Implementations are fail-loud on
+     * non-positive deltas.
+     */
+    extend?(delta: {
+        executions?: number;
+        durationMs?: number;
+    }): void;
+}
+/**
+ * Thrown by a gate (or `pause()`) to suspend the run gracefully. Unlike a plain error this is
+ * not a failure: completed work stays cached, and a later `run()` on the same instance resumes
+ * (cached nodes hit, only the not-yet-run remainder executes).
+ */
+export declare class WorkflowPauseSignal extends Error {
+    readonly atNodeId?: string | undefined;
+    constructor(atNodeId?: string | undefined);
+}
+export interface RunResult {
+    status: "completed" | "failed" | "paused";
+    /** nodeId → its output PortMap. */
+    outputs: Record<string, PortMap>;
+    /** nodeIds whose executor actually ran in this run (cache misses). */
+    executed: Set<string>;
+    progress: ReturnType<DagScheduler["getProgress"]>;
+    /** Set when status === "paused": the node the run suspended at. */
+    pausedAt?: string;
+}
+export interface WorkflowRuntimeOptions {
+    registry?: NodeRegistry;
+    gate?: ExecutionGate;
+    now?: () => Date;
+    trigger?: Record<string, unknown>;
+    log?: {
+        info(m: string): void;
+        warn(m: string): void;
+    };
+    /** Host capabilities for host-backed kinds (agent/tool/http/mcp/channel), D13. */
+    host?: ExecutorHost;
+    /** Cancellation propagated to host calls. */
+    signal?: AbortSignal;
+    /** Durable run checkpoint for crash-restart recovery (plan §M3). */
+    checkpoint?: RunCheckpoint;
+}
+export declare class WorkflowRuntime {
+    private def;
+    private readonly registry;
+    private readonly gate?;
+    private readonly now;
+    private readonly trigger?;
+    private readonly log?;
+    private readonly host?;
+    private readonly signal?;
+    private readonly checkpoint?;
+    private dag;
+    private readonly nodeDefs;
+    private readonly nodeOutputs;
+    /** Content-addressed output cache; persists across run() calls for run-from-node. */
+    private readonly cache;
+    /** loopBack source nodeId → loop controller nodeId. */
+    private readonly loopBackOf;
+    /** Cooperative pause request; honored before the next node executes. */
+    private pauseRequested;
+    /** True once the durable checkpoint has been loaded into `cache` (load once per instance). */
+    private checkpointLoaded;
+    constructor(def: WorkflowDef, opts?: WorkflowRuntimeOptions);
+    /** Patch a node's params (for run-from-node param changes). Invalidates nothing directly —
+     * the content-addressed cache recomputes only what changed. */
+    setNodeParams(nodeId: string, params: Record<string, unknown>): void;
+    /** Request a cooperative pause: the in-flight run suspends before the next node executes. */
+    pause(): void;
+    /**
+     * Raise the budget gate's remaining allowance so a budget-paused run can resume (D15
+     * "抬预算后 resume"). fail-loud if this runtime was built without an extensible budget gate.
+     */
+    extendBudget(delta: {
+        executions?: number;
+        durationMs?: number;
+    }): void;
+    /** Execute the workflow to completion (or until the gate halts / a branch fails / a pause). */
+    run(): Promise<RunResult>;
+    /**
+     * Seed the content-addressed cache from a durable checkpoint (once per instance). After a
+     * crash-restart a fresh runtime replays the DAG; nodes that completed before the crash hit
+     * these entries and their executors are not re-invoked (no duplicate side effects).
+     */
+    private loadCheckpoint;
+    /** Persist the full content-addressed cache so a crash mid-run can resume from here. */
+    private persistCheckpoint;
+    private executeNode;
+    /** Loop entry: fire the "loop" port once to kick the first iteration. */
+    private enterLoop;
+    private decideLoopBack;
+    /** Loop again? No condition → loop until the scheduler's maxIterations cap. */
+    private evalLoopCondition;
+    /** Collect inputs for a node from completed upstream outputs along forward data edges. */
+    private collectInputs;
+    private buildExprContext;
+    private cacheKey;
+    private buildDag;
+}

package/dist/types/orchestration/workflow/workflow-scheduler.d.ts

@@ -0,0 +1,83 @@
+/**
+ * In-process workflow trigger scheduler (plan M3 trigger layer).
+ *
+ * Architecture note: scheduling lives INSIDE qlogicagent, not the gateway. This mirrors the
+ * established precedent — the idle "dream" timer was deliberately moved out of the openclaw gateway
+ * into qlogicagent so the Agent owns its own timed lifecycle ("Agent 是唯一状态拥有者"). The gateway
+ * remains a pure relay: it terminates external ingress (webhook HTTP, inbound IM) and forwards those
+ * events here via `onWebhook` / `onImMessage`; the cron clock and the run decision are the Agent's.
+ *
+ * The scheduler is the consumer of WorkflowController: on `start()` it loads every active workflow
+ * (`listActive`, spec §B4 restart re-registration) and arms a timer per `schedule` trigger; on fire
+ * it calls `controller.run(id, { type: "schedule" })`. Webhook / IM / manual triggers are
+ * caller-driven (the gateway relay or the agent invokes the matching method). Concurrency,
+ * budgeting, and permission gating all live in `controller.run` — the scheduler only decides WHEN.
+ *
+ * Determinism: the clock (now + timers) is injected, so tests pin time exactly and far-future cron
+ * delays are handled by chunked re-arming (Node's setTimeout caps at ~24.8 days).
+ */
+import type { WorkflowController, RunOutcome } from "./workflow-controller.js";
+export type TimerHandle = unknown;
+/** Injectable clock + timer surface so the scheduler is fully deterministic under test. */
+export interface SchedulerClock {
+    now(): number;
+    setTimer(fn: () => void, delayMs: number): TimerHandle;
+    clearTimer(handle: TimerHandle): void;
+}
+/** Default clock backed by the real system time and Node timers. */
+export declare const systemClock: SchedulerClock;
+export interface SchedulerDeps {
+    controller: WorkflowController;
+    clock?: SchedulerClock;
+    /**
+     * Surfaces an error from a timer-driven (cron) run, which has no caller to throw back to.
+     * Required so a failed unattended run is never silently swallowed (§1.5 fail-loud). Caller-driven
+     * triggers (webhook/IM/manual) propagate their errors to the caller instead.
+     */
+    onError: (err: unknown, workflowId: string) => void;
+}
+export declare class WorkflowScheduler {
+    private readonly controller;
+    private readonly clock;
+    private readonly onError;
+    /** Every registered workflow's trigger, keyed by id (the single source for lookups). */
+    private readonly triggers;
+    /** Active cron arms keyed by workflow id. */
+    private readonly cronArms;
+    private started;
+    constructor(deps: SchedulerDeps);
+    /** Load every active workflow and arm its trigger (spec §B4 restart re-registration). */
+    start(): Promise<void>;
+    /** Stop all timers and forget every registration. Idempotent. */
+    stop(): void;
+    /**
+     * Re-read a workflow and (re-)arm its trigger after a create/patch/setActive change. If the
+     * workflow no longer exists or is inactive it is unregistered. Active workflows are armed by
+     * their current trigger (manual ⇒ lookup-only, no timer).
+     */
+    refresh(id: string): Promise<void>;
+    /** Drop a workflow's registration and cancel any pending cron timer. */
+    unregister(id: string): void;
+    /** Workflow ids currently registered (for inspection/tests). */
+    registeredIds(): string[];
+    /** The epoch ms a scheduled workflow will next fire, or undefined if it has no cron arm. */
+    nextFireAt(id: string): number | undefined;
+    /**
+     * Deliver an external webhook hit. Runs every active workflow whose webhook trigger path equals
+     * `path`. Returns the outcomes (empty ⇒ no workflow matched, which the gateway maps to 404).
+     * Errors propagate to the caller (the HTTP handler), which is the fail-loud surface here.
+     */
+    onWebhook(path: string, payload?: Record<string, unknown>): Promise<RunOutcome[]>;
+    /**
+     * Deliver an inbound IM message. Runs every active workflow whose im-message trigger is on
+     * `channel` and whose optional `match` regex tests `text`. The message text + channel are merged
+     * into the run payload so downstream nodes can reference `$trigger`.
+     */
+    onImMessage(channel: string, text: string, payload?: Record<string, unknown>): Promise<RunOutcome[]>;
+    /** Manually trigger a single workflow (the agent's `workflow.run`). Errors propagate to caller. */
+    triggerManual(id: string, payload?: Record<string, unknown>): Promise<RunOutcome>;
+    private matchingIds;
+    private registerTrigger;
+    private armCron;
+    private fireCron;
+}

package/dist/types/orchestration/workflow/workflow-store.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Workflow Store — persist workflow definitions + lifecycle state to disk (spec §B4).
+ *
+ * Stored at `<project>/.qlogicagent/workflows/<workflowId>/workflow.json`. Listing enumerates
+ * subdirectories (mirrors product-persistence.ts). The store is the single source of truth for a
+ * workflow's definition, its active flag, and its concurrency policy; the gateway re-registers
+ * triggers for every active workflow on restart (spec §B4).
+ *
+ * fail-loud: missing id on save throws; load returns undefined only for a genuinely absent record.
+ */
+import type { WorkflowDef } from "./node-schema.js";
+import type { TriggerDef } from "./workflow-patch.js";
+/** What to do when a workflow is triggered while a previous run is still in-flight (spec §B5). */
+export type ConcurrencyPolicy = "queue" | "skip" | "parallel";
+export interface WorkflowRecord {
+    id: string;
+    name: string;
+    def: WorkflowDef;
+    /** Active workflows have their triggers registered by the gateway (spec §B4). */
+    active: boolean;
+    concurrency: ConcurrencyPolicy;
+    /** The workflow's trigger (set via a WorkflowPatch set_trigger op; spec §C/D7). */
+    trigger?: TriggerDef | null;
+    /** Monotonic revision for optimistic concurrency (LWW); bumped on every patch (spec §C). */
+    rev: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare class WorkflowStore {
+    private readonly cwd;
+    constructor(cwd: string);
+    save(record: WorkflowRecord): Promise<void>;
+    load(id: string): Promise<WorkflowRecord | undefined>;
+    /** Load a record or throw (fail-loud lookup for callers that require existence). */
+    require(id: string): Promise<WorkflowRecord>;
+    list(): Promise<WorkflowRecord[]>;
+    /** Active workflows the gateway must re-register triggers for after a restart (spec §B4). */
+    listActive(): Promise<WorkflowRecord[]>;
+    delete(id: string): Promise<void>;
+}

package/dist/types/orchestration/workflow/workflow-trigger.d.ts

@@ -0,0 +1,14 @@
+/** Workflow trigger definitions shared by patching, validation, storage, and render helpers. */
+export type TriggerDef = {
+    type: "manual";
+} | {
+    type: "schedule";
+    cron: string;
+} | {
+    type: "im-message";
+    channel: string;
+    match?: string;
+} | {
+    type: "webhook";
+    path: string;
+};

package/dist/types/permissions.d.ts

@@ -0,0 +1,2 @@
+export { PERMISSION_MODES, } from "./runtime/ports/permission-contracts.js";
+export type { ApprovalRequest, ApprovalResponse, PermissionAllowResult, PermissionApprovalResolver, PermissionAskResult, PermissionBehavior, PermissionConfig, PermissionDecisionReason, PermissionDenyResult, PermissionMetadataResolver, PermissionMode, PermissionResult, PermissionRuleEnginePort, PermissionRuleEntry, PermissionUpdate, ToolPermissionCheckInput, } from "./runtime/ports/permission-contracts.js";

package/dist/types/permissions.public-api.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/protocol/methods.d.ts

@@ -6,10 +6,9 @@
  *
  * Reference: Codex app-server RPC, Claude Code JSON-RPC, GitHub Copilot Agent API.
  */
-import type { ChatMessage, ToolDefinition } from "../agent/types.js";
-import type { TaskItem as TodoItem } from "../skills/tools/task-tool.js";
+import type { ChatMessage, LocalizedToolText, ToolCapabilityCategory, ToolDefinition } from "./wire/chat-types.js";
 import type { AgentDescriptor, AgentConfig, GatewayRpcMethodMap, RpcProjectInfo, RpcProjectType, RpcProjectStatus, SoloStatus, ProductStatus, ProductSummary } from "./wire/index.js";
-import type { AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloStartParams, SoloIdParams, SoloSelectParams, SoloDeleteParams, SoloMessageParams, SoloEvaluateParams, SoloEvaluation, ProductCreateParams, ProductPlanParams, ProductPlan, ProductConfirmParams, ProductMessageParams, ProductIdParams, ProductDeleteParams } from "../runtime/infra/acp-types.js";
+import type { AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloStartParams, SoloIdParams, SoloSelectParams, SoloDeleteParams, SoloMessageParams, SoloEvaluateParams, SoloEvaluation, ProductCreateParams, ProductPlanParams, ProductPlan, ProductConfirmParams, ProductMessageParams, ProductIdParams, ProductDeleteParams } from "./wire/acp-agent-management.js";
 export interface InitializeParams {
     protocolVersion: string;
     host?: {
@@ -181,20 +180,25 @@ export interface MemoryDreamResult {
 }
 export interface ToolsListParams {
     /** Filter by category. */
-    category?: "builtin" | "mcp" | "plugin" | "all";
-    /** Include full parameter schemas (default falsenames only). */
-    includeSchema?: boolean;
+    category?: ToolCapabilityCategory;
+    /** Include tools that are normally deferred until activated. */
+    includeDeferred?: boolean;
 }
 export interface ToolsListResult {
     tools: Array<{
+        id: string;
         name: string;
+        category: ToolCapabilityCategory;
+        displayName: LocalizedToolText;
+        displayDescription: LocalizedToolText;
+        fallbackName: string;
+        fallbackDescription: string;
         description: string;
-        category: "builtin" | "mcp" | "plugin";
-        /** Whether this tool requires approval. */
-        requiresApproval?: boolean;
-        /** Parameter schema (if includeSchema=true). */
+        source: "builtin";
+        deferred: boolean;
         parameters?: Record<string, unknown>;
     }>;
+    total: number;
 }
 export interface SettingsListProvidersResult {
     providers: Array<{
@@ -319,10 +323,202 @@ export interface ConfigUpdateResult {
         reason: string;
     }>;
 }
+export interface CommunityConsentView {
+    enabled: boolean;
+    methodSharingEnabled: boolean;
+    signalsEnabled: boolean;
+    encounterEnabled: boolean;
+    remoteSynced: boolean;
+}
+export interface CommunityGetConsentResult {
+    ok: boolean;
+    remoteAvailable: boolean;
+    consent: CommunityConsentView;
+    error?: string;
+}
+export interface CommunitySetConsentParams {
+    enabled: boolean;
+    methodSharingEnabled?: boolean;
+    signalsEnabled?: boolean;
+    encounterEnabled?: boolean;
+}
+export interface CommunitySetConsentResult {
+    ok: boolean;
+    remoteAvailable: boolean;
+    consent: CommunityConsentView;
+    warning?: string;
+}
+export interface CommunitySharedResource {
+    id: string;
+    type: string;
+    title: string;
+    summary: string;
+    visibility: string;
+    latestVersion: string | null;
+    withdrawn: boolean;
+    withdrawnAt: string | null;
+}
+export interface CommunityListSharedResult {
+    ok: boolean;
+    resources: CommunitySharedResource[];
+}
+export interface CommunityWithdrawSharedParams {
+    resourceId: string;
+    reason?: string;
+}
+export interface CommunityWithdrawSharedResult {
+    ok: boolean;
+    resource: CommunitySharedResource;
+}
+export interface CommunityWithdrawAllSharedParams {
+    reason?: string;
+}
+export interface CommunityWithdrawAllSharedResult {
+    ok: boolean;
+    resources: CommunitySharedResource[];
+}
+export interface CommunityNotice {
+    id: number;
+    resourceId: string;
+    resourceType: string;
+    title: string;
+    event: "withdrawn";
+    version: string | null;
+    reason: string | null;
+    read: boolean;
+    createdAt: string;
+    readAt: string | null;
+}
+export interface CommunityListNoticesParams {
+    includeRead?: boolean;
+}
+export interface CommunityListNoticesResult {
+    ok: boolean;
+    notices: CommunityNotice[];
+}
+export interface CommunityMarkNoticeReadParams {
+    noticeId: number;
+}
+export interface CommunityMarkNoticeReadResult {
+    ok: boolean;
+    notice: CommunityNotice;
+}
+export interface CommunityPublishSkillParams {
+    id: string;
+    title: string;
+    summary: string;
+    visibility?: "public" | "private";
+    tags?: string[];
+    manifest: Record<string, unknown>;
+    version?: string;
+    packageGzipBase64?: string;
+}
+export interface CommunityPublishedVersion {
+    version: string;
+    checksum: string;
+    sizeBytes: number;
+}
+export interface CommunityPublishSkillResult {
+    ok: boolean;
+    resource: CommunitySharedResource;
+    version?: CommunityPublishedVersion;
+}
+export type CommunitySignalEvent = "installed" | "success" | "fail" | "neutral" | "kept" | "uninstalled" | "endorse" | "error";
+export interface CommunityRecordSignalParams {
+    resourceId: string;
+    event: CommunitySignalEvent;
+    attribution?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CommunityRecordSignalResult {
+    ok: boolean;
+    accepted: true;
+}
+export type CommunityTelemetryEvent = "community.journey.view" | "community.share.generated" | "community.sandbox.violation" | "community.desensitization.hit";
+export interface CommunityRecordTelemetryParams {
+    event: CommunityTelemetryEvent;
+    metadata?: Record<string, unknown>;
+}
+export interface CommunityRecordTelemetryResult {
+    ok: boolean;
+    accepted: true;
+}
+export interface CommunityListPublishAuditParams {
+    limit?: number;
+}
+export interface CommunityPublishAuditEntry {
+    eventTurnId: string;
+    skillName: string;
+    decision: "published" | "blocked" | "skipped";
+    reason: string;
+    resourceId?: string;
+    createdAt: string;
+}
+export interface CommunityListPublishAuditResult {
+    ok: boolean;
+    entries: CommunityPublishAuditEntry[];
+}
+export type CommunityInstallRiskTier = "R0" | "R1" | "R2" | "R3";
+export type CommunityInstallSourceTier = "official" | "community";
+export type CommunityInstallTrustStage = "quarantine" | "trial" | "trusted";
+export type CommunityInstallReviewStatus = "pending" | "approved" | "rejected";
+export interface CommunityInstallResolution {
+    id: string;
+    type: string;
+    kind: string;
+    sourceTier: CommunityInstallSourceTier;
+    trustStage: CommunityInstallTrustStage;
+    reviewStatus: CommunityInstallReviewStatus;
+    resourceRiskTier: CommunityInstallRiskTier;
+    effectiveRiskTier: CommunityInstallRiskTier;
+    requires: string[];
+    dependencies: CommunityInstallResolution[];
+    version: string;
+    checksum: string;
+    sizeBytes: number;
+    downloadUrl: string;
+    manifest: unknown;
+}
+export interface CommunityResolveInstallParams {
+    resourceId: string;
+    version?: string;
+    explicitInstallConsent: true;
+    explicitHighRiskConsent?: true;
+}
+export interface CommunityResolveInstallResult {
+    ok: boolean;
+    install: CommunityInstallResolution;
+}
+export interface CommunityInstallResourceParams {
+    resourceId: string;
+    version?: string;
+    explicitInstallConsent: true;
+}
+export interface CommunityInstalledResource {
+    resourceId: string;
+    version: string;
+    skillName: string;
+    installDir: string;
+    checksum: string;
+}
+export interface CommunityInstallResourceResult {
+    ok: boolean;
+    installed: CommunityInstalledResource;
+    signalWarning?: string;
+}
 export interface TodosListParams {
     /** Filter by status. */
     status?: "not-started" | "in-progress" | "completed" | "all";
 }
+export interface TodoItem {
+    id: number;
+    title: string;
+    status: "not-started" | "in-progress" | "completed";
+    description?: string;
+    owner?: string;
+    blockedBy?: number[];
+    blocks?: number[];
+}
 export interface TodosListResult {
     items: TodoItem[];
     summary: {
@@ -344,10 +540,13 @@ export interface AgentAbortResult {
 export interface ToolApprovalResponseParams {
     approvalId: string;
     decision: "allow-once" | "allow-session" | "allow-always" | "deny";
+    toolName?: string;
     updatedInput?: Record<string, unknown>;
     permissionUpdate?: {
         pattern: string;
-        behavior: string;
+        behavior: "allow" | "ask" | "deny";
+        scope?: "session" | "persistent";
+        description?: string;
     };
 }
 export interface MemorySearchParams {
@@ -522,6 +721,58 @@ export interface RpcMethodMap {
         params: ConfigUpdateParams;
         result: ConfigUpdateResult;
     };
+    "community.getConsent": {
+        params: undefined;
+        result: CommunityGetConsentResult;
+    };
+    "community.setConsent": {
+        params: CommunitySetConsentParams;
+        result: CommunitySetConsentResult;
+    };
+    "community.listShared": {
+        params: undefined;
+        result: CommunityListSharedResult;
+    };
+    "community.withdrawShared": {
+        params: CommunityWithdrawSharedParams;
+        result: CommunityWithdrawSharedResult;
+    };
+    "community.withdrawAllShared": {
+        params: CommunityWithdrawAllSharedParams;
+        result: CommunityWithdrawAllSharedResult;
+    };
+    "community.listNotices": {
+        params: CommunityListNoticesParams;
+        result: CommunityListNoticesResult;
+    };
+    "community.markNoticeRead": {
+        params: CommunityMarkNoticeReadParams;
+        result: CommunityMarkNoticeReadResult;
+    };
+    "community.listPublishAudit": {
+        params: CommunityListPublishAuditParams;
+        result: CommunityListPublishAuditResult;
+    };
+    "community.resolveInstall": {
+        params: CommunityResolveInstallParams;
+        result: CommunityResolveInstallResult;
+    };
+    "community.installResource": {
+        params: CommunityInstallResourceParams;
+        result: CommunityInstallResourceResult;
+    };
+    "community.publishSkill": {
+        params: CommunityPublishSkillParams;
+        result: CommunityPublishSkillResult;
+    };
+    "community.recordSignal": {
+        params: CommunityRecordSignalParams;
+        result: CommunityRecordSignalResult;
+    };
+    "community.recordTelemetry": {
+        params: CommunityRecordTelemetryParams;
+        result: CommunityRecordTelemetryResult;
+    };
     "todos.list": {
         params: TodosListParams;
         result: TodosListResult;

package/dist/types/{runtime/infra/acp-types.d.ts → protocol/wire/acp-agent-management.d.ts}

@@ -4,8 +4,8 @@
  * These types define the contract for discovering, registering, and managing
  * external ACP-compatible agent CLIs alongside qlogicagent's internal agents.
  */
-import type { AgentCapabilities, CustomAgentDef, AgentConfig, ProductTaskStatus, ProductInstanceDef, ProductTaskDef } from "../../protocol/wire/index.js";
-export type { AgentCategory, AgentProtocol, AgentStatus, AgentCapabilities, AgentDescriptor, CustomAgentDef, AgentConfig, SoloState, SoloAgentState, SoloAgentResult, SoloStatus, ProductPhase, ProductTaskStatus, ProductInstanceDef, ProductTaskDef, ProductStatus, ProductSummary, } from "../../protocol/wire/index.js";
+import type { AgentCapabilities, CustomAgentDef, AgentConfig, ProductTaskStatus, ProductInstanceDef, ProductTaskDef } from "./agent-methods.js";
+export type { AgentCategory, AgentProtocol, AgentStatus, AgentCapabilities, AgentDescriptor, CustomAgentDef, AgentConfig, SoloState, SoloAgentState, SoloAgentResult, SoloStatus, ProductPhase, ProductTaskStatus, ProductInstanceDef, ProductTaskDef, ProductStatus, ProductSummary, } from "./agent-methods.js";
 /** Pre-defined configuration for a known ACP backend. */
 export interface AcpBackendConfig {
     /** Backend ID, e.g. "claude" | "codex" | "goose". */
@@ -360,4 +360,4 @@ export interface SoloDeleteParams {
 export interface ProductDeleteParams {
     productId: string;
 }
-export type { AgentSource } from "../../protocol/wire/index.js";
+export type { AgentSource } from "./notification-payloads.js";