@undefineds.co/linx 0.3.18 → 0.3.20

package/vendor/agent-runtime/dist/coordination.js

@@ -0,0 +1,145 @@
+export const CLIENT_RECONCILER_LEASE_TTL_MS = 30_000;
+export const CLIENT_CAPABILITY_HEARTBEAT_TTL_MS = 45_000;
+const CLIENT_KIND_PRIORITY = {
+    cli: 40,
+    desktop: 30,
+    mobile: 20,
+    web: 10,
+};
+export function defaultReconcilerOwnerForPolicyKind(policyKind) {
+    return policyKind === 'open_group' ? 'server' : 'client';
+}
+export function resolveReconcilerOwnership(input = {}) {
+    const humanAuthorityCount = resolveHumanAuthorityCount(input);
+    const owner = input.reconcilerOwner === 'client' || input.reconcilerOwner === 'server'
+        ? input.reconcilerOwner
+        : humanAuthorityCount !== undefined && humanAuthorityCount > 1
+            ? 'server'
+            : defaultReconcilerOwnerForPolicyKind(input.policyKind);
+    return {
+        reconcilerOwner: owner,
+        ...(humanAuthorityCount !== undefined ? { humanAuthorityCount } : {}),
+    };
+}
+export function isSingleHumanAuthority(input) {
+    return resolveHumanAuthorityCount(input) === 1;
+}
+export function hasMultipleHumanAuthorities(input) {
+    const count = resolveHumanAuthorityCount(input);
+    return count !== undefined && count > 1;
+}
+export function defaultSharedWakeAgentJobDedupeKey(input) {
+    return [input.thread, input.triggerMessage, input.agent].join('|');
+}
+export function createSharedWakeAgentJob(input) {
+    const job = {
+        ...input,
+        id: input.id ?? sharedWakeAgentJobId(input),
+    };
+    return job;
+}
+export function sharedWakeAgentJobId(input) {
+    return `wake_${hashString(defaultSharedWakeAgentJobDedupeKey(input))}`;
+}
+export function isClientReconcilerLeaseActive(lease, now = Date.now()) {
+    if (!lease?.fencingToken || !lease.thread || !lease.ownerClientId || !lease.ownerUser || !lease.expiresAt) {
+        return false;
+    }
+    const expiresAt = Date.parse(lease.expiresAt);
+    const nowMs = toEpochMs(now);
+    return Number.isFinite(expiresAt) && Number.isFinite(nowMs) && expiresAt > nowMs;
+}
+export function canClientCoordinateThread(input) {
+    const clientId = normalizeText(input.clientId);
+    if (!clientId || !input.thread || !isClientReconcilerLeaseActive(input.lease, input.now)) {
+        return false;
+    }
+    return input.lease.thread === input.thread && input.lease.ownerClientId === clientId;
+}
+export function isClientCapabilityAlive(client, now = Date.now(), heartbeatTtlMs = CLIENT_CAPABILITY_HEARTBEAT_TTL_MS) {
+    const heartbeatAt = Date.parse(client.heartbeatAt);
+    const nowMs = toEpochMs(now);
+    return Number.isFinite(heartbeatAt) && Number.isFinite(nowMs) && nowMs - heartbeatAt <= heartbeatTtlMs;
+}
+export function selectClientReconciler(clients, options = {}) {
+    const now = options.now ?? Date.now();
+    const eligible = clients
+        .filter((client) => client.canCoordinateClientOwned)
+        .filter((client) => !options.ownerUser || client.user === options.ownerUser)
+        .filter((client) => isClientCapabilityAlive(client, now, options.heartbeatTtlMs))
+        .sort(compareClientCapabilityForCoordination);
+    return eligible[0] ?? null;
+}
+export function grantClientReconcilerLease(options) {
+    const now = options.now ?? Date.now();
+    const ttl = options.leaseTtlMs ?? CLIENT_RECONCILER_LEASE_TTL_MS;
+    const previousOwner = options.previousLease && isClientReconcilerLeaseActive(options.previousLease, now)
+        ? options.clients.find((client) => (client.clientId === options.previousLease?.ownerClientId
+            && client.user === options.ownerUser
+            && client.canCoordinateClientOwned
+            && isClientCapabilityAlive(client, now, options.heartbeatTtlMs)))
+        : undefined;
+    const selected = previousOwner ?? selectClientReconciler(options.clients, {
+        ownerUser: options.ownerUser,
+        now,
+        heartbeatTtlMs: options.heartbeatTtlMs,
+    });
+    if (!selected) {
+        return null;
+    }
+    const nowMs = toEpochMs(now);
+    const expiresAt = new Date(nowMs + ttl).toISOString();
+    return {
+        thread: options.thread,
+        ownerClientId: selected.clientId,
+        ownerUser: selected.user,
+        fencingToken: options.fencingToken ?? createClientReconcilerFencingToken(options.thread, selected.clientId, nowMs, options.randomId),
+        expiresAt,
+    };
+}
+export function createClientReconcilerFencingToken(thread, clientId, now = Date.now(), randomId) {
+    const epoch = toEpochMs(now);
+    const entropy = normalizeText(randomId) ?? Math.random().toString(36).slice(2, 10);
+    return `client_${hashString(`${thread}|${clientId}|${epoch}|${entropy}`)}`;
+}
+function compareClientCapabilityForCoordination(a, b) {
+    const priority = CLIENT_KIND_PRIORITY[b.kind] - CLIENT_KIND_PRIORITY[a.kind];
+    if (priority !== 0)
+        return priority;
+    const heartbeat = Date.parse(b.heartbeatAt) - Date.parse(a.heartbeatAt);
+    if (heartbeat !== 0)
+        return heartbeat;
+    return a.clientId.localeCompare(b.clientId);
+}
+function resolveHumanAuthorityCount(input) {
+    if (typeof input.humanAuthorityCount === 'number' && Number.isFinite(input.humanAuthorityCount)) {
+        return Math.max(0, Math.floor(input.humanAuthorityCount));
+    }
+    if (!input.humanAuthorities)
+        return undefined;
+    const unique = new Set();
+    for (const value of input.humanAuthorities) {
+        const normalized = normalizeText(value);
+        if (normalized)
+            unique.add(normalized);
+    }
+    return unique.size;
+}
+function toEpochMs(value) {
+    if (typeof value === 'number')
+        return value;
+    if (value instanceof Date)
+        return value.getTime();
+    return Date.parse(value);
+}
+function normalizeText(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function hashString(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}

package/vendor/agent-runtime/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from './auto-mode.js';
 export * from './companion-model.js';
 export * from './client-inbox-subscription.js';
 export * from './control-plane.js';
+export * from './coordination.js';
 export * from './file-sync.js';
 export * from './reconciler.js';
 export * from './runtime.js';

package/vendor/agent-runtime/dist/index.js

@@ -4,6 +4,7 @@ export * from './auto-mode.js';
 export * from './companion-model.js';
 export * from './client-inbox-subscription.js';
 export * from './control-plane.js';
+export * from './coordination.js';
 export * from './file-sync.js';
 export * from './reconciler.js';
 export * from './runtime.js';

package/vendor/agent-runtime/dist/reconciler.d.ts

@@ -1,4 +1,5 @@
 import type { AgentParticipantRole } from './turn-controller.js';
+import { type ClientReconcilerLease, type ReconcilerOwner } from './coordination.js';
 export type ThreadPolicyKind = 'direct' | 'auto' | 'symphony' | 'open_group' | 'review';
 export type ThreadKind = 'main' | 'control' | 'worker' | 'review' | 'schedule' | 'schedule_run';
 export type ReconcilerEventType = 'message.appended' | 'input.required' | 'approval.required' | 'inbox.notification.created' | 'inbox.notification.updated' | 'delivery.submitted' | 'delivery.completed' | 'delivery.failed' | 'schedule.tick' | 'worker.blocked' | 'change.requested' | 'issue.updated' | 'task.updated' | 'run.updated' | (string & {});
@@ -62,6 +63,9 @@ export interface ThreadControlEvent<TData extends Record<string, unknown> = Reco
 }
 export interface ThreadPolicy {
     kind: ThreadPolicyKind;
+    reconcilerOwner?: ReconcilerOwner;
+    humanAuthorities?: string[];
+    humanAuthorityCount?: number;
     secretaryAgent?: string;
     defaultAssistantAgent?: string;
     assignedWorkerAgent?: string;
@@ -114,6 +118,7 @@ export interface ReconcilerNotificationEvent {
 export interface ReconcileDecision {
     id: string;
     policyKind: ThreadPolicyKind;
+    reconcilerOwner: ReconcilerOwner;
     event: ThreadControlEvent;
     placement: ThreadPlacement;
     wakeJobs: WakeJob[];
@@ -140,6 +145,7 @@ export interface WakeJobSummary {
 export interface ReconcileDecisionSummary {
     id: string;
     policyKind: ThreadPolicyKind;
+    reconcilerOwner: ReconcilerOwner;
     eventType: ReconcilerEventType;
     thread: string;
     chat?: string;
@@ -151,6 +157,11 @@ export interface ReconcileDecisionSummary {
 export interface ReconcileThreadEventInput {
     policy: ThreadPolicyKind | ThreadPolicy;
     event: ThreadControlEvent;
+    reconcilerOwner?: ReconcilerOwner;
+    humanAuthorities?: string[];
+    humanAuthorityCount?: number;
+    clientReconcilerLease?: ClientReconcilerLease | null;
+    requireClientReconcilerLease?: boolean;
     chat?: string;
     thread?: string;
     now?: Date;

package/vendor/agent-runtime/dist/reconciler.js

@@ -1,3 +1,4 @@
+import { canClientCoordinateThread, resolveReconcilerOwnership, } from './coordination.js';
 const DEFAULT_SECRETARY_AGENT = '__secretary__';
 const DEFAULT_ASSISTANT_AGENT = 'primary-agent';
 const DEFAULT_REVIEWER_AGENT = 'ai-reviewer';
@@ -24,12 +25,27 @@ export function reconcileThreadEvent(input) {
         thread: input.thread,
         randomId: input.randomId,
     });
-    const jobs = selectWakeJobs(policy, event, placement, createdAt, input.randomId, input.client);
+    const ownership = resolveReconcilerOwnership({
+        policyKind: policy.kind,
+        humanAuthorities: input.humanAuthorities ?? policy.humanAuthorities,
+        humanAuthorityCount: input.humanAuthorityCount ?? policy.humanAuthorityCount,
+        reconcilerOwner: input.reconcilerOwner ?? policy.reconcilerOwner,
+    });
+    const clientCoordinationSkip = resolveClientCoordinationSkip({
+        ownership,
+        input,
+        placement,
+        createdAt,
+    });
+    const jobs = clientCoordinationSkip
+        ? []
+        : selectWakeJobs(policy, event, placement, createdAt, input.randomId, input.client);
     const notificationEvents = selectNotificationEvents(event, placement, createdAt, input.randomId);
-    const skippedReason = jobs.length === 0 ? skipReasonFor(policy, event, input.client) : undefined;
+    const skippedReason = clientCoordinationSkip ?? (jobs.length === 0 ? skipReasonFor(policy, event, input.client) : undefined);
     return {
         id: createReconcilerId('decision', input.randomId),
         policyKind: policy.kind,
+        reconcilerOwner: ownership.reconcilerOwner,
         event,
         placement,
         wakeJobs: jobs,
@@ -42,6 +58,7 @@ export function summarizeReconcileDecision(decision) {
     return {
         id: decision.id,
         policyKind: decision.policyKind,
+        reconcilerOwner: decision.reconcilerOwner,
         eventType: decision.event.type,
         thread: decision.placement.thread,
         ...(decision.placement.chat ? { chat: decision.placement.chat } : {}),
@@ -120,6 +137,27 @@ export function resolveThreadPlacement(input) {
         kind: 'control',
     };
 }
+function resolveClientCoordinationSkip(input) {
+    if (input.ownership.reconcilerOwner !== 'client') {
+        return undefined;
+    }
+    if (!input.input.requireClientReconcilerLease && !input.input.clientReconcilerLease) {
+        return undefined;
+    }
+    const clientId = input.input.client?.id;
+    if (canClientCoordinateThread({
+        clientId,
+        thread: input.placement.thread,
+        lease: input.input.clientReconcilerLease,
+        now: input.createdAt,
+    })) {
+        return undefined;
+    }
+    const owner = input.input.clientReconcilerLease?.ownerClientId;
+    return owner
+        ? `Client-owned Reconciler is leased by ${owner}; client ${clientId ?? 'unknown'} must not reconcile ${input.placement.thread}.`
+        : `Client-owned Reconciler requires an active client coordinator lease for ${input.placement.thread}.`;
+}
 function selectWakeJobs(policy, event, placement, createdAt, randomId, client) {
     if (policy.kind === 'direct') {
         return isUserMessage(event)
@@ -127,7 +165,7 @@ function selectWakeJobs(policy, event, placement, createdAt, randomId, client) {
                     targetAgent: policy.defaultAssistantAgent ?? DEFAULT_ASSISTANT_AGENT,
                     targetRole: 'primary-agent',
                     priority: 'normal',
-                    reason: 'Direct thread routes user messages to the default assistant.',
+                    reason: 'Single-human assistant surfaces route user messages to the default assistant.',
                     createdAt,
                     randomId,
                 })]

package/vendor/agent-runtime/dist/symphony.d.ts

@@ -11,7 +11,7 @@ export declare const SYMPHONY_ISSUE_FILE_NAME = "issue.json";
 export declare const SYMPHONY_TASK_FILE_NAME = "task.json";
 export declare const SYMPHONY_DELIVERY_FILE_NAME = "delivery.json";
 export declare const SYMPHONY_SESSION_FILE_NAME = "session.json";
-export type SymphonyWorkspaceKind = 'git' | 'folder';
+export type WorkerWorkspaceKind = 'git' | 'folder';
 export type SymphonyIdeaStatus = 'captured' | 'exploring' | 'candidate' | 'promoted' | 'deferred' | 'rejected' | 'superseded';
 export type SymphonyIdeaCommitment = 'thought' | 'direction' | 'tentative_decision' | 'committed';
 export type SymphonyIssueStatus = 'open' | 'triaging' | 'in_progress' | 'blocked' | 'resolved' | 'closed';
@@ -23,13 +23,13 @@ export type SymphonyResourceKind = 'idea' | 'issue' | 'task' | 'delivery' | 'ses
 export interface SymphonyReconcilerState {
     decisions: ReconcileDecisionSummary[];
 }
-export interface SymphonyWorkspaceRef {
+export interface WorkerWorkspaceRef {
     path: string;
-    kind: SymphonyWorkspaceKind;
+    kind: WorkerWorkspaceKind;
     repository?: string;
     branch?: string;
     worktree?: string;
-    workspaceUri?: string;
+    workspace?: string;
     baseRevision?: string;
     environment?: SymphonyWorkerEnvironmentRef;
 }
@@ -59,6 +59,7 @@ export type SymphonyDelegationTargetSource = 'active-session' | 'group-chat' | '
 export interface SymphonyDelegationTarget extends SymphonyChatThreadRef {
     source: SymphonyDelegationTargetSource;
     backend: AutoModeWorkerBackend;
+    contact?: string;
     agent?: string;
     label?: string;
 }
@@ -104,6 +105,7 @@ export interface SymphonyTaskRecord extends SymphonyChatThreadRef {
     status: SymphonyTaskStatus;
     target: SymphonyDelegationTarget;
     backend: AutoModeWorkerBackend;
+    contact?: string;
     agent?: string;
     delivery: string;
     session: string;
@@ -145,7 +147,7 @@ export interface SymphonySessionRecord extends SymphonyChatThreadRef {
     secretaryAutoEnabled?: boolean;
     status: SymphonySessionStatus;
     cwd: string;
-    workspace?: SymphonyWorkspaceRef;
+    workspaceRef?: WorkerWorkspaceRef;
     target: SymphonyDelegationTarget;
     model?: string;
     supervisor?: SymphonySupervisorPolicy;
@@ -178,18 +180,18 @@ export interface SymphonyWorkerSpec extends Partial<SymphonyDelegationTarget> {
     acceptanceCriteria?: string[];
     model?: string;
     supervisorIntervalMs?: number;
-    workspace?: Partial<SymphonyWorkspaceRef>;
+    workspace?: Partial<WorkerWorkspaceRef>;
 }
 export interface CreateSymphonyRunPlanInput {
     objective: string;
     title?: string;
     acceptanceCriteria?: string[];
     workspacePath: string;
-    workspaceKind?: SymphonyWorkspaceKind;
+    workspaceKind?: WorkerWorkspaceKind;
     repository?: string;
     branch?: string;
     worktree?: string;
-    workspaceUri?: string;
+    workspace?: string;
     baseRevision?: string;
     environment?: Partial<SymphonyWorkerEnvironmentRef>;
     backend: AutoModeWorkerBackend;
@@ -240,7 +242,7 @@ export declare function renderSymphonyRuntimePrompt(input: {
     task: string;
     objective: string;
     acceptanceCriteria?: string[];
-    workspace: SymphonyWorkspaceRef;
+    workspace: WorkerWorkspaceRef;
     backend: AutoModeWorkerBackend;
     mode: AutoModeMode;
     secretaryAutoEnabled?: boolean;

package/vendor/agent-runtime/dist/symphony.js

@@ -72,7 +72,7 @@ export function createRunPlan(input) {
         ...(normalizeOptionalText(input.repository) ? { repository: normalizeOptionalText(input.repository) } : {}),
         ...(normalizeOptionalText(input.branch) ? { branch: normalizeOptionalText(input.branch) } : {}),
         ...(normalizeOptionalText(input.worktree) ? { worktree: normalizeOptionalText(input.worktree) } : {}),
-        ...(normalizeOptionalText(input.workspaceUri) ? { workspaceUri: normalizeOptionalText(input.workspaceUri) } : {}),
+        ...(normalizeOptionalText(input.workspace) ? { workspace: normalizeOptionalText(input.workspace) } : {}),
         ...(normalizeOptionalText(input.baseRevision) ? { baseRevision: normalizeOptionalText(input.baseRevision) } : {}),
         environment: normalizeSymphonyWorkerEnvironment(input.environment, input.backend),
     };
@@ -107,7 +107,7 @@ export function createRunPlan(input) {
             thread: target.thread ?? chatThread.thread,
             messages: target.messages ?? chatThread.messages,
         });
-        const targetAgent = target.agent ?? `${target.backend}-worker`;
+        const targetAgent = target.agent ?? target.contact ?? target.backend;
         const dispatchReconciler = createSymphonyDispatchReconcilerState({
             issue: issueUri,
             task: uris.task,
@@ -146,7 +146,7 @@ export function createRunPlan(input) {
             ...(input.secretaryAutoEnabled !== undefined ? { secretaryAutoEnabled: input.secretaryAutoEnabled } : {}),
             status: 'planned',
             cwd: workerWorkspace.path,
-            workspace: workerWorkspace,
+            workspaceRef: workerWorkspace,
             target,
             ...(spec.model ? { model: spec.model } : {}),
             ...(spec.supervisor ? { supervisor: spec.supervisor } : {}),
@@ -233,12 +233,13 @@ export function renderSymphonyRuntimePrompt(input) {
         ...(input.issuer?.thread ? [`Issuer thread: ${input.issuer.thread}`] : []),
         ...(input.target?.chat ? [`Target chat: ${input.target.chat}`] : []),
         ...(input.target?.thread ? [`Target thread: ${input.target.thread}`] : []),
+        ...(input.target?.contact ? [`Target contact: ${input.target.contact}`] : []),
         ...(input.target?.agent ? [`Target agent: ${input.target.agent}`] : []),
         ...(input.workerIndex && input.workerCount ? [`Worker: ${input.workerIndex}/${input.workerCount}`] : []),
         ...(workThread ? [`Work thread: ${workThread}`] : []),
         `Workspace: ${input.workspace.path}`,
         `Workspace kind: ${input.workspace.kind}`,
-        ...(input.workspace.workspaceUri ? [`Workspace URI: ${input.workspace.workspaceUri}`] : []),
+        ...(input.workspace.workspace ? [`Workspace resource: ${input.workspace.workspace}`] : []),
         ...(input.workspace.repository ? [`Workspace repository: ${input.workspace.repository}`] : []),
         ...(input.workspace.branch ? [`Workspace branch: ${input.workspace.branch}`] : []),
         ...(input.workspace.baseRevision ? [`Workspace base revision: ${input.workspace.baseRevision}`] : []),
@@ -405,7 +406,7 @@ function normalizeSymphonyWorkerWorkspace(root, override, backend) {
         ...(normalizeOptionalText(override?.repository ?? root.repository) ? { repository: normalizeOptionalText(override?.repository ?? root.repository) } : {}),
         ...(normalizeOptionalText(override?.branch ?? root.branch) ? { branch: normalizeOptionalText(override?.branch ?? root.branch) } : {}),
         ...(normalizeOptionalText(override?.worktree ?? root.worktree) ? { worktree: normalizeOptionalText(override?.worktree ?? root.worktree) } : {}),
-        ...(normalizeOptionalText(override?.workspaceUri ?? root.workspaceUri) ? { workspaceUri: normalizeOptionalText(override?.workspaceUri ?? root.workspaceUri) } : {}),
+        ...(normalizeOptionalText(override?.workspace ?? root.workspace) ? { workspace: normalizeOptionalText(override?.workspace ?? root.workspace) } : {}),
         ...(normalizeOptionalText(override?.baseRevision ?? root.baseRevision) ? { baseRevision: normalizeOptionalText(override?.baseRevision ?? root.baseRevision) } : {}),
         environment: normalizeSymphonyWorkerEnvironment(override?.environment ?? root.environment, backend),
     };
@@ -488,12 +489,14 @@ function createSymphonySupervisorPolicy(intervalMs) {
 }
 function normalizeSymphonyDelegationTarget(input) {
     const explicit = input.target ?? {};
+    const backend = explicit.backend ?? input.backend;
     const chatThread = normalizeSymphonyChatThreadRef({
         chat: explicit.chat ?? input.chat,
         thread: explicit.thread ?? input.thread,
         messages: explicit.messages ?? input.messages,
     });
-    const agent = normalizeOptionalText(explicit.agent) ?? `${input.backend}-worker`;
+    const contact = normalizeOptionalText(explicit.contact) ?? normalizeOptionalText(explicit.agent) ?? backend;
+    const agent = normalizeOptionalText(explicit.agent) ?? contact;
     const label = normalizeOptionalText(explicit.label);
     const source = explicit.source
         ?? (chatThread.chat || chatThread.thread
@@ -503,7 +506,8 @@ function normalizeSymphonyDelegationTarget(input) {
                 : 'default');
     return {
         source,
-        backend: explicit.backend ?? input.backend,
+        backend,
+        contact,
         agent,
         ...(label ? { label } : {}),
         ...chatThread,