@undefineds.co/linx 0.3.15 → 0.3.16

package/vendor/agent-runtime/dist/pod-resource-identity.js

@@ -0,0 +1,54 @@
+const ABSOLUTE_IRI = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+const AGENT_RESOURCE_ID = /^([A-Za-z0-9_.-]+)\/$/;
+const AGENT_KEY = /^[A-Za-z0-9_.-]+$/;
+export function asBaseRelativeResourceId(value, label = 'Resource id') {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${label} must be a non-empty base-relative resource id.`);
+    }
+    const normalized = value.trim();
+    if (ABSOLUTE_IRI.test(normalized) || normalized.startsWith('/') || normalized.startsWith('//')) {
+        throw new Error(`${label} must be a base-relative resource id.`);
+    }
+    return normalized;
+}
+export function asResourceIri(value, label = 'Resource IRI') {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${label} must be a non-empty resource IRI.`);
+    }
+    const normalized = value.trim();
+    if (!ABSOLUTE_IRI.test(normalized)) {
+        throw new Error(`${label} must be a full resource IRI.`);
+    }
+    return normalized;
+}
+export function requireRowResourceId(row, label = 'Pod row') {
+    if (!row || typeof row.id !== 'string' || row.id.trim().length === 0) {
+        throw new Error(`${label} row is missing row.id.`);
+    }
+    return asBaseRelativeResourceId(row.id, `${label} row.id`);
+}
+function defaultAgentKey() {
+    return `agent_${Math.random().toString(36).slice(2, 12)}`;
+}
+export function agentResourceId(key) {
+    const raw = typeof key === 'string' ? key.trim() : '';
+    const value = raw || defaultAgentKey();
+    if (AGENT_RESOURCE_ID.test(value)) {
+        return asBaseRelativeResourceId(value, 'Agent resource id');
+    }
+    if (!AGENT_KEY.test(value)) {
+        throw new Error('Agent key must use letters, numbers, dot, underscore, or dash.');
+    }
+    return asBaseRelativeResourceId(`${value}/`, 'Agent resource id');
+}
+export function agentKeyFromResourceId(resourceId) {
+    const id = asBaseRelativeResourceId(resourceId, 'Agent resource id');
+    const match = id.match(AGENT_RESOURCE_ID);
+    if (!match?.[1]) {
+        throw new Error('Agent resource id must use {agentKey}/.');
+    }
+    return match[1];
+}
+export function agentHomeDirFromResourceId(resourceId) {
+    return asBaseRelativeResourceId(agentResourceId(agentKeyFromResourceId(resourceId)), 'Agent home dir');
+}

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

@@ -173,10 +173,10 @@ function selectWakeJobs(policy, event, placement, createdAt, randomId, client) {
             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, acceptance, and follow-up extraction reconciliation.', 'high', createdAt, randomId)];
+            return [createSecretaryWakeJob(policy, event, placement, 'Symphony completion Delivery wakes Secretary for quality and acceptance reconciliation.', 'high', createdAt, randomId)];
         }
         if (event.type === 'delivery.failed') {
-            return [createSecretaryWakeJob(policy, event, placement, 'Symphony failed Delivery wakes Secretary for feasibility, retry, scope change, or follow-up extraction reconciliation.', 'high', createdAt, randomId)];
+            return [createSecretaryWakeJob(policy, event, placement, 'Symphony failed Delivery wakes Secretary for feasibility, retry, or scope change 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)];

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: 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.',
+        '- Shared control space: Issue, Task, Delivery, Session, Run, and Evidence URIs are 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 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.',
+        '- Report through Delivery/Evidence: return progress, blockers, implementation change requests, and verification for AI Secretary to persist or route.',
         '- 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,21 +266,20 @@ 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 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.',
+        '- 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.',
         '- 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 files plus meta, Spec files, and Task control records are the authority for status, scope, acceptance, split, ownership, closure, and cross-client coordination.',
+        '- Pod Issue/Spec/Task records are the control 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/workspace.d.ts

@@ -0,0 +1,33 @@
+export type RuntimeWorkspaceKind = 'local-folder' | 'local-worktree' | 'pod-container';
+export interface RuntimeWorkspaceInput {
+    workspaceKind?: unknown;
+    workspaceUri?: string | null;
+    repoPath?: string | null;
+    folderPath?: string | null;
+    baseRef?: string | null;
+    branch?: string | null;
+}
+export interface NormalizedRuntimeWorkspaceInput {
+    workspaceKind: RuntimeWorkspaceKind;
+    workspaceUri?: string;
+    repoPath?: string;
+    folderPath?: string;
+    baseRef: string;
+    branch?: string;
+}
+export interface NormalizeRuntimeWorkspaceOptions {
+    normalizeLocalPath?: (value?: string | null) => string;
+    defaultBaseRef?: string;
+}
+export interface RuntimeWorkspaceSessionLike {
+    cwd?: string | null;
+    repoPath?: string | null;
+    folderPath?: string | null;
+    workspaceUri?: string | null;
+}
+export declare function isRuntimeWorkspaceKind(value: unknown): value is RuntimeWorkspaceKind;
+export declare function isHttpWorkspaceRef(value?: string | null): boolean;
+export declare function inferRuntimeWorkspaceKind(input: RuntimeWorkspaceInput, options?: NormalizeRuntimeWorkspaceOptions): RuntimeWorkspaceKind;
+export declare function normalizeRuntimeWorkspaceInput(input: RuntimeWorkspaceInput, options?: NormalizeRuntimeWorkspaceOptions): NormalizedRuntimeWorkspaceInput;
+export declare function isRuntimeSessionInWorkspace(session: RuntimeWorkspaceSessionLike, workspacePath: string, options?: NormalizeRuntimeWorkspaceOptions): boolean;
+export declare function filterRuntimeSessionsForWorkspace<T extends RuntimeWorkspaceSessionLike>(sessions: T[], workspacePath: string, options?: NormalizeRuntimeWorkspaceOptions): T[];

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

@@ -0,0 +1,80 @@
+function trim(value) {
+    return value?.trim() || '';
+}
+function normalizeLocalPath(value) {
+    return trim(value);
+}
+export function isRuntimeWorkspaceKind(value) {
+    return value === 'local-folder' || value === 'local-worktree' || value === 'pod-container';
+}
+export function isHttpWorkspaceRef(value) {
+    const candidate = trim(value);
+    if (!candidate)
+        return false;
+    try {
+        const url = new URL(candidate);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+export function inferRuntimeWorkspaceKind(input, options = {}) {
+    if (isRuntimeWorkspaceKind(input.workspaceKind)) {
+        return input.workspaceKind;
+    }
+    const normalize = options.normalizeLocalPath ?? normalizeLocalPath;
+    const repoPath = normalize(input.repoPath);
+    if (isHttpWorkspaceRef(input.workspaceUri) && !repoPath) {
+        return 'pod-container';
+    }
+    const folderPath = normalize(input.folderPath);
+    return repoPath && folderPath && folderPath !== repoPath ? 'local-worktree' : 'local-folder';
+}
+export function normalizeRuntimeWorkspaceInput(input, options = {}) {
+    const normalize = options.normalizeLocalPath ?? normalizeLocalPath;
+    const workspaceKind = inferRuntimeWorkspaceKind(input, options);
+    const workspaceUri = trim(input.workspaceUri) || undefined;
+    const repoPath = normalize(input.repoPath) || undefined;
+    const folderPathInput = normalize(input.folderPath) || undefined;
+    const baseRef = trim(input.baseRef) || options.defaultBaseRef || 'HEAD';
+    const branch = trim(input.branch) || undefined;
+    if (workspaceKind === 'pod-container') {
+        if (!workspaceUri || !isHttpWorkspaceRef(workspaceUri)) {
+            throw new Error('Pod workspace session requires an http(s) workspaceUri.');
+        }
+        return {
+            workspaceKind,
+            workspaceUri,
+            repoPath,
+            folderPath: folderPathInput,
+            baseRef,
+            branch,
+        };
+    }
+    if (!repoPath) {
+        throw new Error('Local runtime session requires repoPath.');
+    }
+    const folderPath = folderPathInput || repoPath;
+    return {
+        workspaceKind: folderPath !== repoPath ? 'local-worktree' : 'local-folder',
+        workspaceUri,
+        repoPath,
+        folderPath,
+        baseRef,
+        branch,
+    };
+}
+export function isRuntimeSessionInWorkspace(session, workspacePath, options = {}) {
+    const normalize = options.normalizeLocalPath ?? normalizeLocalPath;
+    const expected = normalize(workspacePath);
+    if (!expected)
+        return false;
+    const candidates = [session.cwd, session.folderPath, session.repoPath]
+        .map((value) => normalize(value))
+        .filter(Boolean);
+    return candidates.some((candidate) => candidate === expected);
+}
+export function filterRuntimeSessionsForWorkspace(sessions, workspacePath, options = {}) {
+    return sessions.filter((session) => isRuntimeSessionInWorkspace(session, workspacePath, options));
+}

package/vendor/agent-runtime/package.json

@@ -9,12 +9,14 @@
     "./companion-model": "./dist/companion-model.js",
     "./control-plane": "./dist/control-plane.js",
     "./file-sync": "./dist/file-sync.js",
+    "./pod-resource-identity": "./dist/pod-resource-identity.js",
     "./reconciler": "./dist/reconciler.js",
     "./runtime": "./dist/runtime.js",
     "./symphony": "./dist/symphony.js",
     "./sync": "./dist/sync.js",
     "./thread-reconciler-controller": "./dist/thread-reconciler-controller.js",
     "./turn-controller": "./dist/turn-controller.js",
-    "./wake-scheduler": "./dist/wake-scheduler.js"
+    "./wake-scheduler": "./dist/wake-scheduler.js",
+    "./workspace": "./dist/workspace.js"
   }
 }