@xopcai/xopc 0.0.254 → 0.0.256

package/dist/src/gateway/hono/routes/user-model.js

@@ -2,7 +2,9 @@ import { createCollaborationRule, getCollaborationRule, listCollaborationRules,
 import { getKnowledgeItem, listKnowledgeItems, searchKnowledgeItems, setKnowledgeStatus } from "../../../knowledge-memory/repository.js";
 import "../../../knowledge-memory/index.js";
 import { createPriorityWindow, createUserGoal, listPriorityWindows, listUserGoals, setUserGoalStatus } from "../../../user-model/goals.js";
-import { getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, listUserAssertions, reconcileAssertion, setAssertionStatus } from "../../../user-model/repository.js";
+import { getAssertionSlot, getUserAssertion, listUserAssertions, reconcileAssertion, setAssertionStatus } from "../../../user-model/repository.js";
+import { applyUserProfilePatch, getUserProfileSnapshot } from "../../../user-model/profile.js";
+import { bootstrapUserModel } from "../../../user-model/bootstrap.js";
 import "../../../user-model/index.js";
 import { listMemoryMaintenanceRuns } from "../../../memory-maintenance/service.js";
 import "../../../memory-maintenance/index.js";
@@ -86,65 +88,6 @@ const RULE_STATUSES = new Set([
 	"disabled",
 	"archived"
 ]);
-function profileAssertion(predicate) {
-	return getActiveAssertionForSlot({
-		subject: {
-			type: "user",
-			id: "self"
-		},
-		predicate,
-		scope: { type: "global" }
-	});
-}
-function profileValue(predicate) {
-	return profileAssertion(predicate)?.value;
-}
-function profileSnapshot() {
-	return {
-		callName: profileValue("identity.call_name"),
-		pronouns: profileValue("identity.pronouns"),
-		timezone: profileValue("preference.timezone"),
-		locale: profileValue("preference.locale"),
-		role: profileValue("identity.role")
-	};
-}
-const PROFILE_FIELDS = {
-	callName: {
-		predicate: "identity.call_name",
-		kind: "identity",
-		volatility: "stable",
-		importance: .95,
-		statement: (value) => `The user prefers to be called ${value}.`
-	},
-	role: {
-		predicate: "identity.role",
-		kind: "identity",
-		volatility: "slow",
-		importance: .9,
-		statement: (value) => `The user's role is ${value}.`
-	},
-	pronouns: {
-		predicate: "identity.pronouns",
-		kind: "identity",
-		volatility: "stable",
-		importance: .75,
-		statement: (value) => `The user's pronouns are ${value}.`
-	},
-	timezone: {
-		predicate: "preference.timezone",
-		kind: "preference",
-		volatility: "slow",
-		importance: .85,
-		statement: (value) => `The user's timezone is ${value}.`
-	},
-	locale: {
-		predicate: "preference.locale",
-		kind: "preference",
-		volatility: "slow",
-		importance: .85,
-		statement: (value) => `The user's language and locale are ${value}.`
-	}
-};
 function assertionView(assertion) {
 	const slot = getAssertionSlot(assertion.slotId);
 	if (!slot) throw new Error(`Assertion slot not found: ${assertion.slotId}`);
@@ -181,7 +124,7 @@ function registerUserModelRoutes(authenticated, deps) {
 			rules: listCollaborationRules(),
 			knowledge,
 			maintenance: { lastRun: listMemoryMaintenanceRuns(1)[0] ?? null },
-			profile: profileSnapshot(),
+			profile: getUserProfileSnapshot(),
 			counts: {
 				activeAssertions: assertions.filter((item) => item.status === "active").length,
 				reviewAssertions: assertions.filter((item) => item.status === "needs_review" || item.status === "conflicted").length,
@@ -194,48 +137,38 @@ function registerUserModelRoutes(authenticated, deps) {
 	authenticated.patch("/api/user-model/profile", write, async (c) => {
 		const input = await body(c);
 		if (!input) return c.json({ error: "A profile patch is required" }, 400);
-		const entries = Object.entries(PROFILE_FIELDS).filter(([key]) => Object.hasOwn(input, key));
-		if (!entries.length || entries.some(([key]) => typeof input[key] !== "string")) return c.json({ error: "Profile fields must be strings" }, 400);
+		const entries = [
+			"callName",
+			"role",
+			"pronouns",
+			"timezone",
+			"locale"
+		].filter((key) => Object.hasOwn(input, key));
+		if (!entries.length || entries.some((key) => typeof input[key] !== "string")) return c.json({ error: "Profile fields must be strings" }, 400);
 		try {
-			const now = Date.now();
-			for (const [key, field] of entries) {
-				const value = input[key].trim();
-				const current = profileAssertion(field.predicate);
-				if (!value) {
-					if (current) setAssertionStatus(current.id, "archived", {
-						actor: "user",
-						reason: "Profile field cleared by user.",
-						now
-					});
-					continue;
-				}
-				reconcileAssertion({
-					subject: {
-						type: "user",
-						id: "self"
-					},
-					predicate: field.predicate,
-					cardinality: "single",
-					scope: { type: "global" },
-					kind: field.kind,
-					value,
-					normalizedValue: value.toLocaleLowerCase(),
-					statement: field.statement(value),
-					authority: "user_explicit",
-					confidence: 1,
-					declaredImportance: field.importance,
-					inferredImportance: field.importance,
-					consequence: "medium",
-					actionability: .9,
-					volatility: field.volatility,
-					sensitivity: "normal",
-					disclosurePolicy: "referenceable",
-					observedAt: now,
-					createdBy: "user",
-					...current ? { correctionOfAssertionId: current.id } : {}
-				});
-			}
-			return c.json({ profile: profileSnapshot() });
+			return c.json({ profile: applyUserProfilePatch(Object.fromEntries(entries.map((key) => [key, input[key]]))) });
+		} catch (error) {
+			return c.json({ error: errorMessage(error) }, 400);
+		}
+	});
+	authenticated.post("/api/user-model/bootstrap", write, async (c) => {
+		const input = await body(c);
+		const profile = object(input?.profile);
+		const listFields = [
+			"responsibilities",
+			"goals",
+			"communicationPreferences",
+			"boundaries",
+			"relationships"
+		];
+		const validProfile = profile && Object.values(profile).every((value) => typeof value === "string");
+		const validLists = listFields.every((key) => input?.[key] === void 0 || Array.isArray(input[key]) && input[key].every((value) => typeof value === "string"));
+		if (!input || !validProfile || !validLists) return c.json({ error: "profile and string-list user-model fields are required" }, 400);
+		try {
+			return c.json(bootstrapUserModel({
+				profile,
+				...Object.fromEntries(listFields.flatMap((key) => input[key] === void 0 ? [] : [[key, input[key]]]))
+			}), 201);
 		} catch (error) {
 			return c.json({ error: errorMessage(error) }, 400);
 		}

package/dist/src/gateway/hono/routes/workflows.js

@@ -1,9 +1,9 @@
 import { init_agent_scope, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
 import { resolveProjectAgentId } from "../../../projects/project-agent.js";
 import "../../../projects/index.js";
+import { messagesToClientHistory } from "../../../session/client-history.js";
 import { validateWorkflowDefinitionInput } from "../../../workflows/domain/validation.js";
 import { WorkflowNameConflictError, WorkflowRevisionConflictError, createWorkflowCatalog } from "../../../agent/workflow/catalog.js";
-import { messagesToClientHistory } from "../../../session/client-history.js";
 import "../../../workflows/domain/index.js";
 import { resolveWorkflowRunArtifactsDir } from "../../../workflows/store/paths.js";
 import { WorkflowDraftService } from "../../../workflows/draft/workflow-draft-service.js";
@@ -103,7 +103,8 @@ function registerWorkflowRoutes(authenticated, deps) {
 		const body = await readJsonBody(c.req.raw);
 		const result = validateWorkflowDefinitionInput({
 			name: body.name,
-			graph: body.graph
+			graph: body.graph,
+			manifest: body.manifest
 		});
 		return c.json(result);
 	});
@@ -132,7 +133,8 @@ function registerWorkflowRoutes(authenticated, deps) {
 		if (body.expectedRevision !== 0) return c.json({ error: "expectedRevision must be 0 when creating a workflow" }, 400);
 		const validation = validateWorkflowDefinitionInput({
 			name: body.name,
-			graph: body.graph
+			graph: body.graph,
+			manifest: body.manifest
 		});
 		if (!validation.valid) return c.json({
 			error: validation.errors[0]?.message ?? "Invalid workflow definition",
@@ -171,7 +173,8 @@ function registerWorkflowRoutes(authenticated, deps) {
 		if (!Number.isSafeInteger(body.expectedRevision) || body.expectedRevision < 1) return c.json({ error: "expectedRevision is required" }, 400);
 		const validation = validateWorkflowDefinitionInput({
 			name: id,
-			graph: body.graph
+			graph: body.graph,
+			manifest: body.manifest
 		});
 		if (!validation.valid) return c.json({
 			error: validation.errors[0]?.message ?? "Invalid workflow definition",

package/dist/src/gateway/service/sessions-api.js

@@ -1,9 +1,9 @@
 import { init_agent_session_key, resolveAgentIdFromSessionKey } from "../../routing/agent-session-key.js";
 import { buildSessionKey, init_session_key } from "../../routing/session-key.js";
 import { retireSessionMcpRuntimeForSessionKey } from "../../agent/mcp/bundle-mcp-runtime.js";
-import "../../agent/mcp/bundle-mcp-tools.js";
 import { buildSessionTimeline } from "../../session/transcript-outline.js";
 import { transcriptRowsToClientHistory } from "../../session/client-history.js";
+import "../../agent/mcp/bundle-mcp-tools.js";
 import { collectMediaUrisFromValues, deleteMediaUris } from "../../media/session-references.js";
 import { withModelConfigLock } from "../../session/model-config-lock.js";
 import { getDistinctSessionChatIds } from "./session-chat-ids.js";

package/dist/src/gateway/service.js

@@ -54,12 +54,6 @@ import { registerClarificationChannelRuntime } from "./clarify-runtime.js";
 import { ChannelManager } from "../channels/manager.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
-import { DiscussionService } from "../discussions/service.js";
-import { DiscussionOrganizer } from "../discussions/organizer.js";
-import { DiscussionLiveWorker } from "../discussions/live-worker.js";
-import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
-import { DiscussionSealer } from "../discussions/sealer.js";
-import "../discussions/index.js";
 import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
@@ -67,6 +61,12 @@ import { ConnectionRecoveryService } from "../connectors/connection-recovery-ser
 import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
 import { ConnectedSourceChangePublisher } from "../connectors/source-change-publisher.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.js";
+import { DiscussionService } from "../discussions/service.js";
+import { DiscussionOrganizer } from "../discussions/organizer.js";
+import { DiscussionLiveWorker } from "../discussions/live-worker.js";
+import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
+import { DiscussionSealer } from "../discussions/sealer.js";
+import "../discussions/index.js";
 import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";

package/dist/src/remote-access/exposure-manager.js

@@ -2,9 +2,9 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { isTailscaleInstalled } from "../infra/tailscale.js";
 import { resolveGatewayBindMode } from "../config/gateway-bind.js";
+import { getTunnelService } from "../tunnel/tunnel-service.js";
 import { collectExposureConflicts } from "./exposure-guards.js";
 import { getTailscaleExposureState, maybeStartTailscaleFromConfig, stopTailscaleExposure } from "../gateway/tailscale-lifecycle.js";
-import { getTunnelService } from "../tunnel/tunnel-service.js";
 import { getTunnelConsentState } from "../tunnel/consent.js";
 import { maybeAutoStartTunnelFromConfig } from "../tunnel/gateway-lifecycle.js";
 //#region src/remote-access/exposure-manager.ts

package/dist/src/session/index.js

@@ -1,9 +1,9 @@
 import { buildSessionContextForLlm, isTranscriptContextEntry, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray } from "./session-context-for-llm.js";
 import { SessionStatus } from "./types.js";
 import { effectiveWorkspacePathForSession, normalizeWorkingDirectoryInput, projectWorkspacePath } from "./session-workspace.js";
+import { flattenMessageContent, messagesToClientHistory } from "./client-history.js";
 import { emitSessionTranscriptUpdate, onSessionTranscriptUpdate } from "./transcript-events.js";
 import { fallbackTitleFromMessages, generateSessionTitleFromMessages, getSessionTitleSource, isWebchatSessionKey, maybeRefineSessionTitleWithLlm, maybeSetProvisionalSessionTitle, provisionalTitleFromUserText, sanitizeGeneratedSessionTitle, sanitizeSessionTitle, shouldAutoTitleSessionKey, shouldRefineSessionTitleWithLlm } from "./session-title.js";
-import { flattenMessageContent, messagesToClientHistory } from "./client-history.js";
 import { SessionStore } from "./store.js";
 import { applySessionPatchToMetadata } from "./patch-metadata.js";
 import { SessionIndex } from "./manager.js";

package/dist/src/session/store.js

@@ -12,6 +12,7 @@ import { appendCompactionBoundaryIfUnchanged, appendTranscriptEntry, listCompact
 import { getSessionConfig, setSessionConfig } from "../storage/sqlite/config-repository.js";
 import "../storage/sqlite/index.js";
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
+import { transcriptRowsToClientHistory } from "./client-history.js";
 import { SessionCompactor } from "../agent/memory/compaction.js";
 import { resolveUserContextSessionAccess } from "../user-context/access-policy.js";
 import { readPostCompactionContext } from "../agent/reply/post-compaction-context.js";
@@ -19,7 +20,6 @@ import { resolveCompactionPolicy } from "../agent/memory/compaction-policy.js";
 import { promoteCompactionLedger } from "../agent/memory/compaction-promotion.js";
 import { SlidingWindow } from "../agent/memory/window.js";
 import { isAppendOnlyLlmTranscriptMessage } from "./transcript-stats.js";
-import { transcriptRowsToClientHistory } from "./client-history.js";
 import { backfillStructuredTurnOutcomes } from "./turn-outcome-projector.js";
 import { computeTranscriptUserRoundDeleteRange } from "./user-round-delete.js";
 //#region src/session/store.ts

package/dist/src/share/hosted-note-publication.d.ts

@@ -0,0 +1,22 @@
+import type { HostedPublicationSnapshot } from './hosted-session-share.js';
+import { type NoteShareSource } from './note-share-service.js';
+export interface HostedNotePublicationSnapshot extends HostedPublicationSnapshot {
+    kind: 'note_document';
+    sourceNoteId: string;
+    sourceVersion: number;
+    title: string;
+    attachmentCount: number;
+}
+export declare class HostedNotePublicationBuilder {
+    private readonly notes;
+    constructor(notes: NoteShareSource);
+    build(noteId: string, input: {
+        expectedNoteVersion?: number;
+        attachmentIds?: string[];
+        description?: string;
+    }): Promise<HostedNotePublicationSnapshot>;
+}
+export declare class HostedNoteVersionConflictError extends Error {
+    readonly currentVersion: number;
+    constructor(currentVersion: number);
+}

package/dist/src/share/hosted-note-publication.js

@@ -0,0 +1,96 @@
+import { collectReferencedAttachmentIds } from "../notes/note-attachment-sync.js";
+import { projectPublicNoteMarkdown } from "./note-share-service.js";
+import { createReadStream } from "node:fs";
+import { createHash } from "node:crypto";
+import { stat } from "node:fs/promises";
+//#region src/share/hosted-note-publication.ts
+const MAX_ATTACHMENTS = 20;
+const MAX_ATTACHMENT_BYTES = 32 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 100 * 1024 * 1024;
+const MAX_MARKDOWN_BYTES = 5 * 1024 * 1024;
+var HostedNotePublicationBuilder = class {
+	constructor(notes) {
+		this.notes = notes;
+	}
+	async build(noteId, input) {
+		const note = await this.notes.getNote(noteId);
+		if (!note) throw new Error("Note not found");
+		if (input.expectedNoteVersion !== void 0 && note.updatedAt !== input.expectedNoteVersion) throw new HostedNoteVersionConflictError(note.updatedAt);
+		const referenced = collectReferencedAttachmentIds(note);
+		const attachments = new Map((note.attachments ?? []).map((attachment) => [attachment.id, attachment]));
+		for (const id of referenced) if (!attachments.has(id)) throw new Error(`Referenced attachment is missing: ${id}`);
+		const selected = input.attachmentIds === void 0 ? [...referenced] : [...new Set(input.attachmentIds)];
+		if (selected.length > MAX_ATTACHMENTS) throw new Error("Note has too many attachments to publish");
+		for (const id of selected) if (!referenced.has(id)) throw new Error(`Attachment is not referenced by this Note: ${id}`);
+		const selectedSet = new Set(selected);
+		const markdown = rewritePublicationAssets(projectPublicNoteMarkdown(note, selectedSet), note, selectedSet);
+		if (Buffer.byteLength(markdown, "utf8") > MAX_MARKDOWN_BYTES) throw new Error("Note Markdown exceeds publishing limit");
+		const assets = [];
+		const manifestAttachments = [];
+		let totalBytes = Buffer.byteLength(markdown, "utf8");
+		for (const id of selected) {
+			const attachment = attachments.get(id);
+			if (attachment.size > MAX_ATTACHMENT_BYTES) throw new Error(`Attachment exceeds publishing limit: ${attachment.fileName}`);
+			totalBytes += attachment.size;
+			if (totalBytes > MAX_TOTAL_BYTES) throw new Error("Note publication exceeds total size limit");
+			const resolved = await this.notes.getAttachmentPath(note.id, id);
+			if (!resolved) throw new Error(`Attachment is missing: ${attachment.fileName}`);
+			const current = await stat(resolved.filePath);
+			if (!current.isFile() || current.size !== attachment.size) throw new Error(`Attachment changed or is missing: ${attachment.fileName}`);
+			assets.push({
+				id,
+				path: resolved.filePath,
+				size: attachment.size
+			});
+			manifestAttachments.push({
+				id,
+				fileName: attachment.fileName,
+				mimeType: attachment.mimeType,
+				size: attachment.size,
+				sha256: await sha256File(resolved.filePath)
+			});
+		}
+		return {
+			kind: "note_document",
+			sourceNoteId: note.id,
+			sourceVersion: note.updatedAt,
+			title: note.title?.trim() || "Untitled Note",
+			attachmentCount: assets.length,
+			assets,
+			manifest: {
+				schemaVersion: 1,
+				kind: "note_document",
+				title: note.title?.trim() || "Untitled Note",
+				snapshotAt: (/* @__PURE__ */ new Date()).toISOString(),
+				...input.description?.trim() ? { description: input.description.trim() } : {},
+				markdown,
+				attachments: manifestAttachments
+			}
+		};
+	}
+};
+var HostedNoteVersionConflictError = class extends Error {
+	constructor(currentVersion) {
+		super("Note changed after the publication preview was reviewed");
+		this.currentVersion = currentVersion;
+		this.name = "HostedNoteVersionConflictError";
+	}
+};
+function rewritePublicationAssets(markdown, note, selected) {
+	return markdown.replace(/xopc-attachment:\/\/notes\/([^/\s)]+)\/([^\s)]+)/gi, (match, rawNoteId, rawAttachmentId) => {
+		try {
+			const noteId = decodeURIComponent(rawNoteId);
+			const attachmentId = decodeURIComponent(rawAttachmentId);
+			return noteId === note.id && selected.has(attachmentId) ? `xopc-publication-asset://${attachmentId}` : match;
+		} catch {
+			return match;
+		}
+	});
+}
+async function sha256File(filePath) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(filePath)) hash.update(chunk);
+	return hash.digest("hex");
+}
+//#endregion
+export { HostedNotePublicationBuilder, HostedNoteVersionConflictError };

package/dist/src/share/hosted-session-share.d.ts

@@ -3,6 +3,7 @@ import { type SessionShareMessage, type SessionShareToolActivity } from './sessi
 import { type SessionShareSource } from './session-share-service.js';
 export interface HostedSessionShareManifest {
     schemaVersion: 1;
+    kind: 'session_document';
     title: string;
     snapshotAt: string;
     description?: string;
@@ -49,7 +50,17 @@ export interface HostedShareResult {
     viewCount: number;
     snapshotRevision: number;
 }
-type OwnerShare = {
+export type HostedPublicationKind = 'session_document' | 'note_document' | 'static_site';
+export interface HostedPublicationSnapshot {
+    kind: HostedPublicationKind;
+    manifest: unknown;
+    assets: Array<{
+        id: string;
+        path: string;
+        size: number;
+    }>;
+}
+export type HostedPublicationSummary = {
     id: string;
     title: string;
     description: string | null;
@@ -60,8 +71,42 @@ type OwnerShare = {
     viewCount: number;
     createdAt: string;
     updatedAt: string;
+    kind: HostedPublicationKind;
+    deliveryMode: 'hosted_snapshot';
+    owner: {
+        type: 'user' | 'workspace';
+        id: string;
+    };
+    workspaceId: string;
+    createdByPrincipalId: string;
 };
-export declare class HostedSessionSharePublisher {
+type OwnerShare = HostedPublicationSummary;
+export interface HostedPublicationCapabilities {
+    protocolVersion: string;
+    kinds: string[];
+    deliveryModes: string[];
+    accessModes: string[];
+    upload: {
+        direct: boolean;
+        multipart: boolean;
+        resumable: boolean;
+        streaming: boolean;
+    };
+    security?: {
+        contentScanning: boolean;
+        quarantineBeforeActivation: boolean;
+    };
+    lifecycle: {
+        revisions: boolean;
+        revoke: boolean;
+        asynchronousDeletion: boolean;
+    };
+    publishing: {
+        allowed: boolean;
+        managedBy: 'platform_admin';
+    };
+}
+export declare class HostedPublicationPublisher {
     private readonly credentials;
     private readonly fetchImpl;
     private readonly baseUrl;
@@ -70,23 +115,54 @@ export declare class HostedSessionSharePublisher {
         ttlMs: number;
         maxViews: number | null;
     }): Promise<HostedShareResult>;
+    createPublication(snapshot: HostedPublicationSnapshot, lifecycle: {
+        ttlMs: number;
+        maxViews: number | null;
+    }): Promise<HostedShareResult>;
     refresh(shareId: string, expectedRevision: number, publicUrl: string, snapshot: HostedSessionShareSnapshot): Promise<HostedShareResult>;
-    list(): Promise<OwnerShare[]>;
+    refreshPublication(shareId: string, expectedRevision: number, publicUrl: string, snapshot: HostedPublicationSnapshot): Promise<HostedShareResult>;
+    listPublications(): Promise<HostedPublicationSummary[]>;
+    capabilities(): Promise<HostedPublicationCapabilities>;
     revoke(shareId: string): Promise<void>;
+    revokePublication(shareId: string): Promise<void>;
+    listRevisions(shareId: string): Promise<Array<{
+        revision: number;
+        createdAt: string;
+        current: boolean;
+    }>>;
+    rollbackPublication(shareId: string, expectedRevision: number, targetRevision: number): Promise<HostedPublicationSummary>;
     private uploadAssets;
     private request;
 }
 export declare class HostedShareAuthorizationError extends Error {
     constructor();
 }
+export declare class HostedShareRemoteError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+export type HostedPublicationSource = {
+    kind: 'session' | 'note' | 'static_site';
+    id: string;
+    version: string;
+};
 export interface HostedShareBinding extends HostedShareResult {
-    sessionId: string;
-    cutoffSeq: number;
+    kind: HostedPublicationKind;
+    source: HostedPublicationSource;
+    revisionSources: Record<string, HostedPublicationSource>;
+    workspaceContext?: {
+        workspaceRoot?: string;
+        sessionKey?: string;
+        agentId?: string;
+    };
+    sessionId?: string;
+    cutoffSeq?: number;
     title: string;
     description: string | null;
-    messageCount: number;
+    messageCount?: number;
     attachmentCount: number;
-    includeToolActivities: boolean;
+    includeToolActivities?: boolean;
     attachmentIds: string[];
     createdAt: string;
     updatedAt: string;
@@ -95,7 +171,10 @@ export interface HostedShareBinding extends HostedShareResult {
 export declare class HostedShareBindingStore {
     private readonly state;
     list(sessionId: string): Promise<HostedShareBinding[]>;
+    listBySource(kind: HostedPublicationSource['kind'], id: string): Promise<HostedShareBinding[]>;
+    listAll(): Promise<HostedShareBinding[]>;
     upsert(binding: HostedShareBinding): Promise<void>;
+    markRevoked(id: string): Promise<void>;
     reconcile(remote: OwnerShare[]): Promise<void>;
 }
 export {};