@undefineds.co/linx 0.3.20 → 0.3.23

package/vendor/stores/dist/pod-collection.js

@@ -0,0 +1,194 @@
+import { createCollection } from '@tanstack/react-db';
+import { queryCollectionOptions } from '@tanstack/query-db-collection';
+import { asBaseRelativeResourceId, requireRowResourceId } from '../../agent-runtime/dist/pod-resource-identity.js';
+import { deleteExactRecord, updateExactRecord } from './exact-records.js';
+function isPodCollectionDebugEnabled() {
+    return typeof process !== 'undefined'
+        && (process.env.LINX_POD_COLLECTION_DEBUG === '1' || process.env.LINX_POD_COLLECTION_DEBUG === 'true');
+}
+function debugPodCollection(...args) {
+    if (isPodCollectionDebugEnabled())
+        console.log(...args);
+}
+/**
+ * Creates a TanStack DB Collection synchronized with a Solid Pod resource.
+ * Includes support for real-time subscriptions via db.subscribe().
+ */
+export function createPodCollection(options) {
+    const { resource, queryKey, queryClient, getDb, columns, orderBy, getKey: customGetKey, seed } = options;
+    const ensureId = (item, operation) => {
+        if (item.id) {
+            asBaseRelativeResourceId(item.id, 'Pod collection row.id');
+            return item;
+        }
+        if (operation === 'seed') {
+            const id = asBaseRelativeResourceId(crypto.randomUUID(), 'generated Pod collection row.id');
+            if (typeof item === 'object' && item) {
+                return Object.assign(item, { id });
+            }
+            return { ...item, id };
+        }
+        throw new Error('Cannot persist Pod collection item without row.id.');
+    };
+    // Default key extractor: id required after insert/read
+    const getKey = customGetKey ?? ((item) => {
+        return requireRowResourceId(item, 'collection item');
+    });
+    let didSeed = false;
+    const fetchRows = async () => {
+        const db = getDb();
+        if (!db)
+            return [];
+        const buildQuery = () => {
+            let query;
+            if (columns && columns.length > 0) {
+                const selectObj = {};
+                for (const col of columns) {
+                    selectObj[col] = resource[col];
+                }
+                query = db.select(selectObj).from(resource);
+            }
+            else {
+                query = db.select().from(resource);
+            }
+            if (orderBy?.column) {
+                query = query.orderBy(orderBy.column, orderBy.direction ?? 'asc');
+            }
+            return query;
+        };
+        let rows;
+        try {
+            rows = (await buildQuery().execute());
+        }
+        catch (error) {
+            if (isUnsupportedDocumentCollectionRead(error)) {
+                console.warn(`[PodCollection] ${queryKey.join('/')} fetch skipped: ${errorMessage(error)}`);
+                return [];
+            }
+            console.error(`[PodCollection] ${queryKey.join('/')} fetch failed:`, error);
+            throw error;
+        }
+        for (const row of rows) {
+            requireRowResourceId(row, 'Pod collection row');
+        }
+        if (!didSeed && rows.length === 0 && seed) {
+            const seedRows = typeof seed === 'function' ? seed() : seed;
+            if (seedRows.length > 0) {
+                const ensured = seedRows.map((row) => ensureId(row, 'seed'));
+                await db.insert(resource).values(ensured).execute();
+                didSeed = true;
+                rows = (await buildQuery().execute());
+            }
+            else {
+                didSeed = true;
+            }
+        }
+        return rows;
+    };
+    // 1. Create the base collection
+    const collection = createCollection(queryCollectionOptions({
+        queryKey,
+        queryClient,
+        // READ
+        queryFn: fetchRows,
+        // IDENTITY
+        getKey,
+        // CREATE
+        onInsert: async ({ transaction }) => {
+            const db = getDb();
+            if (!db)
+                throw new Error('Database not connected');
+            const { modified } = transaction.mutations[0];
+            const ensured = ensureId(modified, 'insert');
+            const payload = toPersistableInsert(ensured, resource);
+            await db.insert(resource).values(payload).execute();
+        },
+        // UPDATE
+        onUpdate: async ({ transaction }) => {
+            const db = getDb();
+            if (!db)
+                throw new Error('Database not connected');
+            const { original, modified } = transaction.mutations[0];
+            try {
+                await updateExactRecord(db, resource, (original ?? modified), modified);
+            }
+            catch (error) {
+                console.error(`[PodCollection] Update failed for ${queryKey.join('/')}:`, error);
+                throw error;
+            }
+        },
+        // DELETE
+        onDelete: async ({ transaction }) => {
+            const db = getDb();
+            if (!db)
+                throw new Error('Database not connected');
+            const { original } = transaction.mutations[0];
+            await deleteExactRecord(db, resource, original);
+        }
+    }));
+    // 2. Attach helpers
+    const fetch = async () => {
+        if (!collection.isReady()) {
+            await collection.preload();
+            return collection.toArray;
+        }
+        const refetch = collection.utils.refetch;
+        if (typeof refetch === 'function') {
+            await refetch();
+        }
+        return collection.toArray;
+    };
+    // Usage: useEffect(() => collection.subscribeToPod(db), [db])
+    const subscribeToPod = async (db) => {
+        if (typeof db.subscribe !== 'function') {
+            console.warn('[PodCollection] db.subscribe not available');
+            return () => { };
+        }
+        try {
+            const sub = await db.subscribe(resource, {
+                onCreate: async (activity) => {
+                    debugPodCollection(`[PodCollection] onCreate: ${activity.object}`);
+                    // 直接 invalidate，让 useQuery 重新获取完整列表
+                    queryClient.invalidateQueries({ queryKey });
+                },
+                onUpdate: async (activity) => {
+                    debugPodCollection(`[PodCollection] onUpdate: ${activity.object}`);
+                    queryClient.invalidateQueries({ queryKey });
+                },
+                onDelete: (activity) => {
+                    debugPodCollection(`[PodCollection] onDelete: ${activity.object}`);
+                    queryClient.invalidateQueries({ queryKey });
+                }
+            });
+            debugPodCollection(`[PodCollection] Subscribed to ${queryKey.join('/')}`);
+            return () => sub.unsubscribe();
+        }
+        catch (error) {
+            console.error(`[PodCollection] Subscription failed`, error);
+            return () => { };
+        }
+    };
+    // Extend the collection object with helper methods
+    const baseInsert = collection.insert.bind(collection);
+    const insert = (item) => baseInsert(ensureId(item, 'insert'));
+    return Object.assign(collection, { insert, subscribeToPod, fetch });
+}
+function isUnsupportedDocumentCollectionRead(error) {
+    return errorMessage(error).includes('Document-mode collection queries over plain LDP are not supported');
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function toPersistableInsert(item, resource) {
+    const buildId = resource?.buildId;
+    if (typeof buildId !== 'function' || !item.id || looksLikeBaseRelativeResourceId(item.id)) {
+        return item;
+    }
+    return {
+        ...item,
+        id: buildId.call(resource, { id: item.id }),
+    };
+}
+function looksLikeBaseRelativeResourceId(id) {
+    return id.includes('/') || id.includes('#') || id.endsWith('.ttl');
+}

package/vendor/stores/dist/pod-write-guard.d.ts

@@ -0,0 +1,5 @@
+import type { SolidDatabase } from '@undefineds.co/models';
+export declare function assertIriBelongsToCurrentPod(db: SolidDatabase, iri: string, operation: 'insert' | 'update' | 'delete'): void;
+export declare function assertCurrentPodBaseUrl(db: SolidDatabase, operation: 'insert' | 'update' | 'delete'): string;
+export declare function assertInsertValuesBelongToCurrentPod(db: SolidDatabase, values: unknown): void;
+export declare function assertUpdateValuesBelongToCurrentPod(db: SolidDatabase, values: unknown): void;

package/vendor/stores/dist/pod-write-guard.js

@@ -0,0 +1,133 @@
+import { resolveCurrentPodBaseUrl } from './current-pod-base.js';
+const ABSOLUTE_IRI = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+const SUBJECT_FIELDS = ['@id', 'subject', 'uri', 'source', 'id'];
+const STORAGE_RELATION_FIELDS = [
+    'approval',
+    'chat',
+    'entry',
+    'issue',
+    'issues',
+    'lastMessageId',
+    'messageResource',
+    'messageResources',
+    'object',
+    'parentIssue',
+    'replyTo',
+    'run',
+    'runStep',
+    'runSteps',
+    'runs',
+    'session',
+    'task',
+    'tasks',
+    'target',
+    'thread',
+    'workspace',
+];
+const STORAGE_RELATION_URI_FIELDS = [
+    'repoRootUri',
+    'rootUri',
+    'targetUri',
+];
+export function assertIriBelongsToCurrentPod(db, iri, operation) {
+    const currentPodBase = assertCurrentPodBaseUrl(db, operation);
+    const podPrefix = normalizePodPrefix(currentPodBase);
+    const target = normalizeAbsoluteIri(iri);
+    if (!target.startsWith(podPrefix)) {
+        throw new Error(`Refusing to ${operation} a Pod record outside the current SP: ${iri}`);
+    }
+}
+export function assertCurrentPodBaseUrl(db, operation) {
+    const currentPodBase = resolveCurrentPodBaseUrl(db);
+    if (!currentPodBase) {
+        throw new Error(`Cannot ${operation} Pod record without a current SP Pod URL.`);
+    }
+    return currentPodBase;
+}
+export function assertInsertValuesBelongToCurrentPod(db, values) {
+    assertCurrentPodBaseUrl(db, 'insert');
+    for (const iri of collectStorageSensitiveIris(values)) {
+        assertIriBelongsToCurrentPod(db, iri, 'insert');
+    }
+}
+export function assertUpdateValuesBelongToCurrentPod(db, values) {
+    assertCurrentPodBaseUrl(db, 'update');
+    for (const iri of collectStorageSensitiveIris(values)) {
+        assertIriBelongsToCurrentPod(db, iri, 'update');
+    }
+}
+function collectStorageSensitiveIris(values) {
+    const seen = new Set();
+    collectStorageSensitiveIrisInto(values, seen);
+    return [...seen];
+}
+function collectStorageSensitiveIrisInto(values, seen) {
+    if (Array.isArray(values)) {
+        for (const value of values) {
+            collectStorageSensitiveIrisInto(value, seen);
+        }
+        return;
+    }
+    if (!isSubjectCarrier(values)) {
+        return;
+    }
+    for (const [field, value] of Object.entries(values)) {
+        if (typeof value === 'string' && ABSOLUTE_IRI.test(value)) {
+            if (shouldGuardFieldIri(field) && isHttpIri(value)) {
+                seen.add(value);
+            }
+            continue;
+        }
+        if (Array.isArray(value) && shouldGuardFieldIri(field)) {
+            for (const item of value) {
+                if (typeof item === 'string' && ABSOLUTE_IRI.test(item) && isHttpIri(item)) {
+                    seen.add(item);
+                }
+            }
+            continue;
+        }
+        collectStorageSensitiveIrisInto(value, seen);
+    }
+}
+function isSubjectCarrier(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isSubjectField(field) {
+    return SUBJECT_FIELDS.includes(field);
+}
+function isStorageRelationField(field) {
+    return STORAGE_RELATION_FIELDS.includes(field);
+}
+function isStorageRelationUriField(field) {
+    if (STORAGE_RELATION_URI_FIELDS.includes(field)) {
+        return true;
+    }
+    if (!field.endsWith('Uri')) {
+        return false;
+    }
+    const baseName = field.slice(0, -3);
+    return isStorageRelationField(baseName);
+}
+function shouldGuardFieldIri(field) {
+    return isSubjectField(field) || isStorageRelationField(field) || isStorageRelationUriField(field);
+}
+function normalizePodPrefix(podBaseUrl) {
+    return `${podBaseUrl.trim().replace(/\/+$/, '')}/`;
+}
+function normalizeAbsoluteIri(iri) {
+    try {
+        return new URL(iri).href;
+    }
+    catch {
+        return iri;
+    }
+}
+function isHttpIri(iri) {
+    try {
+        const { protocol } = new URL(iri);
+        return protocol === 'http:' || protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}

package/vendor/stores/dist/symphony-control.d.ts

@@ -0,0 +1,245 @@
+import type { SymphonyIssueRecord, SymphonyRuntimeEventType, SymphonyRuntimeDeliveryResult, SymphonyRunPlan, SymphonySessionRecord, SymphonyWorkerPlan } from '@linx/agent-runtime/symphony';
+import { type AutoModeInteractionRequest, type AutoModeWorkerBackend } from '@linx/agent-runtime/auto-mode';
+import { type ApprovalInsert, type ChatInsert, type ContactInsert, type DeliveryInsert, type EvidenceInsert, type InboxNotificationInsert, type InputRequestInsert, type IssueInsert, type MessageInsert, type ReportInsert, type RunInsert, type RunStepInsert, type SessionInsert, type SolidDatabase, type TaskInsert, type ThreadInsert } from '@undefineds.co/models';
+import { type ExactRecordDatabase } from '@undefineds.co/drizzle-solid';
+export type SymphonyControlStage = 'planned' | 'running' | 'completed' | 'failed';
+export interface BuildSymphonyControlRowsInput {
+    plan: SymphonyRunPlan;
+    webId: string;
+    stage?: SymphonyControlStage;
+    stages?: SymphonyControlStage[];
+}
+export interface SymphonyControlRows {
+    contacts: ContactInsert[];
+    chats: ChatInsert[];
+    threads: ThreadInsert[];
+    messages: MessageInsert[];
+    issue: IssueInsert;
+    issues: IssueInsert[];
+    tasks: TaskInsert[];
+    deliveries: DeliveryInsert[];
+    sessions: SessionInsert[];
+    runs: RunInsert[];
+    runSteps: RunStepInsert[];
+    evidence: EvidenceInsert[];
+    reports: ReportInsert[];
+}
+export interface PersistSymphonyControlStateInput extends BuildSymphonyControlRowsInput {
+    db: SolidDatabase & ExactRecordDatabase;
+}
+export interface PersistSymphonyControlStateResult {
+    plan: SymphonyRunPlan;
+    rows: SymphonyControlRows;
+}
+export interface SymphonyRuntimeAdapterEvent {
+    stepType: SymphonyRuntimeEventType;
+    message?: string;
+    payload?: Record<string, unknown>;
+    now?: Date;
+    randomId?: string;
+}
+export interface SymphonyRuntimeAdapterResult {
+    status?: 'completed' | 'failed';
+    exitCode?: number;
+    autoModeSessionId?: string;
+    reportText?: string;
+    events?: SymphonyRuntimeAdapterEvent[];
+}
+export interface SymphonyRuntimeAdapter {
+    run(input: {
+        plan: SymphonyRunPlan;
+        worker: SymphonyWorkerPlan;
+        prompt: string;
+        signal?: AbortSignal;
+    }): Promise<SymphonyRuntimeAdapterResult>;
+}
+export interface RunAndPersistSymphonyWorkerGoalPlanInput {
+    db: SolidDatabase & ExactRecordDatabase;
+    webId: string;
+    plan: SymphonyRunPlan;
+    runtimeAdapter: SymphonyRuntimeAdapter;
+    now?: Date;
+    randomId?: string;
+    signal?: AbortSignal;
+}
+export interface RunAndPersistSymphonyWorkerGoalPlanResult {
+    plan: SymphonyRunPlan;
+    worker: SymphonyWorkerPlan;
+    status: 'completed' | 'failed';
+    exitCode: number;
+    autoModeSessionId?: string;
+}
+export interface ApplyAndPersistSymphonyWorkerRuntimeResultInput {
+    db: SolidDatabase & ExactRecordDatabase;
+    webId: string;
+    plan: SymphonyRunPlan;
+    worker?: Worker;
+    result: SymphonyRuntimeAdapterResult | SymphonyRuntimeDeliveryResult;
+    now?: Date;
+    randomId?: string;
+}
+export interface ApplyAndPersistSymphonyWorkerRuntimeResultResult {
+    plan: SymphonyRunPlan;
+    worker: SymphonyWorkerPlan;
+    status: 'completed' | 'failed';
+    exitCode: number;
+    autoModeSessionId?: string;
+}
+export interface PersistSymphonyWorkerDeliveryInput {
+    db: SolidDatabase & ExactRecordDatabase;
+    webId: string;
+    plan: SymphonyRunPlan;
+    worker?: Worker;
+    delivery: unknown;
+    now?: Date;
+    randomId?: string;
+}
+export type PersistSymphonyWorkerDeliveryResult = ApplyAndPersistSymphonyWorkerRuntimeResultResult;
+export interface BuildSymphonyInteractionRequestRowsInput {
+    plan: SymphonyRunPlan;
+    webId: string;
+    request: AutoModeInteractionRequest;
+    worker?: Worker;
+    now?: Date;
+    randomId?: string;
+    source?: 'codex-app-server' | 'codex-acp' | 'acp' | 'runtime' | (string & {});
+    policyVersion?: string;
+}
+export interface SymphonyInteractionRequestRows {
+    approval?: ApprovalInsert;
+    inputRequest?: InputRequestInsert;
+    inboxNotification: InboxNotificationInsert;
+    runStep: RunStepInsert;
+}
+export interface PersistSymphonyInteractionRequestInput extends BuildSymphonyInteractionRequestRowsInput {
+    db: SolidDatabase & ExactRecordDatabase;
+}
+export interface PersistSymphonyInteractionRequestResult {
+    plan: SymphonyRunPlan;
+    rows: SymphonyInteractionRequestRows;
+}
+export interface SymphonyControlWorkerStatus {
+    status: string;
+    backend: string;
+    mode: string;
+    cwd?: string;
+    autoModeSessionId?: string;
+    target?: {
+        label?: string;
+        agent?: string;
+        chat?: string;
+    };
+}
+export interface SymphonyControlReportStatus {
+    status: string;
+    backend: string;
+    agent?: string;
+    title?: string;
+    summary?: string;
+    task?: string;
+    delivery?: string;
+    reportDelivery?: string;
+    run?: string;
+    chat?: string;
+    thread?: string;
+    autoModeSessionId?: string;
+    error?: string;
+    completedAt?: string;
+    updatedAt?: string;
+}
+export declare const SYMPHONY_SECRETARY_AGENT_ID = "__secretary__";
+export declare const SYMPHONY_CHAT_ID = "symphony";
+export declare const SYMPHONY_POLICY_VERSION = "linx-symphony-session/v1";
+export declare const SYMPHONY_WORKER_POD_ACCESS_POLICY_VERSION = "linx-symphony-worker-pod-access/v1";
+export declare const SYMPHONY_ARCHIVE_PROVENANCE_VERSION = "linx-symphony-archive/v1";
+export declare const SYMPHONY_RUNTIME_REQUEST_POLICY_VERSION = "linx-symphony-runtime-request/v1";
+type Worker = SymphonyRunPlan['workers'][number];
+type SymphonyArchiveRefs = Partial<Record<'idea' | 'issue' | 'task' | 'delivery' | 'session', string>>;
+export declare function persistSymphonyControlState(input: PersistSymphonyControlStateInput): Promise<PersistSymphonyControlStateResult>;
+export declare function runAndPersistSymphonyWorkerGoalPlan(input: RunAndPersistSymphonyWorkerGoalPlanInput): Promise<RunAndPersistSymphonyWorkerGoalPlanResult>;
+export declare function persistSymphonyWorkerDelivery(input: PersistSymphonyWorkerDeliveryInput): Promise<PersistSymphonyWorkerDeliveryResult>;
+export declare function applyAndPersistSymphonyWorkerRuntimeResult(input: ApplyAndPersistSymphonyWorkerRuntimeResultInput): Promise<ApplyAndPersistSymphonyWorkerRuntimeResultResult>;
+export declare function persistSymphonyInteractionRequest(input: PersistSymphonyInteractionRequestInput): Promise<PersistSymphonyInteractionRequestResult>;
+export declare function listOpenSymphonyIssuesFromControlState(input: {
+    db: SolidDatabase;
+    webId: string;
+}): Promise<SymphonyIssueRecord[]>;
+export declare function listRunningSymphonyWorkersFromControlState(input: {
+    db: SolidDatabase;
+}): Promise<SymphonyControlWorkerStatus[]>;
+export declare function listRecentSymphonyReportsFromControlState(input: {
+    db: SolidDatabase;
+    limit?: number;
+}): Promise<SymphonyControlReportStatus[]>;
+export declare function buildSymphonyControlRows(input: BuildSymphonyControlRowsInput): SymphonyControlRows;
+export declare function buildSymphonyInteractionRequestRows(input: BuildSymphonyInteractionRequestRowsInput): SymphonyInteractionRequestRows;
+export declare function upsertSymphonyApprovalRequest(db: ExactRecordDatabase, row: ApprovalInsert): Promise<void>;
+export declare function upsertSymphonyInputRequest(db: ExactRecordDatabase, row: InputRequestInsert): Promise<void>;
+export declare function upsertSymphonyContact(db: ExactRecordDatabase, row: ContactInsert): Promise<void>;
+export declare function upsertSymphonyChat(db: ExactRecordDatabase, row: ChatInsert): Promise<void>;
+export declare function upsertSymphonyThread(db: ExactRecordDatabase, row: ThreadInsert): Promise<void>;
+export declare function upsertSymphonyReport(db: ExactRecordDatabase, row: ReportInsert): Promise<void>;
+export declare function upsertSymphonyIssue(db: ExactRecordDatabase, row: IssueInsert): Promise<void>;
+export declare function upsertSymphonyTask(db: ExactRecordDatabase, row: TaskInsert): Promise<void>;
+export declare function upsertSymphonyDelivery(db: ExactRecordDatabase, row: DeliveryInsert): Promise<void>;
+export declare function upsertSymphonySession(db: ExactRecordDatabase, row: SessionInsert): Promise<void>;
+export declare function upsertSymphonyRun(db: ExactRecordDatabase, row: RunInsert): Promise<void>;
+export declare function buildSymphonyIssueRow(plan: SymphonyRunPlan, webId: string, issue?: SymphonyIssueRecord): IssueInsert;
+export declare function buildSymphonyTaskRow(plan: SymphonyRunPlan, webId: string, worker: Worker): TaskInsert;
+export declare function buildSymphonyDeliveryRow(plan: SymphonyRunPlan, webId: string, worker: Worker): DeliveryInsert;
+export declare function buildSymphonySessionRow(plan: SymphonyRunPlan, webId: string, worker?: Worker): SessionInsert;
+export declare function buildSymphonyRunRow(plan: SymphonyRunPlan, webId: string, worker: Worker): RunInsert;
+export declare function buildSymphonyRunStepRow(plan: SymphonyRunPlan, webId: string, worker: Worker, stage: SymphonyControlStage): RunStepInsert;
+export declare function buildSymphonyRuntimeRunStepRow(plan: SymphonyRunPlan, webId: string, worker: Worker, step: NonNullable<Worker['runSteps']>[number]): RunStepInsert;
+export declare function buildSymphonyContactRows(plan: SymphonyRunPlan, webId: string): ContactInsert[];
+export declare function buildSymphonyChatRow(plan: SymphonyRunPlan, webId: string, stage: SymphonyControlStage): ChatInsert;
+export declare function buildSymphonyThreadRows(plan: SymphonyRunPlan, webId: string, stage: SymphonyControlStage): ThreadInsert[];
+export declare function buildSymphonyThreadRow(plan: SymphonyRunPlan, webId: string, stage: SymphonyControlStage, group?: SymphonyThreadProjectionGroup): ThreadInsert;
+export declare function buildSymphonyStatusMessageRow(plan: SymphonyRunPlan, webId: string, stage: SymphonyControlStage): MessageInsert;
+export declare function buildSymphonyEvidenceRows(plan: SymphonyRunPlan, webId: string, worker: Worker): EvidenceInsert[];
+export declare function buildSymphonyReportRows(plan: SymphonyRunPlan, webId: string, worker: Worker): ReportInsert[];
+export declare function buildSymphonyWorkerSummary(plan: SymphonyRunPlan, webId: string, worker: Worker): Record<string, unknown>;
+export declare function buildSymphonyReconcilerMetadata(worker: Worker): Record<string, unknown>;
+export declare function buildSymphonyWorkerPodAccessPolicy(plan: SymphonyRunPlan, webId: string, worker: Worker): Record<string, unknown>;
+export declare function buildSymphonySpaceContract(plan: SymphonyRunPlan, webId: string, worker: Worker): Record<string, unknown>;
+export declare function buildSymphonyWorkspaceMetadata(plan: SymphonyRunPlan, worker: Worker): Record<string, unknown>;
+export declare function buildSymphonyArchiveRefs(refs: SymphonyArchiveRefs): Record<string, string>;
+export declare function buildSymphonyArchiveMetadata(refs: SymphonyArchiveRefs): {
+    archive: Record<string, string>;
+};
+export declare function buildSymphonyIssueId(issue: SymphonyIssueRecord): string;
+export declare function buildSymphonyIssueIri(webId: string, issue: SymphonyIssueRecord | string): string;
+export declare function normalizeSymphonyIssueIri(webId: string, issue: string): string;
+export declare function buildSymphonyTaskKey(task: string): string;
+export declare function buildSymphonyTaskIri(webId: string, task: string): string;
+export declare function normalizeSymphonyTaskIri(webId: string, task: string): string;
+export declare function buildSymphonyDeliveryIri(webId: string, worker: Worker): string;
+export declare function buildSymphonyRunIri(webId: string, worker: Worker): string;
+export declare function buildSymphonyWorkerSessionIri(webId: string, worker: Worker): string;
+export declare function buildSymphonyControlSessionIri(webId: string, plan: SymphonyRunPlan): string;
+export declare function buildSymphonySessionRecordId(session: Pick<SymphonySessionRecord, 'uri'>): string;
+export declare function buildSymphonyThreadId(plan: Pick<SymphonyRunPlan, 'session'>): string;
+export declare function buildSymphonyChatUri(webId: string): string;
+export declare function buildTargetChatId(plan: SymphonyRunPlan, webId: string): string;
+export declare function buildSymphonyMessageIri(webId: string, plan: SymphonyRunPlan, row: Pick<MessageInsert, 'id' | 'createdAt'>): string;
+export declare function selectTargetChatIri(value: string | undefined, webId: string, plan?: SymphonyRunPlan): string;
+export declare function selectTargetThreadIri(value: string | undefined, webId: string, plan: SymphonyRunPlan): string;
+export declare function selectDefaultThreadIri(webId: string, plan: SymphonyRunPlan): string;
+export declare function readWorkerChatRef(worker: Worker): string | undefined;
+export declare function readWorkerThreadRef(worker: Worker): string | undefined;
+export declare function readWorkerMessages(worker: Worker): string[];
+export declare function selectWorkerChatIri(plan: SymphonyRunPlan, webId: string, worker: Worker): string;
+export declare function selectWorkerThreadIri(plan: SymphonyRunPlan, webId: string, worker: Worker): string;
+export declare function buildWorkerThreadId(plan: SymphonyRunPlan, webId: string, worker: Worker): string;
+interface SymphonyThreadProjectionGroup {
+    chat: string;
+    thread: string;
+    workers: Worker[];
+}
+export declare function buildWorkerAgentId(backend: AutoModeWorkerBackend, agent?: string): string;
+export declare function mapSymphonyTaskStatus(status: string): string;
+export declare function mapSymphonyRunStatus(status: string): string;
+export declare function mapSymphonyReportOutcome(worker: Worker, outcome?: string): string;
+export declare function inferSymphonyControlStage(plan: SymphonyRunPlan): SymphonyControlStage;
+export declare function buildStatusContent(plan: SymphonyRunPlan, stage: SymphonyControlStage): string;
+export {};