@agent-native/dispatch 0.7.0 → 0.8.0

package/src/actions/index.ts

@@ -8,14 +8,19 @@ import createVaultGrant from "./create-vault-grant.js";
 import createVaultSecret from "./create-vault-secret.js";
 import createWorkspaceResourceGrant from "./create-workspace-resource-grant.js";
 import createWorkspaceResource from "./create-workspace-resource.js";
+import createDreamReport from "./create-dream-report.js";
 import deleteDestination from "./delete-destination.js";
 import deleteVaultSecret from "./delete-vault-secret.js";
 import deleteWorkspaceResource from "./delete-workspace-resource.js";
 import denyVaultRequest from "./deny-vault-request.js";
+import ensureDreamJob from "./ensure-dream-job.js";
 import getAppCreationSettings from "./get-app-creation-settings.js";
 import getAgentThreadDebug from "./get-agent-thread-debug.js";
+import getDream from "./get-dream.js";
+import getDreamSettings from "./get-dream-settings.js";
 import getDispatchSettings from "./get-dispatch-settings.js";
 import getVaultAccessSettings from "./get-vault-access-settings.js";
+import getWorkspaceResourceEffectiveContext from "./get-workspace-resource-effective-context.js";
 import getWorkspaceInfo from "./get-workspace-info.js";
 import grantWorkspaceResourcesToApp from "./grant-workspace-resources-to-app.js";
 import grantVaultSecretsToApp from "./grant-vault-secrets-to-app.js";
@@ -27,6 +32,8 @@ import listDispatchApprovals from "./list-dispatch-approvals.js";
 import listDispatchAudit from "./list-dispatch-audit.js";
 import listDispatchOverview from "./list-dispatch-overview.js";
 import listDispatchUsageMetrics from "./list-dispatch-usage-metrics.js";
+import listDreamCandidates from "./list-dream-candidates.js";
+import listDreams from "./list-dreams.js";
 import listIntegrationsCatalog from "./list-integrations-catalog.js";
 import listLinkedIdentities from "./list-linked-identities.js";
 import listVaultAudit from "./list-vault-audit.js";
@@ -37,23 +44,29 @@ import listVaultSecrets from "./list-vault-secrets.js";
 import listWorkspaceApps from "./list-workspace-apps.js";
 import listWorkspaceResourceOptions from "./list-workspace-resource-options.js";
 import listWorkspaceResourceGrants from "./list-workspace-resource-grants.js";
+import listWorkspaceResourcesForApp from "./list-workspace-resources-for-app.js";
 import listWorkspaceResources from "./list-workspace-resources.js";
 import navigate from "./navigate.js";
+import applyDreamProposal from "./apply-dream-proposal.js";
+import previewDreamProposal from "./preview-dream-proposal.js";
+import previewWorkspaceResourceChange from "./preview-workspace-resource-change.js";
 import rejectDispatchChange from "./reject-dispatch-change.js";
+import rejectDreamProposal from "./reject-dream-proposal.js";
 import removePendingWorkspaceApp from "./remove-pending-workspace-app.js";
 import requestVaultSecret from "./request-vault-secret.js";
 import revokeVaultGrant from "./revoke-vault-grant.js";
 import revokeWorkspaceResourceGrant from "./revoke-workspace-resource-grant.js";
+import restoreStarterWorkspaceResources from "./restore-starter-workspace-resources.js";
 import scaffoldWorkspaceApp from "./scaffold-workspace-app.js";
 import searchAgentThreads from "./search-agent-threads.js";
+import sendCodeAgentRemoteCommand from "./send-code-agent-remote-command.js";
 import sendPlatformMessage from "./send-platform-message.js";
 import setAppCreationSettings from "./set-app-creation-settings.js";
 import setDispatchApprovalPolicy from "./set-dispatch-approval-policy.js";
+import setDreamSettings from "./set-dream-settings.js";
 import setVaultAccessSettings from "./set-vault-access-settings.js";
 import startWorkspaceAppCreation from "./start-workspace-app-creation.js";
 import syncVaultToApp from "./sync-vault-to-app.js";
-import syncWorkspaceResourcesToAll from "./sync-workspace-resources-to-all.js";
-import syncWorkspaceResourcesToApp from "./sync-workspace-resources-to-app.js";
 import unarchiveWorkspaceApp from "./unarchive-workspace-app.js";
 import updateWorkspaceAppMetadata from "./update-workspace-app-metadata.js";
 import updateVaultSecret from "./update-vault-secret.js";
@@ -77,14 +90,20 @@ export const dispatchActions: Record<string, ActionEntry> = {
   "create-vault-secret": createVaultSecret,
   "create-workspace-resource-grant": createWorkspaceResourceGrant,
   "create-workspace-resource": createWorkspaceResource,
+  "create-dream-report": createDreamReport,
   "delete-destination": deleteDestination,
   "delete-vault-secret": deleteVaultSecret,
   "delete-workspace-resource": deleteWorkspaceResource,
   "deny-vault-request": denyVaultRequest,
+  "ensure-dream-job": ensureDreamJob,
   "get-app-creation-settings": getAppCreationSettings,
   "get-agent-thread-debug": getAgentThreadDebug,
+  "get-dream": getDream,
+  "get-dream-settings": getDreamSettings,
   "get-dispatch-settings": getDispatchSettings,
   "get-vault-access-settings": getVaultAccessSettings,
+  "get-workspace-resource-effective-context":
+    getWorkspaceResourceEffectiveContext,
   "get-workspace-info": getWorkspaceInfo,
   "grant-workspace-resources-to-app": grantWorkspaceResourcesToApp,
   "grant-vault-secrets-to-app": grantVaultSecretsToApp,
@@ -96,6 +115,8 @@ export const dispatchActions: Record<string, ActionEntry> = {
   "list-dispatch-audit": listDispatchAudit,
   "list-dispatch-overview": listDispatchOverview,
   "list-dispatch-usage-metrics": listDispatchUsageMetrics,
+  "list-dream-candidates": listDreamCandidates,
+  "list-dreams": listDreams,
   "list-integrations-catalog": listIntegrationsCatalog,
   "list-linked-identities": listLinkedIdentities,
   "list-vault-audit": listVaultAudit,
@@ -106,23 +127,29 @@ export const dispatchActions: Record<string, ActionEntry> = {
   "list-workspace-apps": listWorkspaceApps,
   "list-workspace-resource-options": listWorkspaceResourceOptions,
   "list-workspace-resource-grants": listWorkspaceResourceGrants,
+  "list-workspace-resources-for-app": listWorkspaceResourcesForApp,
   "list-workspace-resources": listWorkspaceResources,
   navigate: navigate,
+  "apply-dream-proposal": applyDreamProposal,
+  "preview-dream-proposal": previewDreamProposal,
+  "preview-workspace-resource-change": previewWorkspaceResourceChange,
   "reject-dispatch-change": rejectDispatchChange,
+  "reject-dream-proposal": rejectDreamProposal,
   "remove-pending-workspace-app": removePendingWorkspaceApp,
   "request-vault-secret": requestVaultSecret,
   "revoke-vault-grant": revokeVaultGrant,
   "revoke-workspace-resource-grant": revokeWorkspaceResourceGrant,
+  "restore-starter-workspace-resources": restoreStarterWorkspaceResources,
   "scaffold-workspace-app": scaffoldWorkspaceApp,
   "search-agent-threads": searchAgentThreads,
+  "send-code-agent-remote-command": sendCodeAgentRemoteCommand,
   "send-platform-message": sendPlatformMessage,
   "set-app-creation-settings": setAppCreationSettings,
   "set-dispatch-approval-policy": setDispatchApprovalPolicy,
+  "set-dream-settings": setDreamSettings,
   "set-vault-access-settings": setVaultAccessSettings,
   "start-workspace-app-creation": startWorkspaceAppCreation,
   "sync-vault-to-app": syncVaultToApp,
-  "sync-workspace-resources-to-all": syncWorkspaceResourcesToAll,
-  "sync-workspace-resources-to-app": syncWorkspaceResourcesToApp,
   "unarchive-workspace-app": unarchiveWorkspaceApp,
   "update-workspace-app-metadata": updateWorkspaceAppMetadata,
   "update-vault-secret": updateVaultSecret,

package/src/actions/list-dream-candidates.ts

@@ -0,0 +1,77 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { listDreamCandidates } from "../server/lib/dreams-store.js";
+
+export default defineAction({
+  description:
+    "List recent agent threads worth reviewing in a Dispatch dream pass, scored from grounded signals like corrections, failures, tool errors, feedback, evals, and satisfaction.",
+  schema: z.object({
+    sourceId: z
+      .string()
+      .default("current")
+      .describe(
+        "Thread debug source id from list-agent-thread-sources. Use 'all' to scan every connected source.",
+      ),
+    sourceIds: z
+      .array(z.string().min(1))
+      .optional()
+      .describe(
+        "Optional explicit source ids to scan together. When provided, sourceId is treated as aggregate.",
+      ),
+    allSources: z.coerce
+      .boolean()
+      .default(false)
+      .describe(
+        "Scan every connected thread-debug source with partial results.",
+      ),
+    query: z
+      .string()
+      .optional()
+      .describe("Optional search term to focus candidate discovery."),
+    ownerEmail: z
+      .string()
+      .optional()
+      .describe(
+        "Optional owner email filter. Admins may pass '*' or omit to use their admin-visible scope.",
+      ),
+    limit: z.coerce.number().int().min(1).max(50).default(20),
+    sourceTimeoutMs: z.coerce
+      .number()
+      .int()
+      .min(1000)
+      .max(60000)
+      .default(15000)
+      .describe("Per-source timeout in milliseconds for partial scans."),
+    sourceConcurrency: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(8)
+      .default(2)
+      .describe("How many thread-debug sources to scan at once."),
+    sourceStartStaggerMs: z.coerce
+      .number()
+      .int()
+      .min(0)
+      .max(5000)
+      .default(250)
+      .describe("Delay between source starts within a scan batch."),
+    threadConcurrency: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(10)
+      .default(3)
+      .describe("How many threads to inspect at once within each source."),
+    threadTimeoutMs: z.coerce
+      .number()
+      .int()
+      .min(1000)
+      .max(30000)
+      .default(8000)
+      .describe("Per-thread debug timeout in milliseconds."),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (input) => listDreamCandidates(input),
+});

package/src/actions/list-dreams.ts

@@ -0,0 +1,17 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { listDreams } from "../server/lib/dreams-store.js";
+
+export default defineAction({
+  description: "List Dispatch dream reports with proposal status counts.",
+  schema: z.object({
+    limit: z.coerce.number().int().min(1).max(100).default(25),
+    status: z
+      .enum(["running", "completed", "failed", "all"])
+      .default("all")
+      .describe("Optional dream status filter."),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (input) => listDreams(input),
+});

package/src/actions/list-workspace-resources-for-app.ts

@@ -0,0 +1,13 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { listWorkspaceResourcesForApp } from "../server/lib/workspace-resources-store.js";
+
+export default defineAction({
+  description:
+    "List the inherited workspace and explicitly granted resources an app receives, including auto-loaded instructions.",
+  schema: z.object({
+    appId: z.string().describe("Workspace app ID"),
+  }),
+  http: { method: "GET" },
+  run: async (args) => listWorkspaceResourcesForApp(args.appId),
+});

package/src/actions/list-workspace-resources.ts

@@ -4,7 +4,7 @@ import { listWorkspaceResources } from "../server/lib/workspace-resources-store.
 
 export default defineAction({
   description:
-    "List all workspace-wide resources (skills, instructions, agents, and knowledge packs) that can be shared across apps.",
+    "List all workspace-wide resources (skills, instructions, agent profiles, and reference resources) that apps inherit at runtime.",
   schema: z.object({
     kind: z
       .enum(["skill", "instruction", "agent", "knowledge"])

package/src/actions/navigate.ts

@@ -5,6 +5,7 @@
  *
  * Usage:
  *   pnpm action navigate --view=overview
+ *   pnpm action navigate --view=dreams
  *   pnpm action navigate --view=<custom-dispatch-extension-id>
  *   pnpm action navigate --path=/some/route
  *
@@ -25,7 +26,7 @@ export default defineAction({
       .string()
       .optional()
       .describe(
-        "Named dispatch view to navigate to. Built-in views include overview, apps, metrics, new-app, vault, integrations, messaging, workspace, agents, destinations, identities, approvals, audit, thread-debug, and team. Generated Dispatch extension tabs can also use their nav item id.",
+        "Named dispatch view to navigate to. Built-in views include overview, apps, metrics, new-app, vault, integrations, messaging, workspace, agents, destinations, identities, approvals, audit, thread-debug, dreams, and team. Generated Dispatch extension tabs can also use their nav item id.",
       ),
     path: z.string().optional().describe("URL path to navigate to"),
   }),

package/src/actions/preview-dream-proposal.ts

@@ -0,0 +1,14 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { previewDreamProposal } from "../server/lib/dreams-store.js";
+
+export default defineAction({
+  description:
+    "Preview one Dispatch dream proposal before applying it, including target, current content, proposed content, and approval behavior.",
+  schema: z.object({
+    id: z.string().min(1).describe("Dream proposal id."),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async ({ id }) => previewDreamProposal(id),
+});

package/src/actions/preview-workspace-resource-change.ts

@@ -0,0 +1,25 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { previewWorkspaceResourceChange } from "../server/lib/workspace-resources-store.js";
+
+export default defineAction({
+  description:
+    "Preview the impact of creating, updating, or deleting a workspace resource, including All-app reach, overrides, and whether Dispatch approval will be requested.",
+  schema: z.object({
+    operation: z
+      .enum(["create", "update", "delete"])
+      .optional()
+      .describe("Change operation to preview."),
+    resourceId: z.string().optional().describe("Existing resource id."),
+    path: z
+      .string()
+      .optional()
+      .describe("Resource path, such as context/brand.md."),
+    scope: z
+      .enum(["all", "selected"])
+      .optional()
+      .describe("Resulting resource scope after the change."),
+  }),
+  http: { method: "GET" },
+  run: async (args) => previewWorkspaceResourceChange(args),
+});

package/src/actions/reject-dream-proposal.ts

@@ -0,0 +1,12 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { rejectDreamProposal } from "../server/lib/dreams-store.js";
+
+export default defineAction({
+  description: "Reject one pending Dispatch dream proposal.",
+  schema: z.object({
+    id: z.string().min(1).describe("Dream proposal id."),
+    reason: z.string().optional().describe("Optional rejection reason."),
+  }),
+  run: async ({ id, reason }) => rejectDreamProposal(id, reason),
+});

package/src/actions/restore-starter-workspace-resources.ts

@@ -0,0 +1,17 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { restoreStarterWorkspaceResources } from "../server/lib/workspace-resources-store.js";
+
+export default defineAction({
+  description:
+    "Restore missing starter global workspace resources such as company, brand, messaging, guardrails, and company voice. Existing resources are left unchanged.",
+  schema: z.object({
+    paths: z
+      .array(z.string())
+      .optional()
+      .describe(
+        "Optional starter resource paths to restore. Omit to restore every missing starter resource.",
+      ),
+  }),
+  run: async (args) => restoreStarterWorkspaceResources(args),
+});

package/src/actions/send-code-agent-remote-command.ts

@@ -0,0 +1,59 @@
+import { defineAction } from "@agent-native/core";
+import { getRequestUserEmail } from "@agent-native/core/server";
+import { z } from "zod";
+import {
+  enqueueRemoteCodeCommand,
+  type RemoteCodeCommandEnvelope,
+} from "../server/lib/dispatch-remote-commands.js";
+
+const commandSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("create"), prompt: z.string().min(1) }),
+  z.object({ type: z.literal("list") }),
+  z.object({ type: z.literal("status"), runRef: z.string().optional() }),
+  z.object({
+    type: z.literal("continue"),
+    runRef: z.string().min(1),
+    text: z.string().min(1),
+  }),
+  z.object({ type: z.literal("approve"), approvalId: z.string().min(1) }),
+  z.object({ type: z.literal("deny"), approvalId: z.string().min(1) }),
+  z.object({ type: z.literal("stop"), runRef: z.string().min(1) }),
+]);
+
+export default defineAction({
+  description:
+    "Route a command to the remote Agent-Native Code host through the integration relay.",
+  schema: z.object({
+    command: commandSchema,
+    source: z
+      .object({
+        platform: z.string().default("dispatch"),
+        externalThreadId: z.string().default("dispatch"),
+        senderId: z.string().optional(),
+        senderName: z.string().optional(),
+        messageId: z.string().optional(),
+        timestamp: z.number().optional(),
+      })
+      .optional(),
+  }),
+  run: async ({ command, source }) => {
+    const ownerEmail = getRequestUserEmail();
+    if (!ownerEmail) throw new Error("no authenticated user");
+
+    const envelope: RemoteCodeCommandEnvelope = {
+      kind: "code-agent",
+      ownerEmail,
+      command,
+      source: {
+        platform: source?.platform || "dispatch",
+        externalThreadId: source?.externalThreadId || "dispatch",
+        senderId: source?.senderId,
+        senderName: source?.senderName,
+        messageId: source?.messageId,
+        timestamp: source?.timestamp ?? Date.now(),
+      },
+    };
+
+    return enqueueRemoteCodeCommand(envelope);
+  },
+});

package/src/actions/set-dream-settings.spec.ts

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  setDreamSettings: vi.fn(),
+}));
+
+vi.mock("../server/lib/dreams-store.js", () => ({
+  setDreamSettings: mocks.setDreamSettings,
+}));
+
+import action from "./set-dream-settings.js";
+
+describe("set-dream-settings action", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.setDreamSettings.mockImplementation(async (input) => ({
+      enabled: false,
+      schedule: "0 9 * * 1",
+      sourceId: "all",
+      sourceIds: [],
+      allSources: true,
+      query: null,
+      limit: 8,
+      sourceTimeoutMs: 30000,
+      sourceConcurrency: 2,
+      sourceStartStaggerMs: 250,
+      threadConcurrency: 3,
+      threadTimeoutMs: 8000,
+      minCandidateCount: 1,
+      ...input,
+    }));
+  });
+
+  it("coerces numeric fields and preserves explicit clears", async () => {
+    await action.run({
+      enabled: true,
+      schedule: "0 8 * * 2",
+      sourceId: "current",
+      sourceIds: [],
+      allSources: false,
+      query: "",
+      limit: "50",
+      sourceTimeoutMs: "60000",
+      sourceConcurrency: "8",
+      sourceStartStaggerMs: "5000",
+      threadConcurrency: "10",
+      threadTimeoutMs: "30000",
+      minCandidateCount: "0",
+    } as any);
+
+    expect(mocks.setDreamSettings).toHaveBeenCalledWith({
+      enabled: true,
+      schedule: "0 8 * * 2",
+      sourceId: "current",
+      sourceIds: [],
+      allSources: false,
+      query: "",
+      limit: 50,
+      sourceTimeoutMs: 60000,
+      sourceConcurrency: 8,
+      sourceStartStaggerMs: 5000,
+      threadConcurrency: 10,
+      threadTimeoutMs: 30000,
+      minCandidateCount: 0,
+    });
+  });
+
+  it("rejects out-of-range numeric settings before writing", async () => {
+    await expect(action.run({ limit: "0" } as any)).rejects.toThrow(
+      /Invalid action parameters/,
+    );
+    await expect(
+      action.run({ sourceTimeoutMs: "60001" } as any),
+    ).rejects.toThrow(/Invalid action parameters/);
+    await expect(
+      action.run({ threadTimeoutMs: "30001" } as any),
+    ).rejects.toThrow(/Invalid action parameters/);
+
+    expect(mocks.setDreamSettings).not.toHaveBeenCalled();
+  });
+});

package/src/actions/set-dream-settings.ts

@@ -0,0 +1,44 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { setDreamSettings } from "../server/lib/dreams-store.js";
+
+export default defineAction({
+  description:
+    "Update recurring Dispatch dream settings without immediately running or applying a dream pass.",
+  schema: z.object({
+    enabled: z
+      .boolean()
+      .optional()
+      .describe("Whether recurring dreams are on."),
+    schedule: z
+      .string()
+      .optional()
+      .describe('Five-field cron schedule, for example "0 9 * * 1".'),
+    sourceId: z
+      .string()
+      .optional()
+      .describe(
+        "Thread debug source id. Use 'all' for every connected source.",
+      ),
+    sourceIds: z
+      .array(z.string().min(1))
+      .optional()
+      .describe("Optional explicit source ids to scan together."),
+    allSources: z.coerce
+      .boolean()
+      .optional()
+      .describe("Scan every connected thread-debug source."),
+    query: z
+      .string()
+      .optional()
+      .describe("Optional search term for recurring dream passes."),
+    limit: z.coerce.number().int().min(1).max(50).optional(),
+    sourceTimeoutMs: z.coerce.number().int().min(1000).max(60000).optional(),
+    sourceConcurrency: z.coerce.number().int().min(1).max(8).optional(),
+    sourceStartStaggerMs: z.coerce.number().int().min(0).max(5000).optional(),
+    threadConcurrency: z.coerce.number().int().min(1).max(10).optional(),
+    threadTimeoutMs: z.coerce.number().int().min(1000).max(30000).optional(),
+    minCandidateCount: z.coerce.number().int().min(0).max(50).optional(),
+  }),
+  run: async (input) => setDreamSettings(input),
+});

package/src/actions/update-workspace-resource.ts

@@ -4,7 +4,7 @@ import { updateWorkspaceResource } from "../server/lib/workspace-resources-store
 
 export default defineAction({
   description:
-    "Update a workspace resource's name, description, content, or scope.",
+    "Update a workspace resource's name, description, content, or scope. When Dispatch approval policy is enabled, changes that affect All-app resources queue an approval request before taking effect.",
   schema: z.object({
     id: z.string().describe("Resource ID"),
     name: z.string().optional().describe("New name"),

package/src/actions/view-screen.ts

@@ -20,13 +20,36 @@ import {
 } from "../server/lib/vault-store.js";
 import { listWorkspaceApps } from "../server/lib/app-creation-store.js";
 import { listDispatchUsageMetrics } from "../server/lib/usage-metrics-store.js";
-import { listWorkspaceResourceOptions } from "../server/lib/workspace-resources-store.js";
+import {
+  listWorkspaceResourceOptions,
+  listWorkspaceResourcesForApp,
+} from "../server/lib/workspace-resources-store.js";
 import {
   getAgentThreadDebug,
   listThreadDebugSources,
   searchAgentThreads,
 } from "../server/lib/thread-debug-store.js";
 
+async function runLocalDispatchAction(
+  name: string,
+  args: Record<string, unknown>,
+) {
+  const modulePath = `./${name}.js`;
+  const module = (await import(/* @vite-ignore */ modulePath)) as {
+    default?: {
+      run: (args: Record<string, unknown>) => unknown | Promise<unknown>;
+    };
+  };
+  if (!module.default) throw new Error(`Dispatch action not found: ${name}`);
+  return module.default.run(stripUndefined(args));
+}
+
+function stripUndefined(args: Record<string, unknown>) {
+  return Object.fromEntries(
+    Object.entries(args).filter(([, value]) => value !== undefined),
+  );
+}
+
 export default defineAction({
   description:
     "See what the user is currently looking at in the dispatch UI, including navigation state and a compact operational summary.",
@@ -57,9 +80,32 @@ export default defineAction({
       navigation?.view === "apps" ||
       navigation?.view === "new-app"
     ) {
-      screen.workspaceApps = await listWorkspaceApps({
+      const workspaceApps = await listWorkspaceApps({
         includeAgentCards: true,
       });
+      screen.workspaceApps = workspaceApps;
+      if (navigation?.view === "apps") {
+        screen.workspaceAppResources = await Promise.all(
+          workspaceApps
+            .filter((app) => !app.isDispatch)
+            .slice(0, 12)
+            .map(async (app) => {
+              const result = await listWorkspaceResourcesForApp(app.id);
+              return {
+                appId: app.id,
+                appName: app.name,
+                counts: result.counts,
+                resources: result.resources.map((resource) => ({
+                  name: resource.name,
+                  path: resource.path,
+                  kind: resource.kind,
+                  source: resource.source,
+                  autoLoaded: resource.autoLoaded,
+                })),
+              };
+            }),
+        );
+      }
     }
     if (navigation?.view === "metrics") {
       try {
@@ -99,6 +145,16 @@ export default defineAction({
     }
     if (navigation?.view === "workspace" || navigation?.view === "new-app") {
       screen.workspaceResources = await listWorkspaceResourceOptions();
+      screen.workspaceResourceEffectiveContext = {
+        action: "get-workspace-resource-effective-context",
+        description:
+          "Preview workspace -> organization/app -> personal precedence for a resource path and optional app/user. All-app resources are inherited at runtime; selected resources are app-specific exceptions.",
+      };
+      screen.workspaceResourceImpactPreview = {
+        action: "preview-workspace-resource-change",
+        description:
+          "Preview All-app reach, overrides, and approval behavior before creating, updating, or deleting a workspace resource.",
+      };
     }
     if (navigation?.view === "thread-debug") {
       try {
@@ -136,6 +192,38 @@ export default defineAction({
           error instanceof Error ? error.message : String(error);
       }
     }
+    if (navigation?.view === "dreams") {
+      try {
+        const nav = navigation as Record<string, any>;
+        const [sources, candidates, dreams, settings] = await Promise.all([
+          listThreadDebugSources(),
+          runLocalDispatchAction("list-dream-candidates", {
+            sourceId: nav.sourceId,
+            ownerEmail: nav.ownerEmail,
+            limit: 10,
+          }),
+          runLocalDispatchAction("list-dreams", {
+            status: nav.status,
+            limit: 10,
+          }),
+          runLocalDispatchAction("get-dream-settings", {}),
+        ]);
+        screen.dreamSources = sources;
+        screen.dreamCandidates = candidates;
+        screen.latestDreams = dreams;
+        screen.dreamSettings = settings;
+
+        const dreamId = nav.dreamId ?? nav.id;
+        if (dreamId) {
+          screen.dreamDetail = await runLocalDispatchAction("get-dream", {
+            id: dreamId,
+          });
+        }
+      } catch (error) {
+        screen.dreamsError =
+          error instanceof Error ? error.message : String(error);
+      }
+    }
 
     if (Object.keys(screen).length === 0) {
       return "No application state found. Is the app running?";