@undefineds.co/linx 0.3.8 → 0.3.15

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

@@ -1,11 +1,43 @@
 import type { AgentParticipantRole } from './turn-controller.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' | 'delivery.submitted' | 'delivery.completed' | 'delivery.failed' | 'schedule.tick' | 'worker.blocked' | 'change.requested' | 'issue.updated' | 'task.updated' | 'run.updated' | (string & {});
+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 & {});
 export type ReconcilerActorRole = AgentParticipantRole | 'worker' | 'reviewer' | 'runtime' | 'scheduler' | 'tool' | 'assistant';
 export type WakeJobTargetRole = AgentParticipantRole | 'worker' | 'reviewer';
 export type WakeJobPriority = 'low' | 'normal' | 'high';
 export type WakeJobStatus = 'queued';
+export type ReconcilerNotificationAudience = 'user';
+export type ReconcilerNotificationChannel = 'inbox';
+export type ReconcilerClientFocusState = 'focused' | 'background' | 'closed';
+export type ReconcilerControlResourceClaimStatus = 'claimed' | 'lost' | 'display_only' | 'none';
+export interface ReconcilerControlResourceClaimState {
+    status: ReconcilerControlResourceClaimStatus;
+    controlResource?: string;
+    leaseOwner?: string;
+    leaseExpiresAt?: string;
+    reason?: string;
+}
+export interface ReconcilerClientContext {
+    id: string;
+    agentCapable?: boolean;
+    secretaryRuntimeAvailable?: boolean;
+    focusState?: ReconcilerClientFocusState;
+    activeThread?: string;
+    activeChat?: string;
+    generationLocked?: boolean;
+    controlResourceClaim?: ReconcilerControlResourceClaimState;
+}
+export interface SecretaryInboxWakeContext {
+    eventId: string;
+    eventType: ReconcilerEventType;
+    controlResource?: string;
+    sourceThread?: string;
+    sourceRun?: string;
+    sourceTask?: string;
+    requestKind?: string;
+    priority: WakeJobPriority;
+    shortSummary?: string;
+}
 export interface ReconcilerActorRef {
     id?: string;
     role?: ReconcilerActorRole;
@@ -60,12 +92,32 @@ export interface WakeJob {
     sourceEventType: ReconcilerEventType;
     createdAt: string;
 }
+export interface ReconcilerNotificationEvent {
+    id: string;
+    thread: string;
+    chat?: string;
+    audience: ReconcilerNotificationAudience;
+    channel: ReconcilerNotificationChannel;
+    priority: WakeJobPriority;
+    reason: string;
+    sourceEventId?: string;
+    sourceEventType: ReconcilerEventType;
+    sourceResource?: string;
+    inboxNotification?: string;
+    sourceThread?: string;
+    sourceRun?: string;
+    sourceTask?: string;
+    requestKind?: string;
+    shortSummary?: string;
+    createdAt: string;
+}
 export interface ReconcileDecision {
     id: string;
     policyKind: ThreadPolicyKind;
     event: ThreadControlEvent;
     placement: ThreadPlacement;
     wakeJobs: WakeJob[];
+    notificationEvents?: ReconcilerNotificationEvent[];
     skippedReason?: string;
     createdAt: string;
 }
@@ -82,6 +134,7 @@ export interface WakeJobSummary {
     sourceEventId?: string;
     sourceEventType: ReconcilerEventType;
     sourceResource?: string;
+    inboxNotification?: string;
     controlGate?: string;
 }
 export interface ReconcileDecisionSummary {
@@ -92,6 +145,7 @@ export interface ReconcileDecisionSummary {
     chat?: string;
     skippedReason?: string;
     wakeJobs: WakeJobSummary[];
+    notificationEvents?: ReconcilerNotificationEvent[];
     createdAt: string;
 }
 export interface ReconcileThreadEventInput {
@@ -101,6 +155,7 @@ export interface ReconcileThreadEventInput {
     thread?: string;
     now?: Date;
     randomId?: string;
+    client?: ReconcilerClientContext;
 }
 export interface ThreadReconciler {
     readonly policy: ThreadPolicy;
@@ -115,3 +170,7 @@ export declare function resolveThreadPlacement(input: {
     thread?: string;
     randomId?: string;
 }): ThreadPlacement;
+export declare function buildSecretaryInboxWakeContext(event: ThreadControlEvent, options?: {
+    priority?: WakeJobPriority;
+}): SecretaryInboxWakeContext;
+export declare function canClientScheduleInboxWake(client: ReconcilerClientContext | undefined, event: ThreadControlEvent, now?: Date | string | number): boolean;

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

@@ -24,14 +24,16 @@ export function reconcileThreadEvent(input) {
         thread: input.thread,
         randomId: input.randomId,
     });
-    const jobs = selectWakeJobs(policy, event, placement, createdAt, input.randomId);
-    const skippedReason = jobs.length === 0 ? skipReasonFor(policy, event) : undefined;
+    const jobs = 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;
     return {
         id: createReconcilerId('decision', input.randomId),
         policyKind: policy.kind,
         event,
         placement,
         wakeJobs: jobs,
+        ...(notificationEvents.length > 0 ? { notificationEvents } : {}),
         ...(skippedReason ? { skippedReason } : {}),
         createdAt,
     };
@@ -57,8 +59,12 @@ export function summarizeReconcileDecision(decision) {
             ...(job.sourceEventId ? { sourceEventId: job.sourceEventId } : {}),
             sourceEventType: job.sourceEventType,
             ...(decision.event.resource ? { sourceResource: decision.event.resource } : {}),
+            ...(normalizeText(decision.event.data?.inboxNotification) ? { inboxNotification: normalizeText(decision.event.data?.inboxNotification) } : {}),
             ...(resolveControlGate(decision.event) ? { controlGate: resolveControlGate(decision.event) } : {}),
         })),
+        ...(decision.notificationEvents && decision.notificationEvents.length > 0
+            ? { notificationEvents: decision.notificationEvents.map((event) => ({ ...event })) }
+            : {}),
         createdAt: decision.createdAt,
     };
 }
@@ -114,7 +120,7 @@ export function resolveThreadPlacement(input) {
         kind: 'control',
     };
 }
-function selectWakeJobs(policy, event, placement, createdAt, randomId) {
+function selectWakeJobs(policy, event, placement, createdAt, randomId, client) {
     if (policy.kind === 'direct') {
         return isUserMessage(event)
             ? [createWakeJob(policy, event, placement, {
@@ -128,6 +134,11 @@ function selectWakeJobs(policy, event, placement, createdAt, randomId) {
             : [];
     }
     if (policy.kind === 'auto') {
+        if (isActionableInboxEvent(event)) {
+            return canClientScheduleInboxWake(client, event, createdAt)
+                ? [createSecretaryWakeJob(policy, event, placement, 'Auto mode claimed an actionable control resource on this client and schedules the same-Thread Secretary to check Inbox.', 'high', createdAt, randomId)]
+                : [];
+        }
         if (isInputApprovalOrBlocker(event)) {
             return [createSecretaryWakeJob(policy, event, placement, 'Auto mode routes input, approval, and blocker events to the same-Thread Secretary.', 'high', createdAt, randomId)];
         }
@@ -140,6 +151,11 @@ function selectWakeJobs(policy, event, placement, createdAt, randomId) {
         return [];
     }
     if (policy.kind === 'symphony') {
+        if (isActionableInboxEvent(event)) {
+            return canClientScheduleInboxWake(client, event, createdAt)
+                ? [createSecretaryWakeJob(policy, event, placement, 'Symphony claimed an actionable control resource on this client and schedules Secretary to check Inbox; the payload is runtime control context, not a human user message.', 'high', createdAt, randomId)]
+                : [];
+        }
         if (isInputApprovalOrBlocker(event) || event.type === 'change.requested') {
             return [createSecretaryWakeJob(policy, event, placement, 'Symphony routes blocker, input, approval, and change requests to Secretary for semantic judgment.', 'high', createdAt, randomId)];
         }
@@ -157,10 +173,10 @@ function selectWakeJobs(policy, event, placement, createdAt, randomId) {
             return [createSecretaryWakeJob(policy, event, placement, 'Symphony Delivery submissions wake Secretary for review or routing.', 'normal', createdAt, randomId)];
         }
         if (event.type === 'delivery.completed') {
-            return [createSecretaryWakeJob(policy, event, placement, 'Symphony completion Delivery wakes Secretary for quality and acceptance reconciliation.', 'high', createdAt, randomId)];
+            return [createSecretaryWakeJob(policy, event, placement, 'Symphony completion Delivery wakes Secretary for quality, acceptance, and follow-up extraction reconciliation.', 'high', createdAt, randomId)];
         }
         if (event.type === 'delivery.failed') {
-            return [createSecretaryWakeJob(policy, event, placement, 'Symphony failed Delivery wakes Secretary for feasibility, retry, or scope change reconciliation.', 'high', createdAt, randomId)];
+            return [createSecretaryWakeJob(policy, event, placement, 'Symphony failed Delivery wakes Secretary for feasibility, retry, scope change, or follow-up extraction reconciliation.', 'high', createdAt, randomId)];
         }
         if (event.type === 'issue.updated' || event.type === 'task.updated' || event.type === 'run.updated') {
             return [createSecretaryWakeJob(policy, event, placement, 'Symphony state changes wake Secretary to reconcile system state.', 'normal', createdAt, randomId)];
@@ -197,6 +213,92 @@ function selectWakeJobs(policy, event, placement, createdAt, randomId) {
     }
     return [];
 }
+function selectNotificationEvents(event, placement, createdAt, randomId) {
+    if (!isActionableInboxEvent(event)) {
+        return [];
+    }
+    const wakeContext = buildSecretaryInboxWakeContext(event, { priority: 'high' });
+    return [{
+            id: createReconcilerId('notice', randomId ?? event.id),
+            thread: placement.thread,
+            ...(placement.chat ? { chat: placement.chat } : {}),
+            audience: 'user',
+            channel: 'inbox',
+            priority: 'high',
+            reason: 'Inbox envelope changed; notify subscribed clients to refresh Inbox and read the linked control resource without converting it into chat.',
+            ...(event.id ? { sourceEventId: event.id } : {}),
+            sourceEventType: event.type,
+            ...(event.resource ? { sourceResource: event.resource } : {}),
+            ...(normalizeText(event.data?.inboxNotification) ? { inboxNotification: normalizeText(event.data?.inboxNotification) } : {}),
+            ...(wakeContext.sourceThread ? { sourceThread: wakeContext.sourceThread } : {}),
+            ...(wakeContext.sourceRun ? { sourceRun: wakeContext.sourceRun } : {}),
+            ...(wakeContext.sourceTask ? { sourceTask: wakeContext.sourceTask } : {}),
+            ...(wakeContext.requestKind ? { requestKind: wakeContext.requestKind } : {}),
+            ...(wakeContext.shortSummary ? { shortSummary: wakeContext.shortSummary } : {}),
+            createdAt,
+        }];
+}
+export function buildSecretaryInboxWakeContext(event, options = {}) {
+    const controlResource = normalizeText(event.resource)
+        ?? normalizeText(event.data?.controlResource)
+        ?? normalizeText(event.data?.controlResourceId)
+        ?? normalizeText(event.data?.approval)
+        ?? normalizeText(event.data?.inputRequest);
+    const requestKind = normalizeText(event.data?.requestKind)
+        ?? normalizeText(event.data?.kind)
+        ?? normalizeText(event.data?.type);
+    const sourceThread = normalizeText(event.data?.sourceThread);
+    const sourceRun = normalizeText(event.data?.sourceRun);
+    const sourceTask = normalizeText(event.data?.sourceTask);
+    const shortSummary = normalizeText(event.data?.shortSummary)
+        ?? normalizeText(event.data?.summary)
+        ?? normalizeText(event.content);
+    return {
+        eventId: event.id ?? createReconcilerId('event', controlResource ?? requestKind),
+        eventType: event.type,
+        ...(controlResource ? { controlResource } : {}),
+        ...(sourceThread ? { sourceThread } : {}),
+        ...(sourceRun ? { sourceRun } : {}),
+        ...(sourceTask ? { sourceTask } : {}),
+        ...(requestKind ? { requestKind } : {}),
+        priority: options.priority ?? 'normal',
+        ...(shortSummary ? { shortSummary } : {}),
+    };
+}
+export function canClientScheduleInboxWake(client, event, now = Date.now()) {
+    if (!client || !isActionableInboxEvent(event)) {
+        return false;
+    }
+    if (client.agentCapable !== true) {
+        return false;
+    }
+    if (client.secretaryRuntimeAvailable === false) {
+        return false;
+    }
+    const claim = client.controlResourceClaim;
+    if (!claim || claim.status !== 'claimed') {
+        return false;
+    }
+    const eventControlResource = normalizeText(event.resource)
+        ?? normalizeText(event.data?.controlResource)
+        ?? normalizeText(event.data?.controlResourceId);
+    const claimControlResource = normalizeText(claim.controlResource);
+    if (eventControlResource && claimControlResource && eventControlResource !== claimControlResource) {
+        return false;
+    }
+    const leaseOwner = normalizeText(claim.leaseOwner);
+    if (leaseOwner && leaseOwner !== client.id) {
+        return false;
+    }
+    if (claim.leaseExpiresAt) {
+        const expiresAt = Date.parse(claim.leaseExpiresAt);
+        const nowMs = typeof now === 'number' ? now : Date.parse(now instanceof Date ? now.toISOString() : now);
+        if (!Number.isNaN(expiresAt) && !Number.isNaN(nowMs) && expiresAt <= nowMs) {
+            return false;
+        }
+    }
+    return true;
+}
 function createSecretaryWakeJob(policy, event, placement, reason, priority, createdAt, randomId) {
     return createWakeJob(policy, event, placement, {
         targetAgent: policy.secretaryAgent ?? DEFAULT_SECRETARY_AGENT,
@@ -245,12 +347,34 @@ function threadKindFromEvent(event) {
     if (event.type === 'issue.updated' || event.type === 'task.updated' || event.type === 'run.updated') {
         return 'control';
     }
+    if (isInboxEvent(event)) {
+        return 'control';
+    }
     return 'main';
 }
 function isInputApprovalOrBlocker(event) {
     return event.type === 'input.required' || event.type === 'approval.required' || event.type === 'worker.blocked';
 }
 function resolveControlGate(event) {
+    if (isInboxEvent(event)) {
+        const explicitGate = normalizeText(event.data?.controlGate);
+        if (explicitGate) {
+            return explicitGate;
+        }
+        const requestKind = normalizeText(event.data?.requestKind)
+            ?? normalizeText(event.data?.kind)
+            ?? normalizeText(event.data?.type);
+        if (requestKind && /approval|auth|credential|grant|permission|destructive/iu.test(requestKind)) {
+            return 'authority';
+        }
+        if (requestKind && /block|fail|feasibil/iu.test(requestKind)) {
+            return 'feasibility';
+        }
+        if (requestKind && /change|scope|rebase|steer/iu.test(requestKind)) {
+            return 'change';
+        }
+        return 'binding';
+    }
     if (event.type === 'input.required' || event.type === 'approval.required') {
         return 'authority';
     }
@@ -290,6 +414,19 @@ function isPrimaryAgentMessage(event) {
             || event.data?.role === 'assistant'
             || event.data?.source === 'primary-agent');
 }
+function isInboxEvent(event) {
+    return event.type === 'inbox.notification.created' || event.type === 'inbox.notification.updated';
+}
+function isActionableInboxEvent(event) {
+    if (!isInboxEvent(event)) {
+        return false;
+    }
+    const status = normalizeText(event.data?.status);
+    if (!status) {
+        return event.type === 'inbox.notification.created';
+    }
+    return status === 'pending' || status === 'handling';
+}
 function isTaskDispatchDelivery(event) {
     return event.data?.deliveryType === 'task_dispatch'
         || event.data?.type === 'task_dispatch'
@@ -328,10 +465,17 @@ function isMentioned(content, agent) {
         .filter(Boolean)
         .some((name) => normalized.includes(`@${name.toLowerCase()}`));
 }
-function skipReasonFor(policy, event) {
+function skipReasonFor(policy, event, client) {
     if (policy.kind === 'open_group') {
         return 'No mentioned or subscribed agents matched the event.';
     }
+    if (isActionableInboxEvent(event) && (policy.kind === 'auto' || policy.kind === 'symphony')) {
+        if (!client) {
+            return `Policy ${policy.kind} keeps ${event.type} display-only until a subscribed client claims the control resource.`;
+        }
+        const claimStatus = client.controlResourceClaim?.status ?? 'none';
+        return `Policy ${policy.kind} keeps ${event.type} display-only for client ${client.id} because control resource claim status is ${claimStatus}.`;
+    }
     return `Policy ${policy.kind} does not wake an agent for ${event.type}.`;
 }
 function createSyntheticThreadUri(kind, value) {

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

@@ -245,10 +245,10 @@ export function renderSymphonyRuntimePrompt(input) {
         ...(input.workspace.environment ? [`Workspace environment: ${formatSymphonyWorkerEnvironment(input.workspace.environment)}`] : []),
         '',
         '## Runtime Space Contract',
-        '- Shared control space: Issue, Task, Delivery, Session, Run, and Evidence URIs are the common coordination surface with AI Secretary and product UI.',
+        '- Shared control space: Idea/Issue/Report/Evidence are file-primary Pod resources with structured meta; Task, Delivery, Session, Run, and RunStep are TTL control resources. Use the provided URIs as the common coordination surface with AI Secretary and product UI.',
         '- Explicit session topology: you may be collaborating in the same room as Secretary or running in a runtime-projected worker session reached through control events. Follow the provided chat/thread/session targets; do not infer topology from workspace sharing.',
         '- Thread reconciliation: messages, input/approval requests, blockers, schedule ticks, and Delivery submissions enter the Thread first; the Reconciler/Scheduler wakes Secretary or workers.',
-        '- Report through Delivery/Evidence: return progress, blockers, implementation change requests, and verification for AI Secretary to persist or route.',
+        '- Report through Delivery plus file-primary Report/Evidence: return progress, blockers, implementation change requests, and verification so AI Secretary can persist structured control facts and Pod files without inlining long logs into TTL.',
         '- Thread workspace: workers assigned to the same Thread in the same environment should normally share this workspace; independent Threads may use separate worktrees.',
         '- Environment-scoped identity: cross-environment file identity requires revision, artifact, patch, checksum, or evidence references.',
         '',
@@ -266,20 +266,21 @@ export function renderSymphonyRuntimePrompt(input) {
         '- Report blockers to AI Secretary instead of asking the user directly.',
         '- Do not read sibling worker transcripts unless Secretary explicitly includes them in a Delivery.',
         '- Preserve a concise report with changed files, commands run, and remaining risks.',
+        '- In the final report, explicitly list follow-up candidates separately from assigned-work evidence: new defects, missing shared abstractions, app-local glue to move into shared models, storage, or adapter packages, live verification gaps, or deferred cleanup. Secretary classifies these; do not create or close Issues yourself.',
         '- If blocked by missing credentials, destructive actions, or unclear scope, report the blocker instead of guessing.',
         '- Your workspace path is local to this worker environment. Same-Thread workers in this environment may share it, but do not assume Secretary, the user, or workers in other environments can access the same absolute path.',
         '- When reporting file work across environments, include repo-relative paths plus base revision, checksums/etags, patch or artifact references, and verification evidence.',
         '',
         '## Pod And Control Record Boundary',
         '- In LinX runtime, Pod control records are authoritative. Local files are mirrors, logs, or portable-runtime fallbacks.',
-        '- If Pod/model tools are available, read only the assigned Issue, Task, Delivery, Run, source context, and existing evidence needed for this task.',
-        '- Write only execution facts for the assigned work: Run/RunStep progress, blockers, Evidence, Delivery report, or Implementation Change Request.',
+        '- If Pod/model tools are available, read only the assigned Issue document/meta, Task, Delivery, Run, source context, and existing Report/Evidence files needed for this task.',
+        '- Write only execution facts for the assigned work: Run/RunStep progress, blockers, file-primary Evidence/Report, Delivery report metadata, or Implementation Change Request.',
         '- Do not close Issues, rewrite Spec/current truth, change acceptance criteria, change work split, alter release or roadmap state, create grants, or mutate sibling worker state.',
         '- Use shared model/ORM surfaces when writing structured Pod data. Do not hand-patch business TTL or invent Pod paths.',
         '- If Pod access is unavailable, return the same facts as a structured report so AI Secretary can persist them.',
         '',
         '## Documentation Authority',
-        '- Pod Issue/Spec/Task records are the control authority for status, scope, acceptance, split, ownership, closure, and cross-client coordination.',
+        '- Pod Issue files plus meta, Spec files, and Task control records are the authority for status, scope, acceptance, split, ownership, closure, and cross-client coordination.',
         '- Repository docs are the implementation authority for code-adjacent design, behavior notes, tests, examples, migration details, and file-level evidence.',
         '- When you edit repository docs, reference the Pod Issue/Spec/Task URI instead of creating a second Issue truth.',
         '- If repository findings contradict the Pod control record, write an Implementation Change Request instead of silently changing acceptance or scope.',

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

@@ -1,4 +1,4 @@
-import { type ReconcileDecision, type ReconcileDecisionSummary, type ReconcileThreadEventInput, type ThreadControlEvent, type ThreadPolicy, type ThreadPolicyKind, type WakeJob } from './reconciler.js';
+import { type ReconcileDecision, type ReconcileDecisionSummary, type ReconcileThreadEventInput, type ReconcilerNotificationEvent, type ThreadControlEvent, type ThreadPolicy, type ThreadPolicyKind, type WakeJob } from './reconciler.js';
 import { type WakeJobExecutionRecord, type WakeJobExecutionRecordSummary, type WakeJobSchedulerSnapshot, type WakeJobSchedulerSnapshotSummary } from './wake-scheduler.js';
 type MaybePromise<T> = T | Promise<T>;
 export interface ThreadWakeJobContext {
@@ -19,6 +19,7 @@ export interface ThreadReconcilerControllerOptions {
     onWakeJobStarted?: (record: WakeJobExecutionRecord, decision: ReconcileDecisionSummary) => void;
     onWakeJobCompleted?: (record: WakeJobExecutionRecord, decision: ReconcileDecisionSummary) => void;
     onWakeJobFailed?: (record: WakeJobExecutionRecord, decision: ReconcileDecisionSummary) => void;
+    onNotificationEvent?: (event: ReconcilerNotificationEvent, decision: ReconcileDecisionSummary) => void;
 }
 export interface ThreadReconcilerDispatchOptions extends Omit<ReconcileThreadEventInput, 'policy' | 'event'> {
 }

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

@@ -58,10 +58,14 @@ class ConfiguredThreadReconcilerController {
     dispatch(event, options = {}) {
         const { decision, summary } = decideThreadControlEvent({
             ...options,
+            now: options.now ?? this.options.now?.(),
             policy: this.options.policy,
             event,
         });
         this.options.onDecision?.(summary);
+        for (const notificationEvent of decision.notificationEvents ?? []) {
+            this.options.onNotificationEvent?.(notificationEvent, summary);
+        }
         for (const job of decision.wakeJobs) {
             const key = defaultWakeJobDedupeKey(job);
             if (!this.contexts.has(key)) {