@holon-run/agentinbox 1.0.0-beta.0 → 1.0.0-beta.1

package/README.md

@@ -66,7 +66,7 @@ manually or relying on the agent runtime to expose its own notification API.
 
 ## v1.0.0 Beta Upgrade Notes
 
-`v1.0.0-beta.0` is the first release on the final v1 storage and API boundary.
+`v1.0.0-beta.0` was the first release on the final v1 storage and API boundary.
 
 - pre-v1 local databases are archived and replaced with a fresh v1 database
 - old local state is not imported into the new v1 database
@@ -171,6 +171,10 @@ agentinbox inbox read --agent-id <agent_id>
 agentinbox inbox ack --agent-id <agent_id> --through <last_entry_id>
 ```
 
+The HTTP `POST /subscriptions` endpoint always returns
+`{ "subscriptions": [...] }`, even when only one subscription is created. That
+keeps shortcut expansion consistent for external callers.
+
 When acking a reviewed batch, prefer `--through <last_entry_id>` over `--all`.
 That preserves the boundary of the items you actually inspected. Use
 `ack --all` only when you have intentionally verified that every current

package/dist/src/cli.js

@@ -19,8 +19,11 @@ const store_1 = require("./store");
 const terminal_1 = require("./terminal");
 const util_1 = require("./util");
 async function main() {
-    const args = process.argv.slice(2);
-    const normalized = normalizeHelpArgs(args);
+    const rawArgs = process.argv.slice(2);
+    const detectedArgs = normalizeHelpArgs(rawArgs);
+    const normalized = shouldTreatJsonFlagAsNoop(detectedArgs)
+        ? stripNoopJsonFlag(detectedArgs)
+        : detectedArgs;
     const command = normalized[0];
     if (!command || command === "help" || command === "--help" || command === "-h") {
         printHelp(normalized.slice(1));
@@ -445,7 +448,7 @@ async function main() {
             startOffset: parseOptionalNumber(takeFlagValue(normalized, "--start-offset")),
             startTime: takeFlagValue(normalized, "--start-time") ?? undefined,
         });
-        console.log((0, util_1.jsonResponse)(withCommandMetadata(response.data, selection)));
+        console.log((0, util_1.jsonResponse)(withCommandMetadata(normalizeSubscriptionAddOutput(response.data, Boolean(shortcutName)), selection)));
         return;
     }
     if (command === "subscription" && normalized[1] === "list") {
@@ -767,7 +770,7 @@ async function main() {
         printHelp([command]);
         return;
     }
-    throw new Error(`unknown command: ${args.join(" ")}`);
+    throw new Error(`unknown command: ${normalized.join(" ")}`);
 }
 async function runServe(args) {
     const port = parseOptionalNumber(takeFlagValue(args, "--port"));
@@ -1000,6 +1003,26 @@ function normalizeHelpArgs(args) {
     }
     return [args[1], "--help"];
 }
+function stripNoopJsonFlag(args) {
+    return args.filter((arg) => arg !== "--json");
+}
+function shouldTreatJsonFlagAsNoop(args) {
+    if (!args.includes("--json")) {
+        return false;
+    }
+    const command = args[0];
+    if (!command) {
+        return false;
+    }
+    if (args.includes("--help") || args.includes("-h")) {
+        return false;
+    }
+    return command !== "help" &&
+        command !== "version" &&
+        command !== "--version" &&
+        command !== "-v" &&
+        command !== "serve";
+}
 function hasHelpFlag(args) {
     return args.includes("--help") || args.includes("-h");
 }
@@ -1047,6 +1070,19 @@ function withCommandMetadata(data, selection) {
         ...(selection.warnings.length > 0 ? { warnings: selection.warnings } : {}),
     };
 }
+function normalizeSubscriptionAddOutput(data, shortcutUsed) {
+    if (shortcutUsed) {
+        return data;
+    }
+    const subscriptions = data.subscriptions;
+    if (Array.isArray(subscriptions) &&
+        subscriptions.length === 1 &&
+        subscriptions[0] &&
+        typeof subscriptions[0] === "object") {
+        return subscriptions[0];
+    }
+    return data;
+}
 function getRequiredTerminalContext() {
     try {
         return (0, terminal_1.detectTerminalContext)(process.env);

package/dist/src/http.js

@@ -29,6 +29,14 @@ const errorResponseSchema = {
         error: { type: "string" },
     },
 };
+const subscriptionCollectionSchema = {
+    type: "object",
+    required: ["subscriptions"],
+    additionalProperties: false,
+    properties: {
+        subscriptions: { type: "array", items: jsonObjectSchema },
+    },
+};
 const deliveryHandleSchema = {
     type: "object",
     additionalProperties: false,
@@ -1041,13 +1049,7 @@ function buildFastifyServer(service) {
                 },
             },
             response: {
-                200: {
-                    type: "object",
-                    required: ["subscriptions"],
-                    properties: {
-                        subscriptions: { type: "array", items: jsonObjectSchema },
-                    },
-                },
+                200: subscriptionCollectionSchema,
             },
         },
     }, async (request) => {
@@ -1087,13 +1089,13 @@ function buildFastifyServer(service) {
                 },
             },
             response: {
-                200: jsonObjectSchema,
+                200: subscriptionCollectionSchema,
                 400: errorResponseSchema,
             },
         },
     }, async (request) => {
         const body = request.body;
-        return service.registerSubscription({
+        const input = {
             agentId: String(body.agentId),
             sourceId: String(body.sourceId),
             shortcut: body.shortcut && typeof body.shortcut === "object"
@@ -1110,7 +1112,8 @@ function buildFastifyServer(service) {
             startPolicy: optionalString(body.startPolicy),
             startOffset: typeof body.startOffset === "number" ? body.startOffset : undefined,
             startTime: optionalString(body.startTime) ?? undefined,
-        });
+        };
+        return { subscriptions: await service.registerSubscriptions(input) };
     });
     app.get("/subscriptions/:subscriptionId", {
         schema: {

package/dist/src/service.js

@@ -707,26 +707,93 @@ class AgentInboxService {
         return result;
     }
     async registerSubscription(input) {
-        if (input.shortcut) {
-            const source = this.store.getSource(input.sourceId);
-            if (!source) {
-                throw new Error(`unknown source: ${input.sourceId}`);
+        const expanded = await this.expandShortcutRegistration(input);
+        if (!expanded) {
+            return this.registerSingleSubscription(input);
+        }
+        if (expanded.plan.members.length !== 1) {
+            throw new Error(`subscription shortcut ${input.shortcut?.name ?? "unknown"} for source ${input.sourceId} expands to ${expanded.plan.members.length} subscriptions; use registerSubscriptions() instead`);
+        }
+        const subscriptions = await this.registerExpandedShortcutSubscriptions(input, expanded.source, expanded.plan);
+        return subscriptions[0];
+    }
+    async registerSubscriptions(input) {
+        const expanded = await this.expandShortcutRegistration(input);
+        if (expanded) {
+            return this.registerExpandedShortcutSubscriptions(input, expanded.source, expanded.plan);
+        }
+        return [await this.registerSingleSubscription(input)];
+    }
+    async expandShortcutRegistration(input) {
+        if (!input.shortcut) {
+            return null;
+        }
+        const source = this.store.getSource(input.sourceId);
+        if (!source) {
+            throw new Error(`unknown source: ${input.sourceId}`);
+        }
+        if (hasSubscriptionFieldOverride(input)) {
+            throw new Error("subscription add shortcut does not allow filter, trackedResourceRef, or cleanupPolicy overrides");
+        }
+        const plan = await this.adapters.expandSubscriptionShortcut(source, input.shortcut);
+        if (!plan) {
+            throw new Error(`unknown subscription shortcut ${input.shortcut.name} for source ${input.sourceId}`);
+        }
+        return { source, plan };
+    }
+    async registerExpandedShortcutSubscriptions(input, source, plan) {
+        if (plan.members.length === 0) {
+            throw new Error(`subscription shortcut ${input.shortcut?.name ?? "unknown"} did not produce any subscriptions`);
+        }
+        const resolvedMembers = plan.members.map((member) => ({
+            source: this.resolveShortcutMemberSource(source, member),
+            member,
+        }));
+        const created = [];
+        try {
+            for (const { source: memberSource, member } of resolvedMembers) {
+                created.push(await this.registerSingleSubscription({
+                    ...input,
+                    sourceId: memberSource.sourceId,
+                    shortcut: undefined,
+                    filter: member.filter,
+                    trackedResourceRef: member.trackedResourceRef ?? null,
+                    cleanupPolicy: member.cleanupPolicy ?? null,
+                }));
             }
-            if (hasSubscriptionFieldOverride(input)) {
-                throw new Error("subscription add shortcut does not allow filter, trackedResourceRef, or cleanupPolicy overrides");
+        }
+        catch (error) {
+            await this.rollbackRegisteredSubscriptions(created);
+            throw error;
+        }
+        return created;
+    }
+    async rollbackRegisteredSubscriptions(subscriptions) {
+        for (const subscription of [...subscriptions].reverse()) {
+            try {
+                await this.removeSubscription(subscription.subscriptionId);
             }
-            const expanded = await this.adapters.expandSubscriptionShortcut(source, input.shortcut);
-            if (!expanded) {
-                throw new Error(`unknown subscription shortcut ${input.shortcut.name} for source ${input.sourceId}`);
+            catch (error) {
+                console.warn(`failed to roll back subscription ${subscription.subscriptionId}:`, error);
             }
-            return this.registerSubscription({
-                ...input,
-                shortcut: undefined,
-                filter: expanded.filter,
-                trackedResourceRef: expanded.trackedResourceRef ?? null,
-                cleanupPolicy: expanded.cleanupPolicy,
-            });
         }
+    }
+    resolveShortcutMemberSource(source, member) {
+        if (!member.streamKind || member.streamKind === source.streamKind) {
+            return source;
+        }
+        if (!source.hostId || !source.streamKey) {
+            throw new Error(`subscription shortcut ${source.sourceId} requires a host-scoped source to resolve ${member.streamKind}`);
+        }
+        const sibling = this.store.listSources().find((candidate) => candidate.hostId === source.hostId &&
+            candidate.streamKind === member.streamKind &&
+            candidate.streamKey === source.streamKey);
+        if (!sibling) {
+            throw new Error(`subscription shortcut ${source.sourceId} requires an existing sibling ${member.streamKind} stream under host ${source.hostId} with streamKey ${source.streamKey}`);
+        }
+        return sibling;
+    }
+    async registerSingleSubscription(input) {
         this.getAgent(input.agentId);
         const source = this.store.getSource(input.sourceId);
         if (!source) {
@@ -755,17 +822,25 @@ class AgentInboxService {
         };
         this.ensureInboxForAgent(subscription.agentId);
         this.store.insertSubscription(subscription);
-        const stream = await this.ensureStreamForSource(source);
-        await this.backend.ensureConsumer({
-            streamId: stream.streamId,
-            subscriptionId: subscription.subscriptionId,
-            consumerKey: `subscription:${subscription.subscriptionId}`,
-            startPolicy: subscription.startPolicy,
-            startOffset: subscription.startOffset ?? null,
-            startTime: subscription.startTime ?? null,
-        });
-        this.store.deleteSourceIdleState(source.sourceId);
-        return subscription;
+        try {
+            const stream = await this.ensureStreamForSource(source);
+            await this.backend.ensureConsumer({
+                streamId: stream.streamId,
+                subscriptionId: subscription.subscriptionId,
+                consumerKey: `subscription:${subscription.subscriptionId}`,
+                startPolicy: subscription.startPolicy,
+                startOffset: subscription.startOffset ?? null,
+                startTime: subscription.startTime ?? null,
+            });
+            this.store.deleteSourceIdleState(source.sourceId);
+            return subscription;
+        }
+        catch (error) {
+            this.store.deleteSubscription(subscription.subscriptionId);
+            this.clearSubscriptionRuntimeState(subscription);
+            this.refreshSourceIdleState(source.sourceId);
+            throw error;
+        }
     }
     async removeSubscription(subscriptionId) {
         const subscription = this.getSubscription(subscriptionId);
@@ -1322,7 +1397,7 @@ class AgentInboxService {
                 });
             }
             for (const signal of lifecycleSignals.values()) {
-                this.scheduleLifecycleRetirements(source, subscription, signal);
+                this.scheduleLifecycleRetirements(source, signal);
             }
             return {
                 subscriptionId: subscription.subscriptionId,
@@ -1483,31 +1558,33 @@ class AgentInboxService {
             signals.set(normalized.ref, normalized);
         }
     }
-    scheduleLifecycleRetirements(source, subscription, signal) {
+    scheduleLifecycleRetirements(source, signal) {
         if (!signal.terminal) {
             return;
         }
-        if (!subscription.trackedResourceRef || subscription.trackedResourceRef !== signal.ref) {
+        if (!source.hostId) {
             return;
         }
         const signalOccurredAt = signal.occurredAt ?? (0, util_1.nowIso)();
         const signalOccurredAtMs = Date.parse(signalOccurredAt);
-        const retireAt = lifecycleRetireAtForSignal(subscription.cleanupPolicy, signalOccurredAtMs);
-        if (!retireAt) {
-            return;
+        for (const subscription of this.store.listSubscriptionsForHostTrackedResourceRef(source.hostId, signal.ref)) {
+            const retireAt = lifecycleRetireAtForSignal(subscription.cleanupPolicy, signalOccurredAtMs);
+            if (!retireAt) {
+                continue;
+            }
+            const now = (0, util_1.nowIso)();
+            this.store.upsertSubscriptionLifecycleRetirement({
+                subscriptionId: subscription.subscriptionId,
+                hostId: source.hostId,
+                trackedResourceRef: signal.ref,
+                retireAt,
+                terminalState: signal.state ?? null,
+                terminalResult: signal.result ?? null,
+                terminalOccurredAt: signalOccurredAt,
+                createdAt: now,
+                updatedAt: now,
+            });
         }
-        const now = (0, util_1.nowIso)();
-        this.store.upsertSubscriptionLifecycleRetirement({
-            subscriptionId: subscription.subscriptionId,
-            sourceId: source.sourceId,
-            trackedResourceRef: signal.ref,
-            retireAt,
-            terminalState: signal.state ?? null,
-            terminalResult: signal.result ?? null,
-            terminalOccurredAt: signalOccurredAt,
-            createdAt: now,
-            updatedAt: now,
-        });
     }
     notifyInboxWatchers(agentId, items) {
         const watchers = this.inboxWatchers.get(agentId);

package/dist/src/sources/github.js

@@ -4,6 +4,7 @@ exports.GithubDeliveryAdapter = exports.GithubUxcClient = exports.DEFAULT_GITHUB
 exports.githubDeliveryOperationsForHandle = githubDeliveryOperationsForHandle;
 exports.invokeGithubDeliveryOperation = invokeGithubDeliveryOperation;
 exports.normalizeGithubRepoEvent = normalizeGithubRepoEvent;
+exports.canonicalGithubPullRequestRef = canonicalGithubPullRequestRef;
 exports.deriveGithubTrackedResource = deriveGithubTrackedResource;
 exports.githubSubscriptionShortcutSpec = githubSubscriptionShortcutSpec;
 exports.expandGithubSubscriptionShortcut = expandGithubSubscriptionShortcut;
@@ -282,7 +283,11 @@ function normalizeGithubRepoEvent(source, config, raw) {
         deliveryHandle,
     };
 }
-function deriveGithubTrackedResource(filter) {
+function canonicalGithubPullRequestRef(source, number) {
+    const config = parseGithubSourceConfig(source);
+    return `repo:${config.owner}/${config.repo}:pr:${number}`;
+}
+function deriveGithubTrackedResource(filter, source) {
     const metadata = asRecord(filter.metadata);
     const payload = asRecord(filter.payload);
     const number = asNumber(metadata.number) ?? asNumber(payload.number) ?? asNumber(payload.ref);
@@ -290,13 +295,16 @@ function deriveGithubTrackedResource(filter) {
     if (!number || isPullRequest !== true) {
         return null;
     }
-    return { ref: `pr:${number}` };
+    return { ref: canonicalGithubPullRequestRef(source, number) };
 }
 function githubSubscriptionShortcutSpec() {
     return [{
             name: "pr",
             description: "Follow one pull request and auto-retire when it closes.",
-            argsSchema: [{ name: "number", type: "number", required: true, description: "Pull request number." }],
+            argsSchema: [
+                { name: "number", type: "number", required: true, description: "Pull request number." },
+                { name: "withCi", type: "boolean", required: false, description: "Also create a sibling ci_runs subscription under the same host and stream key." },
+            ],
         }];
 }
 function expandGithubSubscriptionShortcut(input) {
@@ -307,18 +315,32 @@ function expandGithubSubscriptionShortcut(input) {
     if (!number || !Number.isInteger(number) || number <= 0) {
         throw new Error("subscription shortcut pr requires a positive integer number");
     }
+    const trackedResourceRef = canonicalGithubPullRequestRef(input.source, number);
+    const withCi = input.args?.withCi === true;
     return {
-        filter: {
-            metadata: {
-                number,
-                isPullRequest: true,
+        members: [
+            {
+                streamKind: "repo_events",
+                filter: {
+                    metadata: {
+                        number,
+                        isPullRequest: true,
+                    },
+                },
+                trackedResourceRef,
+                cleanupPolicy: { mode: "on_terminal" },
             },
-        },
-        trackedResourceRef: `pr:${number}`,
-        cleanupPolicy: { mode: "on_terminal" },
+            ...(withCi
+                ? [{
+                        streamKind: "ci_runs",
+                        trackedResourceRef,
+                        cleanupPolicy: { mode: "on_terminal" },
+                    }]
+                : []),
+        ],
     };
 }
-function projectGithubLifecycleSignal(rawPayload) {
+function projectGithubLifecycleSignal(rawPayload, source) {
     const eventType = asString(rawPayload.type);
     if (eventType !== "PullRequestEvent") {
         return null;
@@ -334,7 +356,7 @@ function projectGithubLifecycleSignal(rawPayload) {
     }
     const merged = action === "merged" || asBoolean(rawPayload.merged) === true || asBoolean(pullRequest.merged) === true;
     return {
-        ref: `pr:${number}`,
+        ref: canonicalGithubPullRequestRef(source, number),
         terminal: true,
         state: "closed",
         result: merged ? "merged" : "closed",

package/dist/src/sources/remote.js

@@ -185,11 +185,12 @@ class RemoteSourceRuntime {
         if (typeof module.expandSubscriptionShortcut !== "function") {
             return null;
         }
-        return module.expandSubscriptionShortcut({
+        const expanded = module.expandSubscriptionShortcut({
             name: input.name,
             args: input.args,
             source: moduleInputSource(source),
         });
+        return normalizeExpandedSubscriptionPlan(expanded);
     }
     async deriveInlinePreview(source, item) {
         if (!REMOTE_SOURCE_TYPES.has(source.sourceType)) {
@@ -368,6 +369,32 @@ class RemoteSourceRuntime {
     }
 }
 exports.RemoteSourceRuntime = RemoteSourceRuntime;
+function normalizeExpandedSubscriptionPlan(value) {
+    if (!value) {
+        return null;
+    }
+    if (isExpandedSubscriptionPlan(value)) {
+        return {
+            members: value.members.map((member) => ({
+                streamKind: typeof member.streamKind === "string" ? member.streamKind : null,
+                filter: member.filter,
+                trackedResourceRef: member.trackedResourceRef ?? null,
+                cleanupPolicy: member.cleanupPolicy ?? null,
+            })),
+        };
+    }
+    return {
+        members: [{
+                streamKind: null,
+                filter: value.filter,
+                trackedResourceRef: value.trackedResourceRef ?? null,
+                cleanupPolicy: value.cleanupPolicy ?? null,
+            }],
+    };
+}
+function isExpandedSubscriptionPlan(value) {
+    return "members" in value && Array.isArray(value.members);
+}
 function moduleInputSource(source) {
     if (source.sourceType !== "remote_source") {
         return source;

package/dist/src/sources/remote_modules.js

@@ -200,8 +200,8 @@ const GITHUB_REPO_MODULE = {
     expandSubscriptionShortcut(input) {
         return (0, github_1.expandGithubSubscriptionShortcut)(input);
     },
-    deriveTrackedResource(filter) {
-        return (0, github_1.deriveGithubTrackedResource)(filter);
+    deriveTrackedResource(filter, source) {
+        return (0, github_1.deriveGithubTrackedResource)(filter, source);
     },
     deriveNotificationGrouping(item) {
         const number = typeof item.metadata.number === "number" ? item.metadata.number : null;
@@ -251,8 +251,8 @@ const GITHUB_REPO_MODULE = {
         const count = items.length;
         return `${count} ${grouping.summaryHint}`;
     },
-    projectLifecycleSignal(rawPayload) {
-        return (0, github_1.projectGithubLifecycleSignal)(rawPayload);
+    projectLifecycleSignal(rawPayload, source) {
+        return (0, github_1.projectGithubLifecycleSignal)(rawPayload, source);
     },
     validateConfig(source) {
         (0, github_1.parseGithubSourceConfig)(source);

package/dist/src/store.js

@@ -595,6 +595,16 @@ class AgentInboxStore {
         const rows = this.getAll("select * from subscriptions where agent_id = ? order by created_at asc", [agentId]);
         return rows.map((row) => this.mapSubscription(row));
     }
+    listSubscriptionsForHostTrackedResourceRef(hostId, trackedResourceRef) {
+        const rows = this.getAll(`
+      select subscriptions.*
+      from subscriptions
+      inner join sources on sources.source_id = subscriptions.source_id
+      where sources.host_id = ? and subscriptions.tracked_resource_ref = ?
+      order by subscriptions.created_at asc
+    `, [hostId, trackedResourceRef]);
+        return rows.map((row) => this.mapSubscription(row));
+    }
     deleteSubscription(subscriptionId) {
         const subscription = this.getSubscription(subscriptionId);
         if (!subscription) {
@@ -628,10 +638,10 @@ class AgentInboxStore {
             : retirement;
         this.db.run(`
       insert into subscription_lifecycle_retirements (
-        subscription_id, source_id, tracked_resource_ref, retire_at, terminal_state, terminal_result, terminal_occurred_at, created_at, updated_at
+        subscription_id, host_id, tracked_resource_ref, retire_at, terminal_state, terminal_result, terminal_occurred_at, created_at, updated_at
       ) values (?, ?, ?, ?, ?, ?, ?, ?, ?)
       on conflict(subscription_id) do update set
-        source_id = excluded.source_id,
+        host_id = excluded.host_id,
         tracked_resource_ref = excluded.tracked_resource_ref,
         retire_at = excluded.retire_at,
         terminal_state = excluded.terminal_state,
@@ -641,7 +651,7 @@ class AgentInboxStore {
         updated_at = excluded.updated_at
     `, [
             next.subscriptionId,
-            next.sourceId,
+            next.hostId,
             next.trackedResourceRef,
             next.retireAt,
             next.terminalState ?? null,
@@ -1673,7 +1683,7 @@ class AgentInboxStore {
     mapSubscriptionLifecycleRetirement(row) {
         return {
             subscriptionId: String(row.subscription_id),
-            sourceId: String(row.source_id),
+            hostId: String(row.host_id),
             trackedResourceRef: String(row.tracked_resource_ref),
             retireAt: String(row.retire_at),
             terminalState: row.terminal_state ? String(row.terminal_state) : null,

package/drizzle/migrations/0002_host_scoped_lifecycle_retirements.sql

@@ -0,0 +1,42 @@
+pragma foreign_keys=off;
+
+create table if not exists subscription_lifecycle_retirements__new (
+  subscription_id text primary key,
+  host_id text not null,
+  tracked_resource_ref text not null,
+  retire_at text not null,
+  terminal_state text,
+  terminal_result text,
+  terminal_occurred_at text not null,
+  created_at text not null,
+  updated_at text not null
+);
+
+insert into subscription_lifecycle_retirements__new (
+  subscription_id,
+  host_id,
+  tracked_resource_ref,
+  retire_at,
+  terminal_state,
+  terminal_result,
+  terminal_occurred_at,
+  created_at,
+  updated_at
+)
+select
+  retirement.subscription_id,
+  coalesce(source.host_id, retirement.source_id),
+  retirement.tracked_resource_ref,
+  retirement.retire_at,
+  retirement.terminal_state,
+  retirement.terminal_result,
+  retirement.terminal_occurred_at,
+  retirement.created_at,
+  retirement.updated_at
+from subscription_lifecycle_retirements as retirement
+left join sources as source on source.source_id = retirement.source_id;
+
+drop table subscription_lifecycle_retirements;
+alter table subscription_lifecycle_retirements__new rename to subscription_lifecycle_retirements;
+
+pragma foreign_keys=on;

package/drizzle/migrations/0003_subscription_tracked_resource_indexes.sql

@@ -0,0 +1,5 @@
+create index if not exists idx_subscriptions_tracked_resource_ref
+  on subscriptions(tracked_resource_ref);
+
+create index if not exists idx_subscriptions_tracked_resource_source
+  on subscriptions(tracked_resource_ref, source_id);

package/drizzle/schema.ts

@@ -97,11 +97,14 @@ export const subscriptions = sqliteTable("subscriptions", {
   startOffset: integer("start_offset"),
   startTime: text("start_time"),
   createdAt: text("created_at").notNull(),
-});
+}, (table) => ({
+  trackedResourceRefIdx: index("idx_subscriptions_tracked_resource_ref").on(table.trackedResourceRef),
+  trackedResourceRefSourceIdx: index("idx_subscriptions_tracked_resource_source").on(table.trackedResourceRef, table.sourceId),
+}));
 
 export const subscriptionLifecycleRetirements = sqliteTable("subscription_lifecycle_retirements", {
   subscriptionId: text("subscription_id").primaryKey(),
-  sourceId: text("source_id").notNull(),
+  hostId: text("host_id").notNull(),
   trackedResourceRef: text("tracked_resource_ref").notNull(),
   retireAt: text("retire_at").notNull(),
   terminalState: text("terminal_state"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holon-run/agentinbox",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.1",
   "description": "Local event subscription and delivery service for agents.",
   "license": "Apache-2.0",
   "repository": {