@plandesk/api 0.20.0 → 1.0.0-beta.2

package/dist/routes/shares.js

@@ -26,7 +26,7 @@ export function createSharesRouter(shareService) {
             return c.json({ error: 'invalid_expires' }, 400);
         }
         const origin = new URL(c.req.url).origin;
-        const result = shareService.createResourceShare({ resource: { kind, id }, expiresAt: resolveExpiresAt(body.expires) }, origin);
+        const result = await shareService.createResourceShare({ resource: { kind, id }, expiresAt: resolveExpiresAt(body.expires) }, origin);
         if (!result) {
             return c.json({ error: 'not_found' }, 404);
         }
@@ -36,14 +36,14 @@ export function createSharesRouter(shareService) {
     router.post('/documents/:id/share', createShareHandler('document'));
     // Hono doesn't match a literal `.md` suffix inside a param, so the route
     // takes the raw segment and the handler enforces + strips the extension.
-    router.get('/share/:tokenWithExt', (c) => {
+    router.get('/share/:tokenWithExt', async (c) => {
         const raw = c.req.param('tokenWithExt');
         if (!raw.endsWith('.md')) {
             return c.notFound();
         }
         const token = raw.slice(0, -'.md'.length);
         const origin = new URL(c.req.url).origin;
-        const result = shareService.getResourceMarkdown(token, origin);
+        const result = await shareService.getResourceMarkdown(token, origin);
         if (result.status === 'not_found') {
             return c.json({ error: 'not_found' }, 404);
         }
@@ -52,6 +52,95 @@ export function createSharesRouter(shareService) {
         }
         return c.body(result.markdown, 200, { 'Content-Type': 'text/markdown; charset=utf-8' });
     });
+    // Pre-join: audience name + mode so the portal can render the join gate.
+    router.get('/share/:token/meta', async (c) => {
+        const token = c.req.param('token');
+        const result = await shareService.getShareMeta(token);
+        if (result.status === 'not_found') {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json({ audience_name: result.audienceName, mode: result.mode });
+    });
+    // Named join: gate by invite allow-list when mode=invite; mint guest session.
+    router.post('/share/:token/join', async (c) => {
+        const token = c.req.param('token');
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: 'invalid_json' }, 400);
+        }
+        const result = await shareService.joinShare(token, {
+            name: body.name ?? '',
+            email: body.email,
+        });
+        if (result.status === 'unauthorized') {
+            return c.json({ error: 'unauthorized' }, 401);
+        }
+        if (result.status === 'name_required') {
+            return c.json({ error: 'name_required' }, 400);
+        }
+        if (result.status === 'email_not_invited') {
+            return c.json({ error: 'email_not_invited' }, 403);
+        }
+        return c.json({
+            session_token: result.sessionToken,
+            participant: result.participant,
+            share: {
+                audience_name: result.share.audienceName,
+                permissions: result.share.permissions,
+            },
+        });
+    });
+    // Guest-session-gated portal view (middleware sets AuthContext kind guest).
+    // Live projection per request; uniform 404 on any failure shape.
+    router.get('/share/:token/view', async (c) => {
+        const token = c.req.param('token');
+        const view = await shareService.getClientView(token);
+        if (view === undefined) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(view);
+    });
+    // Guest moderated inbox — same guest session as view (BA6b single-server).
+    router.post('/share/:token/submissions', async (c) => {
+        const token = c.req.param('token');
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: 'invalid_json' }, 400);
+        }
+        const result = await shareService.submitIssue(token, {
+            title: body.title ?? '',
+            body: body.body,
+            severity: body.severity,
+            task_ref: body.task_ref,
+        });
+        if (result.status === 'unauthorized') {
+            return c.json({ error: 'unauthorized' }, 401);
+        }
+        if (result.status === 'submit_not_permitted') {
+            return c.json({ error: 'submit_not_permitted' }, 403);
+        }
+        if (result.status === 'title_required') {
+            return c.json({ error: 'title_required' }, 400);
+        }
+        if (result.status === 'rate_limited') {
+            return c.json({ error: 'rate_limited' }, 429);
+        }
+        return c.json({ submission: result.submission }, 201);
+    });
+    router.get('/share/:token/submissions', async (c) => {
+        const token = c.req.param('token');
+        const result = await shareService.listMySubmissions(token);
+        if (result.status === 'unauthorized') {
+            return c.json({ error: 'unauthorized' }, 401);
+        }
+        return c.json(result.submissions);
+    });
     return router;
 }
 //# sourceMappingURL=shares.js.map

package/dist/routes/submissions.js

@@ -6,16 +6,16 @@ function isSubmissionStatus(value) {
 }
 export function createSubmissionsRouter(syncService, projectService) {
     const router = new Hono();
-    router.get('/projects/:id/submissions', (c) => {
+    router.get('/projects/:id/submissions', async (c) => {
         const projectId = c.req.param('id');
-        if (!projectService.get(projectId)) {
+        if (!(await projectService.get(projectId))) {
             return c.json({ error: 'not_found' }, 404);
         }
         const statusParam = c.req.query('status') ?? 'pending';
         if (!isSubmissionStatus(statusParam)) {
             return c.json({ error: 'invalid_argument' }, 400);
         }
-        return c.json(syncService.listTriage(projectId, statusParam));
+        return c.json(await syncService.listTriage(projectId, statusParam));
     });
     router.post('/submissions/:id/triage', async (c) => {
         const submissionId = c.req.param('id');
@@ -23,14 +23,13 @@ export function createSubmissionsRouter(syncService, projectService) {
         if (body.action !== 'accept' && body.action !== 'reject') {
             return c.json({ error: 'invalid_argument' }, 400);
         }
-        const submission = syncService.getSubmission(submissionId);
+        const submission = await syncService.getSubmission(submissionId);
         if (submission === undefined) {
             return c.json({ error: 'not_found' }, 404);
         }
-        const remote = syncService.getRemote(submission.project_id);
-        if (remote === undefined) {
-            return c.json({ error: 'not_published' }, 400);
-        }
+        // Optional remote: single-server guest submit has no cross-server ack target.
+        // Legacy local→remote pull still stores a remote when present.
+        const remote = await syncService.getRemote(submission.project_id);
         try {
             // Triage never creates a `todo` task — the scope->todo release is the human's own
             // board action, enforced in syncService.triage(). A merge (link_task_id) links to

package/dist/routes/tags.js

@@ -2,8 +2,8 @@ import { Hono } from 'hono';
 import { InvalidTagError } from '../services/tags.js';
 export function createTagsRouter(tagService) {
     const router = new Hono();
-    router.get('/projects/:id/tags', (c) => {
-        const tags = tagService.list(c.req.param('id'));
+    router.get('/projects/:id/tags', async (c) => {
+        const tags = await tagService.list(c.req.param('id'));
         if (!tags) {
             return c.json({ error: 'not_found' }, 404);
         }
@@ -15,7 +15,7 @@ export function createTagsRouter(tagService) {
             return c.json({ error: 'invalid_argument' }, 400);
         }
         try {
-            const tag = tagService.create(c.req.param('id'), {
+            const tag = await tagService.create(c.req.param('id'), {
                 name: body.name,
                 color: body.color,
             });
@@ -34,7 +34,7 @@ export function createTagsRouter(tagService) {
     router.patch('/tags/:id', async (c) => {
         const body = await c.req.json();
         try {
-            const tag = tagService.update(c.req.param('id'), {
+            const tag = await tagService.update(c.req.param('id'), {
                 ...(body.name !== undefined ? { name: body.name } : {}),
                 ...(body.color !== undefined ? { color: body.color } : {}),
             });
@@ -50,8 +50,8 @@ export function createTagsRouter(tagService) {
             throw error;
         }
     });
-    router.delete('/tags/:id', (c) => {
-        const deleted = tagService.delete(c.req.param('id'));
+    router.delete('/tags/:id', async (c) => {
+        const deleted = await tagService.delete(c.req.param('id'));
         if (!deleted) {
             return c.json({ error: 'not_found' }, 404);
         }

package/dist/routes/tasks.js

@@ -15,7 +15,7 @@ export function createTasksRouter(taskService) {
             return c.json({ error: 'invalid_argument' }, 400);
         }
         try {
-            const task = taskService.update(c.req.param('id'), {
+            const task = await taskService.update(c.req.param('id'), {
                 ...(body.label !== undefined ? { label: body.label } : {}),
                 ...(body.status !== undefined ? { status: body.status } : {}),
                 ...(body.description !== undefined ? { description: body.description } : {}),
@@ -35,13 +35,24 @@ export function createTasksRouter(taskService) {
             throw error;
         }
     });
-    router.delete('/tasks/:id', (c) => {
-        const deleted = taskService.delete(c.req.param('id'));
+    router.delete('/tasks/:id', async (c) => {
+        const deleted = await taskService.delete(c.req.param('id'));
         if (!deleted) {
             return c.json({ error: 'not_found' }, 404);
         }
         return c.body(null, 204);
     });
+    router.post('/tasks/:id/claim', async (c) => {
+        const body = await c.req.json();
+        if (typeof body.agent_ref !== 'string' || body.agent_ref.length === 0) {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        const result = await taskService.claim(c.req.param('id'), body.agent_ref);
+        if (!result.claimed) {
+            return c.json(result, 409);
+        }
+        return c.json(result);
+    });
     return router;
 }
 //# sourceMappingURL=tasks.js.map

package/dist/routes/tokens.js

@@ -6,12 +6,12 @@ export function createTokensRouter(tokenService) {
         if (typeof body.name !== 'string' || body.name.trim() === '') {
             return c.json({ error: 'invalid_argument' }, 400);
         }
-        const created = tokenService.create(body.name.trim());
+        const created = await tokenService.create(body.name.trim());
         return c.json(created, 201);
     });
-    router.get('/mcp-tokens', (c) => c.json(tokenService.list()));
-    router.delete('/mcp-tokens/:id', (c) => {
-        const revoked = tokenService.revoke(c.req.param('id'));
+    router.get('/mcp-tokens', async (c) => c.json(await tokenService.list()));
+    router.delete('/mcp-tokens/:id', async (c) => {
+        const revoked = await tokenService.revoke(c.req.param('id'));
         if (!revoked) {
             return c.json({ error: 'not_found' }, 404);
         }

package/dist/serialize.d.ts

@@ -33,7 +33,7 @@ export declare function serializeGoal(goal: Goal): {
     id: string;
     project_id: string;
     objective: string;
-    status: "active" | "paused" | "complete" | "blocked";
+    status: "paused" | "active" | "complete" | "blocked";
     verification_surface: string | null;
     constraints: string | null;
     boundaries: string | null;
@@ -55,7 +55,7 @@ export declare function serializeTask(task: Task, tags?: Tag[]): {
     project_id: string;
     goal_id: string;
     label: string;
-    status: "scope" | "todo" | "in_progress" | "done" | "backlog";
+    status: "in_progress" | "done" | "todo" | "scope" | "backlog";
     description: string | null;
     x: number;
     y: number;
@@ -150,7 +150,7 @@ export declare function serializeEdge(edge: Edge): {
 export declare function serializeAgentRun(run: AgentRun): {
     id: string;
     project_id: string;
-    status: "running" | "completed" | "failed";
+    status: "completed" | "running" | "failed";
     label: string | null;
     started_at: string;
     completed_at: string | null;

package/dist/server.d.ts

@@ -1,13 +1,31 @@
 import { Hono } from 'hono';
 import type { Db } from '@plandesk/db';
-import type { EventBus } from './events.js';
+import type { GithubConfig } from './github.js';
+import type { BetterAuthInstance } from './better-auth.js';
 import { type Services } from './services/index.js';
 export type AppDeps = {
     db: Db;
-    eventBus?: EventBus;
     services?: Services;
     mcp?: Hono;
     authPassword?: string;
+    /** Server bind host — loopback default-org only when this is loopback. Default 127.0.0.1. */
+    bindHost?: string;
+    /**
+     * GitHub app for better-auth social sign-in. Omit it and the instance simply
+     * has no GitHub sign-in; /auth/methods reports githubEnabled:false.
+     * Self-hosting must never require registering an app (REQ-20).
+     */
+    github?: GithubConfig;
+    /**
+     * better-auth (GitHub sign-in + session + apiKey). Omit and /api/auth/* 404s;
+     * when set, org middleware recognizes better-auth session cookies and API keys.
+     */
+    betterAuth?: {
+        secret: string;
+        baseURL: string;
+    };
+    /** Reuse a better-auth instance owned by an edge entry across requests. */
+    betterAuthInstance?: BetterAuthInstance;
 };
 export declare function createApp(deps: AppDeps): Hono;
 //# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -1,6 +1,8 @@
 import { Hono } from 'hono';
-import { createAuthMiddleware } from './auth.js';
+import { createAuthMiddleware, createOrgAuthMiddleware, createWriteGuardMiddleware, } from './auth.js';
 import { healthRouter } from './routes/health.js';
+import { createAuthRouter } from './routes/auth.js';
+import { createBetterAuth } from './better-auth.js';
 import { createProjectsRouter } from './routes/projects.js';
 import { createTasksRouter } from './routes/tasks.js';
 import { createTagsRouter } from './routes/tags.js';
@@ -12,21 +14,60 @@ import { createFilesRouter } from './routes/files.js';
 import { createFoldersRouter } from './routes/folders.js';
 import { createNotesRouter } from './routes/notes.js';
 import { createSharesRouter } from './routes/shares.js';
-import { createEventsRouter } from './routes/events.js';
-import { createTokensRouter } from './routes/tokens.js';
 import { createAgentRunsRouter } from './routes/agent-runs.js';
 import { createGoalsRouter } from './routes/goals.js';
 import { createSubmissionsRouter } from './routes/submissions.js';
-import { mountStatic } from './static.js';
+import { createOrgsRouter } from './routes/orgs.js';
 import { createServices } from './services/index.js';
+import { ProjectNotInOrgError } from './services/scope.js';
+import { ReadOnlyTokenError } from './auth-context.js';
+import { PermissionDeniedError } from './permissions.js';
 export function createApp(deps) {
-    const services = deps.services ?? createServices({ db: deps.db, eventBus: deps.eventBus });
-    const { eventBus, projectService, goalService, taskService, tagService, canvasService, documentService, folderService, noteService, commentService, agentRunService, tokenService, syncService, fileService, artifactService, shareService, } = services;
+    const services = deps.services ?? createServices({ db: deps.db });
+    const { projectService, goalService, taskService, tagService, canvasService, documentService, folderService, noteService, commentService, agentRunService, syncService, fileService, artifactService, shareService, } = services;
+    const bindHost = deps.bindHost ?? '127.0.0.1';
     const app = new Hono();
+    // Create better-auth before org middleware so the same instance is recognized
+    // by AuthContext and mounted at /api/auth/* (BA4a session recognition).
+    const betterAuthInstance = deps.betterAuthInstance ??
+        (deps.betterAuth !== undefined
+            ? createBetterAuth({
+                client: deps.db.$client,
+                db: deps.db,
+                secret: deps.betterAuth.secret,
+                baseURL: deps.betterAuth.baseURL,
+                github: deps.github,
+            })
+            : undefined);
+    // Always-on org resolution (better-auth apiKey/session, loopback, or guest).
+    app.use('*', createOrgAuthMiddleware({
+        db: deps.db,
+        bindHost,
+        betterAuth: betterAuthInstance,
+    }));
+    app.use('*', createWriteGuardMiddleware());
     if (deps.authPassword !== undefined && deps.authPassword.length > 0) {
         app.use('*', createAuthMiddleware(deps.authPassword));
     }
+    app.onError((err, c) => {
+        if (err instanceof ProjectNotInOrgError) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        if (err instanceof ReadOnlyTokenError || err instanceof PermissionDeniedError) {
+            return c.json({ error: 'forbidden' }, 403);
+        }
+        throw err;
+    });
     app.route('/api/v1', healthRouter);
+    app.route('/api/v1', createAuthRouter({
+        db: deps.db,
+        github: deps.github,
+        betterAuth: betterAuthInstance,
+    }));
+    app.route('/api/v1', createOrgsRouter(deps.db, {
+        betterAuth: betterAuthInstance,
+        baseURL: deps.betterAuth?.baseURL,
+    }));
     app.route('/api/v1', createProjectsRouter(projectService, taskService));
     app.route('/api/v1', createGoalsRouter(goalService));
     app.route('/api/v1', createTasksRouter(taskService));
@@ -39,10 +80,8 @@ export function createApp(deps) {
     app.route('/api/v1', createNotesRouter(noteService));
     app.route('/api/v1', createSharesRouter(shareService));
     app.route('/api/v1', createCommentsRouter(commentService));
-    app.route('/api/v1', createTokensRouter(tokenService));
     app.route('/api/v1', createAgentRunsRouter(agentRunService));
     app.route('/api/v1', createSubmissionsRouter(syncService, projectService));
-    app.route('/api/v1', createEventsRouter(eventBus));
     // Mount the MCP router BEFORE the static/SPA handler. The MCP transport uses
     // GET /mcp/ for its server->client SSE stream; if the SPA catch-all (app.get('*'))
     // is registered first it shadows that GET and the stream never reaches the
@@ -50,7 +89,16 @@ export function createApp(deps) {
     if (deps.mcp) {
         app.route('/mcp', deps.mcp);
     }
-    mountStatic(app);
+    // Mounted at /api/auth/*, one segment away from the existing /api/v1/auth/*
+    // (routes/auth.ts) so it can never shadow it. /api/auth/* is public so a
+    // stranger can reach sign-in without a plandesk credential first (BA4a).
+    if (betterAuthInstance) {
+        app.on(['GET', 'POST'], '/api/auth/*', (c) => betterAuthInstance.handler(c.req.raw));
+    }
+    // SPA static files are NOT mounted here. Node mounts them via `mountStatic`
+    // in the serve entry; Workers/Vercel serve the SPA through platform assets.
+    // Keeping static out of createApp prevents node:fs and @hono/node-server
+    // from entering the edge bundle graph.
     app.notFound((c) => c.json({ error: 'not_found' }, 404));
     return app;
 }

package/dist/services/agent-runs.d.ts

@@ -1,15 +1,14 @@
 import { type Db } from '@plandesk/db';
-import type { EventBus } from '../events.js';
 import { type PaginationParams } from '../serialize.js';
-export type AgentRunServiceDeps = {
+import { type OrgScopedDeps } from './org-scope.js';
+export type AgentRunServiceDeps = OrgScopedDeps & {
     db: Db;
-    eventBus: EventBus;
 };
 export declare class InvalidAgentRunError extends Error {
     constructor(message: string);
 }
 export declare function createAgentRunService(deps: AgentRunServiceDeps): {
-    listForProject(projectId: string, pagination?: PaginationParams): {
+    listForProject(projectId: string, pagination?: PaginationParams): Promise<{
         events: {
             id: string;
             message: string;
@@ -17,33 +16,33 @@ export declare function createAgentRunService(deps: AgentRunServiceDeps): {
         }[];
         id: string;
         project_id: string;
-        status: "running" | "completed" | "failed";
+        status: "completed" | "running" | "failed";
         label: string | null;
         started_at: string;
         completed_at: string | null;
-    }[] | undefined;
-    start(projectId: string, label?: string | null): {
+    }[] | undefined>;
+    start(projectId: string, label?: string | null): Promise<{
         id: string;
         project_id: string;
-        status: "running" | "completed" | "failed";
+        status: "completed" | "running" | "failed";
         label: string | null;
         started_at: string;
         completed_at: string | null;
-    } | undefined;
-    recordProgress(runId: string, message: string): {
+    } | undefined>;
+    recordProgress(runId: string, message: string): Promise<{
         id: string;
         run_id: string;
         message: string;
         created_at: string;
-    } | undefined;
-    complete(runId: string, status: "completed" | "failed"): {
+    } | undefined>;
+    complete(runId: string, status: "completed" | "failed"): Promise<{
         id: string;
         project_id: string;
-        status: "running" | "completed" | "failed";
+        status: "completed" | "running" | "failed";
         label: string | null;
         started_at: string;
         completed_at: string | null;
-    } | undefined;
+    } | undefined>;
 };
 export type AgentRunService = ReturnType<typeof createAgentRunService>;
 //# sourceMappingURL=agent-runs.d.ts.map

package/dist/services/agent-runs.js

@@ -1,5 +1,7 @@
 import { createAgentRun, createAgentRunEvent, getAgentRun, getProject, listAgentRunEvents, listAgentRuns, updateAgentRunStatus, } from '@plandesk/db';
 import { serializeAgentRun, serializeAgentRunEvent } from '../serialize.js';
+import { assertPermission, resolveOrgId } from './org-scope.js';
+import { assertProjectInOrg, ProjectNotInOrgError } from './scope.js';
 export class InvalidAgentRunError extends Error {
     constructor(message) {
         super(message);
@@ -8,84 +10,80 @@ export class InvalidAgentRunError extends Error {
 }
 const terminalStatuses = new Set(['completed', 'failed']);
 export function createAgentRunService(deps) {
-    const { db, eventBus } = deps;
+    const { db } = deps;
     return {
-        listForProject(projectId, pagination = {}) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async listForProject(projectId, pagination = {}) {
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
+            }
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
             }
-            const runs = listAgentRuns(db, projectId, pagination)
-                .slice()
-                .sort((a, b) => {
+            const runs = (await listAgentRuns(db, projectId, pagination)).slice().sort((a, b) => {
                 const timeDiff = b.startedAt.getTime() - a.startedAt.getTime();
                 if (timeDiff !== 0) {
                     return timeDiff;
                 }
                 return b.id.localeCompare(a.id);
             });
-            return runs.map((run) => {
+            return Promise.all(runs.map(async (run) => {
                 const serialized = serializeAgentRun(run);
-                const events = listAgentRunEvents(db, run.id).map((event) => {
-                    const serialized = serializeAgentRunEvent(event);
+                const events = (await listAgentRunEvents(db, run.id)).map((event) => {
+                    const serializedEvent = serializeAgentRunEvent(event);
                     return {
-                        id: serialized.id,
-                        message: serialized.message,
-                        created_at: serialized.created_at,
+                        id: serializedEvent.id,
+                        message: serializedEvent.message,
+                        created_at: serializedEvent.created_at,
                     };
                 });
                 return { ...serialized, events };
-            });
+            }));
         },
-        start(projectId, label) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async start(projectId, label) {
+            assertPermission(deps, 'agent_run', 'create');
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
             }
-            const run = createAgentRun(db, { projectId, label });
-            eventBus.emit({
-                type: 'agent_run_started',
-                runId: run.id,
-                projectId,
-            });
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
+            }
+            const run = await createAgentRun(db, { projectId, label });
             return serializeAgentRun(run);
         },
-        recordProgress(runId, message) {
-            const run = getAgentRun(db, runId);
+        async recordProgress(runId, message) {
+            assertPermission(deps, 'agent_run', 'update');
+            const run = await getAgentRun(db, runId);
             if (!run) {
                 return undefined;
             }
             if (terminalStatuses.has(run.status)) {
                 throw new InvalidAgentRunError('Agent run is already complete');
             }
-            const event = createAgentRunEvent(db, { runId, message });
-            eventBus.emit({
-                type: 'agent_run_progress',
-                runId,
-                projectId: run.projectId,
-            });
+            const event = await createAgentRunEvent(db, { runId, message });
             return serializeAgentRunEvent(event);
         },
-        complete(runId, status) {
-            const run = getAgentRun(db, runId);
+        async complete(runId, status) {
+            assertPermission(deps, 'agent_run', 'update');
+            const run = await getAgentRun(db, runId);
             if (!run) {
                 return undefined;
             }
             if (terminalStatuses.has(run.status)) {
                 throw new InvalidAgentRunError('Agent run is already complete');
             }
-            const updated = updateAgentRunStatus(db, runId, {
+            const updated = await updateAgentRunStatus(db, runId, {
                 status,
                 completedAt: new Date(),
             });
             if (!updated) {
                 return undefined;
             }
-            eventBus.emit({
-                type: 'agent_run_completed',
-                runId,
-                projectId: run.projectId,
-            });
             return serializeAgentRun(updated);
         },
     };

package/dist/services/artifacts.d.ts

@@ -1,9 +1,8 @@
 import { type ArtifactKind, type Db } from '@plandesk/db';
 import { type SerializedArtifact, type SerializedArtifactSummary } from '../serialize.js';
-import type { EventBus } from '../events.js';
-export type ArtifactServiceDeps = {
+import { type OrgScopedDeps } from './org-scope.js';
+export type ArtifactServiceDeps = OrgScopedDeps & {
     db: Db;
-    eventBus: EventBus;
 };
 export type CreateArtifactInput = {
     title: string;
@@ -19,10 +18,10 @@ export declare class InvalidArtifactError extends Error {
     constructor(message: string);
 }
 export declare function createArtifactService(deps: ArtifactServiceDeps): {
-    listByProject(projectId: string): SerializedArtifactSummary[] | undefined;
-    create(projectId: string, input: CreateArtifactInput): SerializedArtifact | undefined;
-    get(id: string): SerializedArtifact | undefined;
-    update(id: string, input: UpdateArtifactInput): SerializedArtifact | undefined;
+    listByProject(projectId: string): Promise<SerializedArtifactSummary[] | undefined>;
+    create(projectId: string, input: CreateArtifactInput): Promise<SerializedArtifact | undefined>;
+    get(id: string): Promise<SerializedArtifact | undefined>;
+    update(id: string, input: UpdateArtifactInput): Promise<SerializedArtifact | undefined>;
 };
 export type ArtifactService = ReturnType<typeof createArtifactService>;
 //# sourceMappingURL=artifacts.d.ts.map