@nettee/beacon 0.6.0 → 0.6.1

package/dist/daemon/run/create-pi-orchestrator.js

@@ -4,7 +4,9 @@ import { DEFAULT_ORPHAN_AFTER_MS } from "../runtime/supervisor-lease.js";
 import { RunOrchestrator } from "./orchestrator.js";
 export function createPiRunOrchestrator(options) {
     const detachRuns = options.detachRuns ?? true;
-    const supervisorLeasePath = join(options.config.homeDirectory, "state", "supervisor.lease");
+    const stateDirectory = join(options.config.homeDirectory, "state");
+    const supervisorLeasePath = join(stateDirectory, "supervisor.lease");
+    const outcomesDirectory = join(stateDirectory, "outcomes");
     return new RunOrchestrator({
         profile: options.profile,
         store: options.store,
@@ -26,6 +28,7 @@ export function createPiRunOrchestrator(options) {
             ? {
                 detached: {
                     supervisorLeasePath,
+                    outcomesDirectory,
                     orphanAfterMs: options.orphanAfterMs ?? DEFAULT_ORPHAN_AFTER_MS,
                     executable: options.config.pi.executable,
                     timeoutMs: options.config.runs.timeoutSeconds * 1_000,

package/dist/daemon/run/orchestrator.d.ts

@@ -11,6 +11,8 @@ export type DeliveryAdapter = {
 };
 export type DetachedRunOptions = {
     supervisorLeasePath: string;
+    /** Directory for short per-run Outcome sockets (e.g. ~/.beacon/state/outcomes). */
+    outcomesDirectory: string;
     orphanAfterMs?: number | undefined;
     executable?: string | undefined;
     timeoutMs?: number | undefined;

package/dist/daemon/run/orchestrator.js

@@ -3,7 +3,7 @@ import { isAbsolute, join } from "node:path";
 import { isMissingReplyOutcomeError, MISSING_REPLY_OUTCOME_SUMMARY, } from "../outcome/content.js";
 import { inboundOutOfRoleReply } from "../outcome/instructions.js";
 import { PiRuntimeError, RUNTIME_TIMEOUT_OUTCOME_MISSING_NOTE, RUNTIME_TIMEOUT_OUTCOME_SUBMITTED_NOTE, } from "../runtime/pi-rpc.js";
-import { isWorkerAdoptable, signalWorker, spawnDetachedPiWorker, waitForWorkerCompletion, } from "../runtime/pi-worker-lifecycle.js";
+import { isWorkerAdoptable, resolveWorkerOutcomeSocketPath, signalWorker, spawnDetachedPiWorker, waitForWorkerCompletion, } from "../runtime/pi-worker-lifecycle.js";
 import { DEFAULT_ORPHAN_AFTER_MS } from "../runtime/supervisor-lease.js";
 import { agentSystemPromptTrigger, buildAgentSystemPrompt, profilePromptDigest, } from "../runtime/system-prompt.js";
 function promptFor(input) {
@@ -383,6 +383,7 @@ export class RunOrchestrator {
         const lifecycleDirectory = join(sessionPath, "beacon-runtime");
         const runToken = randomBytes(32).toString("base64url");
         const orphanAfterMs = detached.orphanAfterMs ?? DEFAULT_ORPHAN_AFTER_MS;
+        const outcomeSocketPath = resolveWorkerOutcomeSocketPath(detached.outcomesDirectory, runId);
         const handle = await spawnDetachedPiWorker(lifecycleDirectory, {
             prompt: promptFor(input),
             playbook: this.options.profile.playbook,
@@ -394,6 +395,7 @@ export class RunOrchestrator {
                 path: sessionPath,
                 name: `Beacon ${this.options.profile.id} ${runId}`,
             },
+            outcomeSocketPath,
             ...(this.options.profile.skills
                 ? { skills: this.options.profile.skills }
                 : {}),

package/dist/daemon/runtime/pi-worker-lifecycle.d.ts

@@ -1,6 +1,11 @@
 import type { ProfileSkills } from "../config/profile.js";
 import type { FeedbackRecord, FinalOutcomeContent, ObservabilityFeedbackRecord } from "../domain/types.js";
 import type { PiRunResult, PiRuntimeOptions } from "./pi-rpc.js";
+/**
+ * Usable AF_UNIX path length on macOS (`sun_path` is 104 including NUL).
+ * Enforced on all platforms so Linux CI catches oversize paths too.
+ */
+export declare const UNIX_SOCKET_PATH_MAX_BYTES = 103;
 export type PiWorkerRequest = {
     prompt: string;
     playbook: string;
@@ -15,6 +20,8 @@ export type PiWorkerRequest = {
     skills?: ProfileSkills | undefined;
     beaconCliPath: string;
     runToken: string;
+    /** Short absolute path under ~/.beacon/state/outcomes/<16hex>.sock */
+    outcomeSocketPath: string;
     supervisorLeasePath: string;
     orphanAfterMs?: number | undefined;
     executable?: string | undefined;
@@ -24,6 +31,8 @@ export type PiWorkerRequest = {
     environment?: NodeJS.ProcessEnv | undefined;
     runtimeEnvironment?: NodeJS.ProcessEnv | undefined;
 };
+/** Stable, short per-run Outcome socket under the daemon outcomes directory. */
+export declare function resolveWorkerOutcomeSocketPath(outcomesDirectory: string, runId: string): string;
 export type PiWorkerCompletion = {
     ok: true;
     result: PiRunResult;
@@ -55,9 +64,12 @@ export declare function lifecyclePaths(lifecycleDirectory: string): {
     completion: string;
     heartbeat: string;
     pid: string;
-    outcomeSocket: string;
+    /** @deprecated 0.6.0 bound here; 0.6.1+ uses resolveWorkerOutcomeSocketPath. */
+    legacyOutcomeSocket: string;
 };
-export declare function prepareLifecycleDirectory(lifecycleDirectory: string): Promise<void>;
+export declare function prepareLifecycleDirectory(lifecycleDirectory: string, options?: {
+    outcomeSocketPath?: string | undefined;
+}): Promise<void>;
 export declare function writeWorkerRequest(lifecycleDirectory: string, request: PiWorkerRequest): Promise<void>;
 export declare function readWorkerRequest(lifecycleDirectory: string): Promise<PiWorkerRequest>;
 export declare function writeWorkerHeartbeat(lifecycleDirectory: string): Promise<void>;

package/dist/daemon/runtime/pi-worker-lifecycle.js

@@ -1,8 +1,30 @@
 import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
 import { access, chmod, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
-import { isAbsolute, join } from "node:path";
+import { dirname, isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_ORPHAN_AFTER_MS, isSupervisorLeaseFresh, } from "./supervisor-lease.js";
+/**
+ * Usable AF_UNIX path length on macOS (`sun_path` is 104 including NUL).
+ * Enforced on all platforms so Linux CI catches oversize paths too.
+ */
+export const UNIX_SOCKET_PATH_MAX_BYTES = 103;
+/** Stable, short per-run Outcome socket under the daemon outcomes directory. */
+export function resolveWorkerOutcomeSocketPath(outcomesDirectory, runId) {
+    if (!isAbsolute(outcomesDirectory)) {
+        throw new Error("Worker outcome socket directory must be absolute");
+    }
+    if (!runId) {
+        throw new Error("Worker outcome socket requires a run id");
+    }
+    const shortId = createHash("sha256").update(runId).digest("hex").slice(0, 16);
+    const socketPath = join(outcomesDirectory, `${shortId}.sock`);
+    const bytes = Buffer.byteLength(socketPath, "utf8");
+    if (bytes > UNIX_SOCKET_PATH_MAX_BYTES) {
+        throw new Error(`Worker outcome socket path exceeds Unix sun_path limit (${bytes} > ${UNIX_SOCKET_PATH_MAX_BYTES} bytes): ${socketPath}`);
+    }
+    return socketPath;
+}
 const REQUEST_FILE = "request.json";
 const COMPLETION_FILE = "completion.json";
 const HEARTBEAT_FILE = "worker.heartbeat";
@@ -13,10 +35,11 @@ export function lifecyclePaths(lifecycleDirectory) {
         completion: join(lifecycleDirectory, COMPLETION_FILE),
         heartbeat: join(lifecycleDirectory, HEARTBEAT_FILE),
         pid: join(lifecycleDirectory, PID_FILE),
-        outcomeSocket: join(lifecycleDirectory, "outcomes.sock"),
+        /** @deprecated 0.6.0 bound here; 0.6.1+ uses resolveWorkerOutcomeSocketPath. */
+        legacyOutcomeSocket: join(lifecycleDirectory, "outcomes.sock"),
     };
 }
-export async function prepareLifecycleDirectory(lifecycleDirectory) {
+export async function prepareLifecycleDirectory(lifecycleDirectory, options = {}) {
     if (!isAbsolute(lifecycleDirectory)) {
         throw new Error("Pi worker lifecycle directory must be absolute");
     }
@@ -26,10 +49,25 @@ export async function prepareLifecycleDirectory(lifecycleDirectory) {
     await rm(paths.completion, { force: true });
     await rm(paths.heartbeat, { force: true });
     await rm(paths.pid, { force: true });
-    await rm(paths.outcomeSocket, { force: true });
+    await rm(paths.legacyOutcomeSocket, { force: true });
+    if (options.outcomeSocketPath) {
+        if (!isAbsolute(options.outcomeSocketPath)) {
+            throw new Error("Worker outcome socket path must be absolute");
+        }
+        await mkdir(dirname(options.outcomeSocketPath), {
+            recursive: true,
+            mode: 0o700,
+        });
+        await rm(options.outcomeSocketPath, { force: true });
+    }
 }
 export async function writeWorkerRequest(lifecycleDirectory, request) {
-    await prepareLifecycleDirectory(lifecycleDirectory);
+    if (!request.outcomeSocketPath || !isAbsolute(request.outcomeSocketPath)) {
+        throw new Error("Pi worker request requires an absolute outcomeSocketPath");
+    }
+    await prepareLifecycleDirectory(lifecycleDirectory, {
+        outcomeSocketPath: request.outcomeSocketPath,
+    });
     const temporary = `${lifecyclePaths(lifecycleDirectory).request}.tmp`;
     await writeFile(temporary, `${JSON.stringify(request, null, 2)}\n`, {
         mode: 0o600,
@@ -38,9 +76,15 @@ export async function writeWorkerRequest(lifecycleDirectory, request) {
 }
 export async function readWorkerRequest(lifecycleDirectory) {
     const raw = JSON.parse(await readFile(lifecyclePaths(lifecycleDirectory).request, "utf8"));
-    if (!raw.beaconCliPath || !raw.runToken || !raw.supervisorLeasePath) {
+    if (!raw.beaconCliPath ||
+        !raw.runToken ||
+        !raw.supervisorLeasePath ||
+        !raw.outcomeSocketPath) {
         throw new Error("Pi worker request is missing required fields");
     }
+    if (!isAbsolute(raw.outcomeSocketPath)) {
+        throw new Error("Pi worker outcomeSocketPath must be absolute");
+    }
     return raw;
 }
 export async function writeWorkerHeartbeat(lifecycleDirectory) {

package/dist/daemon/runtime/pi-worker-main.js

@@ -1,8 +1,9 @@
 import { chmod, mkdir, rm } from "node:fs/promises";
 import { createServer } from "node:net";
+import { dirname } from "node:path";
 import { completeOutcome, mergeOutcome, parseOutcomePatch, } from "../outcome/content.js";
 import { PiRuntimeError, runPiAgent } from "./pi-rpc.js";
-import { assertSupervisorOrThrow, lifecyclePaths, readWorkerRequest, writeWorkerCompletion, writeWorkerHeartbeat, } from "./pi-worker-lifecycle.js";
+import { assertSupervisorOrThrow, readWorkerRequest, writeWorkerCompletion, writeWorkerHeartbeat, } from "./pi-worker-lifecycle.js";
 import { DEFAULT_ORPHAN_AFTER_MS } from "./supervisor-lease.js";
 function respond(socket, response) {
     socket.end(`${JSON.stringify(response)}\n`);
@@ -123,8 +124,9 @@ async function startWorkerOutcomeServer(socketPath, runToken, maxRequestBytes =
 async function runWorker(lifecycleDirectory) {
     const request = await readWorkerRequest(lifecycleDirectory);
     const orphanAfterMs = request.orphanAfterMs ?? DEFAULT_ORPHAN_AFTER_MS;
-    const paths = lifecyclePaths(lifecycleDirectory);
+    const outcomeSocketPath = request.outcomeSocketPath;
     await mkdir(lifecycleDirectory, { recursive: true, mode: 0o700 });
+    await mkdir(dirname(outcomeSocketPath), { recursive: true, mode: 0o700 });
     const abort = new AbortController();
     const heartbeat = setInterval(() => {
         void writeWorkerHeartbeat(lifecycleDirectory).catch(() => undefined);
@@ -137,7 +139,7 @@ async function runWorker(lifecycleDirectory) {
     }, 5_000);
     heartbeat.unref?.();
     await writeWorkerHeartbeat(lifecycleDirectory);
-    const outcomes = await startWorkerOutcomeServer(paths.outcomeSocket, request.runToken);
+    const outcomes = await startWorkerOutcomeServer(outcomeSocketPath, request.runToken);
     const finish = async (completion) => {
         clearInterval(heartbeat);
         await writeWorkerCompletion(lifecycleDirectory, completion);
@@ -154,7 +156,7 @@ async function runWorker(lifecycleDirectory) {
             session: request.session,
             skills: request.skills,
             outcome: {
-                socketPath: paths.outcomeSocket,
+                socketPath: outcomeSocketPath,
                 runToken: request.runToken,
                 cliPath: request.beaconCliPath,
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nettee/beacon",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "A single-host bridge from messaging and schedules to isolated agent runs",
   "license": "Apache-2.0",
   "repository": {