@agent-native/dispatch 0.7.0 → 0.8.1

package/src/components/workspace-resource-effective-stack.tsx

@@ -0,0 +1,141 @@
+import { useActionQuery } from "@agent-native/core/client";
+import { Badge } from "@/components/ui/badge";
+import { cn } from "@/lib/utils";
+
+export function appAvailabilityLabel(value?: string) {
+  switch (value) {
+    case "all-apps":
+      return "Inherited by all apps";
+    case "selected-granted":
+      return "Granted to this app";
+    case "selected-not-granted":
+      return "Not granted";
+    case "selected-no-app":
+      return "Select app";
+    case "path-not-managed":
+      return "Not managed";
+    default:
+      return "Checking";
+  }
+}
+
+export function appLayerState(layer: any): {
+  label: string;
+  className: string;
+} {
+  if (layer.effective) {
+    return {
+      label: "Wins",
+      className: "border-green-500/30 bg-green-500/10 text-green-700",
+    };
+  }
+  if (layer.overridden) {
+    return {
+      label: "Overridden",
+      className: "border-amber-500/30 bg-amber-500/10 text-amber-700",
+    };
+  }
+  return {
+    label: "Missing",
+    className: "text-muted-foreground",
+  };
+}
+
+export function formatResourceTimestamp(value?: number | null): string {
+  if (!value) return "not present";
+  return new Date(value).toLocaleString();
+}
+
+export function AppResourceEffectiveStack({
+  appId,
+  resource,
+}: {
+  appId: string;
+  resource: any;
+}) {
+  const { data: context, isLoading } = useActionQuery(
+    "get-workspace-resource-effective-context",
+    { resourceId: resource.id, appId },
+    { enabled: !!resource.id },
+  );
+  const layers = ((context as any)?.layers ?? []) as any[];
+  const active = (context as any)?.effectiveResource;
+  const availability = (context as any)?.availability;
+
+  if (isLoading && !context) {
+    return (
+      <div className="mt-3 rounded-lg border bg-muted/20 p-3">
+        <div className="h-3 w-44 animate-pulse rounded bg-muted-foreground/10" />
+        <div className="mt-3 grid gap-2 sm:grid-cols-3">
+          <div className="h-20 animate-pulse rounded-md bg-muted-foreground/10" />
+          <div className="h-20 animate-pulse rounded-md bg-muted-foreground/10" />
+          <div className="h-20 animate-pulse rounded-md bg-muted-foreground/10" />
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="mt-3 rounded-lg border bg-muted/20 p-3">
+      <div className="flex flex-wrap items-start justify-between gap-2">
+        <div className="min-w-0">
+          <div className="text-xs font-semibold uppercase text-muted-foreground">
+            Effective context stack
+          </div>
+          <div className="mt-1 truncate font-mono text-[11px] text-muted-foreground">
+            {resource.path}
+          </div>
+        </div>
+        <Badge variant="outline">{appAvailabilityLabel(availability)}</Badge>
+      </div>
+
+      <div className="mt-3 grid gap-2 sm:grid-cols-3">
+        {layers.map((layer) => {
+          const state = appLayerState(layer);
+          return (
+            <div
+              key={layer.scope}
+              className={cn("rounded-md border bg-background/70 p-2", {
+                "border-green-500/30 bg-green-500/10": layer.effective,
+              })}
+            >
+              <div className="flex items-start justify-between gap-2">
+                <span className="text-xs font-medium text-foreground">
+                  {layer.label}
+                </span>
+                <Badge variant="outline" className={state.className}>
+                  {state.label}
+                </Badge>
+              </div>
+              <div className="mt-1 truncate font-mono text-[10px] text-muted-foreground">
+                {layer.owner}
+              </div>
+              {layer.resource ? (
+                <div className="mt-2 text-[11px] text-muted-foreground">
+                  Updated {formatResourceTimestamp(layer.resource.updatedAt)}
+                </div>
+              ) : (
+                <div className="mt-2 text-[11px] text-muted-foreground">
+                  No file at this layer
+                </div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+
+      <div className="mt-3 rounded-md bg-background/70 px-3 py-2 text-xs text-muted-foreground">
+        {active ? (
+          <>
+            Winning layer:{" "}
+            <span className="font-mono text-foreground">
+              {active.owner}/{active.path}
+            </span>
+          </>
+        ) : (
+          "No active resource exists for this path yet."
+        )}
+      </div>
+    </div>
+  );
+}

package/src/components/workspace-resource-impact-preview.spec.tsx

@@ -0,0 +1,147 @@
+// @vitest-environment happy-dom
+import React, { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  ImpactPreview,
+  workspaceResourceMutationMessage,
+} from "./workspace-resource-impact-preview";
+
+const queryState = vi.hoisted(() => ({
+  result: { data: null as any, isLoading: false },
+  calls: [] as any[],
+}));
+
+vi.mock("@agent-native/core/client", () => ({
+  useActionQuery: (...args: any[]) => {
+    queryState.calls.push(args);
+    return queryState.result;
+  },
+}));
+
+describe("ImpactPreview", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    queryState.calls = [];
+    queryState.result = { data: null, isLoading: false };
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  });
+
+  it("renders All-app approval impact and override details", () => {
+    queryState.result = {
+      isLoading: false,
+      data: {
+        affectsAllApps: true,
+        affectedApps: { count: 4 },
+        approval: { willRequestApproval: true },
+        overrides: {
+          count: 2,
+          items: [
+            {
+              scope: "shared",
+              owner: "__shared__",
+              label: "Organization/app override",
+              updatedAt: 1,
+            },
+            {
+              scope: "personal",
+              owner: "person@example.test",
+              label: "Personal override (person@example.test)",
+              updatedAt: 2,
+            },
+          ],
+        },
+      },
+    };
+
+    act(() => {
+      root.render(
+        <ImpactPreview
+          operation="update"
+          resourceId="resource_1"
+          scope="all"
+        />,
+      );
+    });
+
+    expect(queryState.calls[0]).toEqual([
+      "preview-workspace-resource-change",
+      {
+        operation: "update",
+        resourceId: "resource_1",
+        path: undefined,
+        scope: "all",
+      },
+      { enabled: true },
+    ]);
+    expect(container.textContent).toContain("All apps impact");
+    expect(container.textContent).toContain("Approval required");
+    expect(container.textContent).toContain("2 overrides");
+    expect(container.textContent).toContain(
+      "This change applies to every workspace app (4 discovered).",
+    );
+    expect(container.textContent).toContain(
+      "It will be queued for approval before it takes effect.",
+    );
+    expect(container.textContent).toContain("Organization/app override");
+    expect(container.textContent).toContain(
+      "Personal override (person@example.test)",
+    );
+  });
+
+  it("renders selected-only changes as immediate", () => {
+    queryState.result = {
+      isLoading: false,
+      data: {
+        affectsAllApps: false,
+        affectedApps: { count: null },
+        approval: { willRequestApproval: false },
+        overrides: { count: 0, items: [] },
+      },
+    };
+
+    act(() => {
+      root.render(
+        <ImpactPreview
+          operation="create"
+          path="context/private-launch.md"
+          scope="selected"
+        />,
+      );
+    });
+
+    expect(container.textContent).toContain("Selected only");
+    expect(container.textContent).toContain(
+      "This change only applies to explicitly granted apps.",
+    );
+    expect(container.textContent).toContain(
+      "It will take effect immediately when saved.",
+    );
+  });
+
+  it("uses approval-request mutation copy only for workspace resource approvals", () => {
+    expect(
+      workspaceResourceMutationMessage(
+        { status: "pending", changeType: "workspace-resource.update" },
+        "Resource updated",
+      ),
+    ).toBe("Approval requested");
+    expect(
+      workspaceResourceMutationMessage(
+        { status: "pending", changeType: "dream-proposal.apply" },
+        "Resource updated",
+      ),
+    ).toBe("Resource updated");
+  });
+});

package/src/components/workspace-resource-impact-preview.tsx

@@ -0,0 +1,116 @@
+import { useActionQuery } from "@agent-native/core/client";
+import { Badge } from "@/components/ui/badge";
+import { Skeleton } from "@/components/ui/skeleton";
+import { formatResourceTimestamp } from "./workspace-resource-effective-stack";
+
+function isApprovalRequest(result: any): boolean {
+  return (
+    result?.status === "pending" &&
+    typeof result?.changeType === "string" &&
+    result.changeType.startsWith("workspace-resource.")
+  );
+}
+
+export function workspaceResourceMutationMessage(
+  result: any,
+  fallback: string,
+): string {
+  return isApprovalRequest(result) ? "Approval requested" : fallback;
+}
+
+export function ImpactPreview({
+  operation,
+  resourceId,
+  path,
+  scope,
+  enabled = true,
+}: {
+  operation: "create" | "update" | "delete";
+  resourceId?: string;
+  path?: string;
+  scope?: "all" | "selected";
+  enabled?: boolean;
+}) {
+  const { data: impact, isLoading } = useActionQuery(
+    "preview-workspace-resource-change",
+    {
+      operation,
+      resourceId,
+      path,
+      scope,
+    },
+    { enabled: enabled && Boolean(resourceId || path) },
+  );
+
+  if (!enabled || (!resourceId && !path)) return null;
+
+  if (isLoading) {
+    return (
+      <div className="rounded-lg border bg-muted/30 p-3">
+        <Skeleton className="h-4 w-40" />
+        <Skeleton className="mt-2 h-3 w-72" />
+      </div>
+    );
+  }
+
+  const data = impact as any;
+  if (!data) return null;
+  const affectsAllApps = data.affectsAllApps === true;
+  const appCount = data.affectedApps?.count;
+  const overrides = data.overrides ?? { count: 0, items: [] };
+  const willRequestApproval = data.approval?.willRequestApproval === true;
+
+  return (
+    <div className="rounded-lg border bg-muted/30 p-3 text-xs">
+      <div className="flex flex-wrap items-center gap-2">
+        <Badge variant={affectsAllApps ? "secondary" : "outline"}>
+          {affectsAllApps ? "All apps impact" : "Selected only"}
+        </Badge>
+        {willRequestApproval ? (
+          <Badge
+            variant="outline"
+            className="border-amber-500/30 bg-amber-500/10 text-amber-700 dark:text-amber-300"
+          >
+            Approval required
+          </Badge>
+        ) : null}
+        {overrides.count > 0 ? (
+          <Badge variant="outline">
+            {overrides.count} override{overrides.count === 1 ? "" : "s"}
+          </Badge>
+        ) : null}
+      </div>
+      <p className="mt-2 leading-relaxed text-muted-foreground">
+        {affectsAllApps
+          ? `This change applies to every workspace app${typeof appCount === "number" ? ` (${appCount} discovered)` : ""}.`
+          : "This change only applies to explicitly granted apps."}{" "}
+        {willRequestApproval
+          ? "It will be queued for approval before it takes effect."
+          : "It will take effect immediately when saved."}
+      </p>
+      {overrides.count > 0 ? (
+        <div className="mt-2 space-y-1">
+          {overrides.items.slice(0, 4).map((override: any) => (
+            <div
+              key={`${override.scope}:${override.owner}`}
+              className="flex items-center justify-between gap-3 rounded-md border bg-background px-2 py-1.5"
+            >
+              <span className="min-w-0 truncate text-muted-foreground">
+                {override.label}
+              </span>
+              <span className="shrink-0 font-mono text-[11px] text-muted-foreground">
+                {formatResourceTimestamp(override.updatedAt)}
+              </span>
+            </div>
+          ))}
+          {overrides.count > 4 ? (
+            <div className="text-muted-foreground">
+              +{overrides.count - 4} more override
+              {overrides.count - 4 === 1 ? "" : "s"}
+            </div>
+          ) : null}
+        </div>
+      ) : null}
+    </div>
+  );
+}

package/src/db/migrations.spec.ts

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const originalEnv = {
+  DATABASE_URL: process.env.DATABASE_URL,
+  DATABASE_AUTH_TOKEN: process.env.DATABASE_AUTH_TOKEN,
+};
+
+let tempDir: string | null = null;
+
+function restoreEnv() {
+  for (const [key, value] of Object.entries(originalEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+}
+
+async function setupTempDb() {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "dispatch-migrations-"));
+  process.env.DATABASE_URL = `file:${path.join(tempDir, "app.db")}`;
+  delete process.env.DATABASE_AUTH_TOKEN;
+  vi.resetModules();
+}
+
+beforeEach(async () => {
+  await setupTempDb();
+});
+
+afterEach(async () => {
+  try {
+    const { closeDbExec } = await import("@agent-native/core/db");
+    await closeDbExec();
+  } catch {}
+  restoreEnv();
+  if (tempDir) {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    tempDir = null;
+  }
+  vi.restoreAllMocks();
+});
+
+describe("dispatch migrations", () => {
+  it("quietly records source_health when the column already exists", async () => {
+    const [{ getDbExec, runMigrations }, { dispatchMigrations }] =
+      await Promise.all([
+        import("@agent-native/core/db"),
+        import("./migrations.js"),
+      ]);
+    const exec = getDbExec();
+    await exec.execute(`
+      CREATE TABLE dispatch_dreams (
+        id TEXT PRIMARY KEY,
+        source_health TEXT
+      )
+    `);
+    await exec.execute(
+      "CREATE TABLE dispatch_migrations (version INTEGER PRIMARY KEY)",
+    );
+    await exec.execute({
+      sql: "INSERT INTO dispatch_migrations VALUES (?)",
+      args: [3],
+    });
+
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    await runMigrations(dispatchMigrations, {
+      table: "dispatch_migrations",
+    })({});
+
+    expect(consoleError).not.toHaveBeenCalled();
+    const { rows } = await exec.execute(
+      "SELECT MAX(version) as version FROM dispatch_migrations",
+    );
+    expect(rows[0]?.version).toBe(4);
+  });
+});

package/src/db/migrations.ts

@@ -162,4 +162,63 @@ export const dispatchMigrations: Array<{ version: number; sql: string }> = [
       );
     `,
   },
+  {
+    version: 3,
+    sql: `
+      CREATE TABLE IF NOT EXISTS dispatch_dreams (
+        id TEXT PRIMARY KEY,
+        owner_email TEXT NOT NULL,
+        org_id TEXT,
+        source_id TEXT NOT NULL,
+        title TEXT NOT NULL,
+        status TEXT NOT NULL,
+        query TEXT,
+        report TEXT,
+        summary TEXT,
+        candidate_count INTEGER NOT NULL,
+        inspected_thread_count INTEGER NOT NULL,
+        created_by TEXT NOT NULL,
+        error TEXT,
+        started_at INTEGER NOT NULL,
+        completed_at INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS dispatch_dream_proposals (
+        id TEXT PRIMARY KEY,
+        dream_id TEXT NOT NULL,
+        owner_email TEXT NOT NULL,
+        org_id TEXT,
+        target_type TEXT NOT NULL,
+        target_path TEXT NOT NULL,
+        title TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        rationale TEXT NOT NULL,
+        content TEXT NOT NULL,
+        evidence TEXT NOT NULL,
+        confidence INTEGER NOT NULL,
+        risk TEXT NOT NULL,
+        status TEXT NOT NULL,
+        applied_by TEXT,
+        applied_at INTEGER,
+        rejected_by TEXT,
+        rejected_at INTEGER,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS dispatch_dreams_owner_updated_idx
+        ON dispatch_dreams (owner_email, org_id, updated_at);
+
+      CREATE INDEX IF NOT EXISTS dispatch_dream_proposals_dream_status_idx
+        ON dispatch_dream_proposals (dream_id, status);
+    `,
+  },
+  {
+    version: 4,
+    sql: `
+      ALTER TABLE dispatch_dreams ADD COLUMN IF NOT EXISTS source_health TEXT;
+    `,
+  },
 ];

package/src/db/schema.ts

@@ -73,6 +73,50 @@ export const dispatchAuditEvents = table("dispatch_audit_events", {
   createdAt: integer("created_at").notNull(),
 });
 
+export const dispatchDreams = table("dispatch_dreams", {
+  id: text("id").primaryKey(),
+  ownerEmail: text("owner_email").notNull(),
+  orgId: text("org_id"),
+  sourceId: text("source_id").notNull(),
+  title: text("title").notNull(),
+  status: text("status").notNull(),
+  query: text("query"),
+  report: text("report"),
+  summary: text("summary"),
+  sourceHealth: text("source_health"),
+  candidateCount: integer("candidate_count").notNull(),
+  inspectedThreadCount: integer("inspected_thread_count").notNull(),
+  createdBy: text("created_by").notNull(),
+  error: text("error"),
+  startedAt: integer("started_at").notNull(),
+  completedAt: integer("completed_at"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const dispatchDreamProposals = table("dispatch_dream_proposals", {
+  id: text("id").primaryKey(),
+  dreamId: text("dream_id").notNull(),
+  ownerEmail: text("owner_email").notNull(),
+  orgId: text("org_id"),
+  targetType: text("target_type").notNull(),
+  targetPath: text("target_path").notNull(),
+  title: text("title").notNull(),
+  summary: text("summary").notNull(),
+  rationale: text("rationale").notNull(),
+  content: text("content").notNull(),
+  evidence: text("evidence").notNull(),
+  confidence: integer("confidence").notNull(),
+  risk: text("risk").notNull(),
+  status: text("status").notNull(),
+  appliedBy: text("applied_by"),
+  appliedAt: integer("applied_at"),
+  rejectedBy: text("rejected_by"),
+  rejectedAt: integer("rejected_at"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
 // ─── Vault: workspace-wide secret management ───────────────────────
 
 export const vaultSecrets = table("vault_secrets", {
@@ -141,7 +185,7 @@ export const workspaceResources = table("workspace_resources", {
   description: text("description"),
   path: text("path").notNull(), // resource path, e.g. "skills/designer.md"
   content: text("content").notNull(),
-  scope: text("scope").notNull(), // "all" (push to all apps) | "selected" (grant per-app)
+  scope: text("scope").notNull(), // "all" (runtime inherited) | "selected" (grant per-app)
   createdBy: text("created_by").notNull(),
   createdAt: integer("created_at").notNull(),
   updatedAt: integer("updated_at").notNull(),
@@ -154,7 +198,7 @@ export const workspaceResourceGrants = table("workspace_resource_grants", {
   resourceId: text("resource_id").notNull(),
   appId: text("app_id").notNull(),
   status: text("status").notNull(), // "active" | "revoked"
-  syncedAt: integer("synced_at"),
+  syncedAt: integer("synced_at"), // legacy column retained for older rows
   createdAt: integer("created_at").notNull(),
   updatedAt: integer("updated_at").notNull(),
 });

package/src/hooks/use-navigation-state.ts

@@ -14,6 +14,9 @@ import type {
 export interface NavigationState {
   view: string;
   path?: string;
+  dreamId?: string;
+  sourceId?: string;
+  query?: string;
 }
 
 export function useNavigationState(extensions?: DispatchExtensionConfig) {
@@ -24,10 +27,19 @@ export function useNavigationState(extensions?: DispatchExtensionConfig) {
   // Sync current route to application state
   useEffect(() => {
     const localPathname = routerPath(location.pathname);
+    const params = new URLSearchParams(location.search);
     const state: NavigationState = {
       view: resolveView(localPathname, extensions),
       path: appPath(localPathname),
     };
+    if (state.view === "dreams") {
+      const dreamId = params.get("dreamId");
+      const sourceId = params.get("sourceId");
+      const query = params.get("query");
+      if (dreamId) state.dreamId = dreamId;
+      if (sourceId) state.sourceId = sourceId;
+      if (query) state.query = query;
+    }
 
     fetch(agentNativePath("/_agent-native/application-state/navigation"), {
       method: "PUT",
@@ -35,7 +47,7 @@ export function useNavigationState(extensions?: DispatchExtensionConfig) {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(state),
     }).catch(() => {});
-  }, [extensions, location.pathname]);
+  }, [extensions, location.pathname, location.search]);
 
   // Listen for navigate commands from agent
   const { data: navCommand } = useQuery({
@@ -66,10 +78,14 @@ export function useNavigationState(extensions?: DispatchExtensionConfig) {
     const cmd = navCommand as NavigationState;
 
     // Navigate to a specific path or resolve view name to path
-    const path = routerPath(
-      cmd.path || resolvePath(cmd.view, extensions) || "/overview",
-    );
-    navigate(path);
+    const resolvedPath =
+      cmd.path || resolvePath(cmd.view, extensions) || "/overview";
+    const path =
+      cmd.view === "dreams" && cmd.dreamId && !resolvedPath.includes("?")
+        ? `${resolvedPath}?dreamId=${encodeURIComponent(cmd.dreamId)}`
+        : resolvedPath;
+    const nextPath = routerPath(path);
+    navigate(nextPath);
     qc.setQueryData(["navigate-command"], null);
   }, [extensions, navCommand, navigate, qc]);
 }
@@ -139,6 +155,7 @@ function resolveView(
   if (pathname.startsWith("/identities")) return "identities";
   if (pathname.startsWith("/approvals")) return "approvals";
   if (pathname.startsWith("/audit")) return "audit";
+  if (pathname.startsWith("/dreams")) return "dreams";
   if (pathname.startsWith("/thread-debug")) return "thread-debug";
   if (pathname.startsWith("/team")) return "team";
   return "overview";
@@ -180,6 +197,8 @@ function resolvePath(
       return "/approvals";
     case "audit":
       return "/audit";
+    case "dreams":
+      return "/dreams";
     case "thread-debug":
     case "threads":
       return "/thread-debug";

package/src/lib/utils.ts

@@ -1 +1,6 @@
-export { cn } from "@agent-native/core";
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}