@nettee/beacon 0.1.2 → 0.1.4

package/README.md

@@ -31,10 +31,11 @@ Upgrade to the current stable release with the same `latest` command. Run
 service. Beacon does not manage launchd installation, restart, or rollback in
 this release.
 
-Beacon only accepts an absolute path for the global configuration:
+Operator commands find the standard Beacon home automatically; a service
+deployment names its configuration explicitly:
 
 ```sh
-beacon doctor --config /Users/USERNAME/.beacon/config.yaml
+beacon doctor
 beacon serve --config /Users/USERNAME/.beacon/config.yaml
 ```
 
@@ -61,6 +62,20 @@ chmod 700 /Users/USERNAME/.beacon
 chmod 600 /Users/USERNAME/.beacon/secrets.json
 ```
 
+Configure a dedicated absolute Pi session root in `config.yaml`:
+
+```yaml
+pi:
+  executable: /ABSOLUTE/PATH/TO/pi
+  coding_agent_directory: /Users/USERNAME/.pi/agent
+  session_directory: /Users/USERNAME/.beacon/sessions
+```
+
+`pi.session_directory` is optional for compatibility with configurations
+created by Beacon 0.1.2 and earlier; when omitted it defaults to `sessions/`
+beside `config.yaml`. When configured, it must be absolute. Beacon creates
+per-Run directories with mode `0700` when Pi starts.
+
 Configuration is strict: unknown YAML/JSON fields, YAML aliases or warnings, missing paths, duplicate Schedule IDs, invalid timezones/cron expressions, unsafe Prompt paths, permissive secret permissions, and missing Profile credentials all fail startup. Beacon validates all Profiles before opening a Feishu connection.
 
 Each Schedule uses a five-field cron expression and an IANA timezone. Its `delivery.chat_id` may identify either a direct chat or a group chat; Beacon deliberately does not infer or fall back to another destination. A newly discovered Schedule starts at the current time. After sleep or restart, overdue occurrences are reconciled and coalesced to the most recent one.
@@ -69,22 +84,65 @@ Each Schedule uses a five-field cron expression and an IANA timezone. Its `deliv
 
 ```text
 beacon serve --config <absolute-path>
-beacon doctor --config <absolute-path>
-beacon trigger --config <absolute-path> --profile <id> --input -
+beacon doctor [--config <absolute-path>]
+beacon trigger [--config <absolute-path>] --profile <id> --input -
+beacon schedule trigger [--config <absolute-path>] --profile <id> --schedule <id>
 beacon version
 ```
 
+Operator commands use `~/.beacon/config.yaml` when `--config` is omitted.
+An explicit override must still be an absolute path. `serve` keeps requiring an
+explicit absolute config path so service definitions identify their deployment
+configuration unambiguously.
+
 An operator can run one Profile without Feishu delivery by piping input to `trigger`; the Final Outcome is printed to stdout:
 
 ```sh
 printf '%s\n' 'Summarize the workspace status.' | \
-  beacon trigger --config /Users/USERNAME/.beacon/config.yaml --profile example --input -
+  beacon trigger --profile example --input -
+```
+
+An operator can also immediately run a configured Schedule through the real
+Schedule input and Feishu chat Delivery path:
+
+```sh
+beacon schedule trigger --profile example --schedule daily-report
 ```
 
+This creates a distinct durable Run on every invocation and prints its
+`run_id`. It uses the Schedule's configured `input` and `delivery.chat_id`, but
+does not read, initialize, or advance the Schedule's cron cursor. Unknown
+Profiles or Schedules and failed Runs or Deliveries exit non-zero; failure
+messages include the `run_id` whenever a Run record was created.
+
 ## State and failure behavior
 
 Per-Profile state lives below `profiles/<profile-id>/state/`. Trigger claims, normalized inputs, Run state, Final Outcomes, Delivery state, and Schedule cursors use durable JSON snapshots. Records do not expire, and Beacon has no automatic cleanup task. Manually deleting state also deletes its deduplication memory.
 
+Every new business Run also owns a permanent Pi session. Its Run record stores
+both `sessionId` and `sessionPath`; the session ID is exactly the Beacon
+`runId`, and the path is the dedicated directory
+`<pi.session_directory>/<profile-id>/<runId>/`. Pi receives that mapping via
+`--session-dir`, `--session-id`, and a readable `Beacon <profile-id> <runId>`
+name. The directory contains the Pi JSONL session file and is never cleaned up
+by Beacon. A queued Run keeps the same mapping after restart. Queued records
+written by Beacon 0.1.2 or earlier are assigned the same deterministic mapping
+when recovered. Historical completed records remain readable and may omit the
+two session fields because those Runs were originally ephemeral.
+
+To locate a session from a reported `run_id`, first find its durable Run
+record, then inspect or export the sole JSONL file in `sessionPath`:
+
+```sh
+rg -l '"runId": "run_REPORTED_ID"' /Users/USERNAME/.beacon/profiles/*/state/triggers/*/record.json
+jq '.run | {runId, sessionId, sessionPath, state}' /ABSOLUTE/PATH/TO/record.json
+find /ABSOLUTE/SESSION/PATH -maxdepth 1 -name '*.jsonl' -print
+pi --export /ABSOLUTE/SESSION/PATH/TIMESTAMP_run_REPORTED_ID.jsonl run.html
+```
+
+`beacon doctor` keeps using `--no-session`, so its Pi smoke tests do not create
+diagnostic session files.
+
 Duplicate Feishu events and duplicate Schedule occurrences do not start a second Run. Active Runs interrupted by restart fail rather than rerun. Pending Delivery can resume, while a Delivery interrupted after its external call began fails without resending. Run and Delivery success are recorded independently. Beacon does not automatically retry either one.
 
 Secrets and ephemeral Run Capability tokens are excluded from persisted records and from the Pi environment except for the one Run-scoped Outcome capability.
@@ -105,6 +163,12 @@ launchctl print gui/$(id -u)/io.nettee.beacon
 
 The example uses a restrictive umask and asks launchd to restart only after abnormal exit. `SIGTERM` initiates an orderly shutdown: timers and Gateways stop, accepted intake work drains, and the local Outcome server closes.
 
+The repository also contains Chinese operator runbooks based on the verified
+`macmini.liuyi` deployment:
+
+- [Deploy or update Beacon on macmini](docs/macmini-deploy-and-update.md)
+- [Add a Beacon Profile on macmini](docs/macmini-add-profile.md)
+
 ## Development checks
 
 Development requires pnpm 10.33.2. Install dependencies before running checks
@@ -131,7 +195,7 @@ installed `beacon` binary without using the source tree.
 `pnpm e2e:message` sends one synthetic Feishu direct message through an
 in-memory Gateway, the production message pipeline, and a real Pi model. The
 same in-memory Gateway captures the quoted reply without contacting Feishu. It defaults to
-`openai-codex/gpt-5.3-codex-spark`; override the runtime with
+`openai-codex/gpt-5.6-luna:low`; override the runtime with
 `BEACON_E2E_MESSAGE_PROVIDER`, `BEACON_E2E_MESSAGE_MODEL`,
 `BEACON_E2E_MESSAGE_PI_EXECUTABLE`, or
 `BEACON_E2E_MESSAGE_PI_CODING_AGENT_DIRECTORY`.

package/dist/cli-app.js

@@ -1,18 +1,40 @@
-import { isAbsolute } from "node:path";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+export const defaultConfigPath = join(homedir(), ".beacon", "config.yaml");
 function usage() {
     throw new Error(`Usage:
   beacon serve --config <absolute-path>
-  beacon doctor --config <absolute-path>
-  beacon trigger --config <absolute-path> --profile <id> --input -
+  beacon doctor [--config <absolute-path>]
+  beacon trigger [--config <absolute-path>] --profile <id> --input -
+  beacon schedule trigger [--config <absolute-path>] --profile <id> --schedule <id>
   beacon version`);
 }
-function configOnly(args) {
+function requiredConfig(args) {
     if (args.length !== 2 || args[0] !== "--config" || !args[1])
         usage();
     if (!isAbsolute(args[1]))
         throw new Error("Config path must be absolute");
     return args[1];
 }
+function options(args) {
+    if (args.length % 2 !== 0)
+        usage();
+    const values = new Map();
+    for (let index = 0; index < args.length; index += 2) {
+        const key = args[index];
+        const value = args[index + 1];
+        if (!key?.startsWith("--") || !value || values.has(key))
+            usage();
+        values.set(key, value);
+    }
+    return values;
+}
+function optionalConfig(values) {
+    const config = values.get("--config") ?? defaultConfigPath;
+    if (!isAbsolute(config))
+        throw new Error("Config path must be absolute");
+    return config;
+}
 export function parseCli(args) {
     const [command, ...rest] = args;
     if (command === "version") {
@@ -20,30 +42,38 @@ export function parseCli(args) {
             usage();
         return { command: "version" };
     }
-    if (command === "serve" || command === "doctor") {
-        return { command, config: configOnly(rest) };
+    if (command === "serve") {
+        return { command, config: requiredConfig(rest) };
     }
-    if (command === "trigger") {
-        if (rest.length !== 6)
+    if (command === "doctor") {
+        const values = options(rest);
+        if ([...values.keys()].some((key) => key !== "--config"))
             usage();
-        const values = new Map();
-        for (let index = 0; index < rest.length; index += 2) {
-            const key = rest[index];
-            const value = rest[index + 1];
-            if (!key?.startsWith("--") || !value || values.has(key))
-                usage();
-            values.set(key, value);
-        }
-        const config = values.get("--config");
+        return { command, config: optionalConfig(values) };
+    }
+    if (command === "trigger") {
+        const values = options(rest);
         const profile = values.get("--profile");
-        if (!config ||
-            !profile ||
+        if (!profile ||
             values.get("--input") !== "-" ||
-            values.size !== 3)
+            [...values.keys()].some((key) => !["--config", "--profile", "--input"].includes(key)))
+            usage();
+        return { command: "trigger", config: optionalConfig(values), profile };
+    }
+    if (command === "schedule" && rest[0] === "trigger") {
+        const values = options(rest.slice(1));
+        const profile = values.get("--profile");
+        const schedule = values.get("--schedule");
+        if (!profile ||
+            !schedule ||
+            [...values.keys()].some((key) => !["--config", "--profile", "--schedule"].includes(key)))
             usage();
-        if (!isAbsolute(config))
-            throw new Error("Config path must be absolute");
-        return { command: "trigger", config, profile };
+        return {
+            command: "schedule-trigger",
+            config: optionalConfig(values),
+            profile,
+            schedule,
+        };
     }
     if (command === "outcome" && rest.length === 1 && rest[0] === "submit") {
         return { command: "outcome-submit" };
@@ -65,6 +95,9 @@ export async function runCli(command, dependencies) {
     if (command.command === "trigger") {
         return dependencies.trigger(command.config, command.profile, await readStdin());
     }
+    if (command.command === "schedule-trigger") {
+        return dependencies.triggerSchedule(command.config, command.profile, command.schedule);
+    }
     if (command.command === "outcome-submit")
         return dependencies.submitOutcome();
     console.log(dependencies.version);

package/dist/cli.js

@@ -3,6 +3,7 @@ import { parseCli, runCli } from "./cli-app.js";
 import { runDoctor } from "./doctor.js";
 import { runManualTrigger } from "./manual-trigger.js";
 import { submitOutcomeFromCli } from "./outcome/submit.js";
+import { runScheduleTrigger } from "./schedule-trigger.js";
 import { runBeacon } from "./service.js";
 import { packageVersion } from "./version.js";
 async function main() {
@@ -10,6 +11,7 @@ async function main() {
         serve: runBeacon,
         doctor: runDoctor,
         trigger: runManualTrigger,
+        triggerSchedule: runScheduleTrigger,
         submitOutcome: submitOutcomeFromCli,
         version: packageVersion,
     });

package/dist/config/global.js

@@ -1,6 +1,6 @@
 import { constants } from "node:fs";
 import { access, realpath, stat } from "node:fs/promises";
-import { dirname, isAbsolute, resolve } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { z } from "zod";
 import { parseStrictYaml } from "./yaml.js";
 const positiveInteger = z.number().int().positive().safe();
@@ -12,6 +12,7 @@ const globalDocumentSchema = z
         .object({
         executable: z.string().min(1),
         coding_agent_directory: z.string().min(1),
+        session_directory: z.string().min(1).optional(),
     })
         .strict(),
     runs: z
@@ -63,6 +64,10 @@ export async function loadGlobalConfig(path) {
     if (!isAbsolute(document.pi.coding_agent_directory)) {
         throw new Error("Pi coding agent directory must be absolute");
     }
+    if (document.pi.session_directory !== undefined &&
+        !isAbsolute(document.pi.session_directory)) {
+        throw new Error("Pi session directory path must be absolute");
+    }
     const executable = await assertFile(document.pi.executable, true);
     const codingAgentDirectory = await assertDirectory(document.pi.coding_agent_directory);
     return {
@@ -70,7 +75,13 @@ export async function loadGlobalConfig(path) {
         homeDirectory,
         profilesDirectory,
         secretsPath: resolve(homeDirectory, "secrets.json"),
-        pi: { executable, codingAgentDirectory },
+        pi: {
+            executable,
+            codingAgentDirectory,
+            // Keep version 1 configurations valid while moving sessions out of Pi's
+            // workspace-derived default hierarchy.
+            sessionDirectory: document.pi.session_directory ?? join(homeDirectory, "sessions"),
+        },
         runs: {
             maxConcurrent: document.runs.max_concurrent,
             maxQueued: document.runs.max_queued,

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

@@ -8,6 +8,7 @@ export function createPiRunOrchestrator(options) {
         queue: options.queue,
         outcomes: options.outcomes,
         beaconCliPath: fileURLToPath(new URL("../../dist/cli.js", import.meta.url)),
+        sessionDirectory: options.config.pi.sessionDirectory,
         runAgent: (request) => runPiAgent(request, {
             executable: options.config.pi.executable,
             timeoutMs: options.config.runs.timeoutSeconds * 1_000,

package/dist/run/orchestrator.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
+import { isAbsolute, join } from "node:path";
 import { PiRuntimeError } from "../runtime/pi-rpc.js";
 function promptFor(input) {
     if (input.kind === "manual") {
@@ -42,6 +43,9 @@ export class RunOrchestrator {
     id;
     constructor(options) {
         this.options = options;
+        if (!isAbsolute(options.sessionDirectory)) {
+            throw new Error("Pi session directory must be absolute");
+        }
         this.now = options.now ?? (() => new Date());
         this.id = options.id ?? randomUUID;
     }
@@ -52,6 +56,8 @@ export class RunOrchestrator {
         const timestamp = this.timestamp();
         return {
             runId,
+            sessionId: runId,
+            sessionPath: join(this.options.sessionDirectory, this.options.profile.id, runId),
             state,
             queuedAt: timestamp,
             ...(state === "failed" ? { finishedAt: timestamp } : {}),
@@ -136,10 +142,30 @@ export class RunOrchestrator {
         await this.deliver(triggerKey);
     }
     async execute(triggerKey, input, runId) {
-        await this.options.store.update(triggerKey, (current) => ({
-            ...current,
-            run: { ...current.run, state: "starting", startedAt: this.timestamp() },
-        }));
+        const record = await this.options.store.update(triggerKey, (current) => {
+            if (!current.run) {
+                throw new Error(`Cannot execute Trigger ${triggerKey} without a Run`);
+            }
+            const session = current.run.sessionId && current.run.sessionPath
+                ? {
+                    sessionId: current.run.sessionId,
+                    sessionPath: current.run.sessionPath,
+                }
+                : {
+                    // Migration for queued records written by Beacon <= 0.1.2.
+                    sessionId: current.run.runId,
+                    sessionPath: join(this.options.sessionDirectory, this.options.profile.id, current.run.runId),
+                };
+            return {
+                ...current,
+                run: {
+                    ...current.run,
+                    ...session,
+                    state: "starting",
+                    startedAt: this.timestamp(),
+                },
+            };
+        });
         await this.options.store.update(triggerKey, (current) => ({
             ...current,
             run: { ...current.run, state: "running" },
@@ -158,6 +184,11 @@ export class RunOrchestrator {
                     "Beacon ignores ordinary assistant final text for Delivery.",
                 ].join("\n"),
                 outcome: { ...submission.binding, cliPath: this.options.beaconCliPath },
+                session: {
+                    id: record.run.sessionId,
+                    path: record.run.sessionPath,
+                    name: `Beacon ${this.options.profile.id} ${runId}`,
+                },
             });
             const outcome = submission.take();
             await this.options.store.update(triggerKey, (current) => ({

package/dist/runtime/pi-rpc.js

@@ -1,4 +1,6 @@
 import { spawn } from "node:child_process";
+import { chmod, mkdir } from "node:fs/promises";
+import { isAbsolute } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 export class PiRuntimeError extends Error {
@@ -43,7 +45,15 @@ function collectText(message) {
         .trim();
 }
 function buildArguments(request) {
-    const args = ["--mode", "rpc", "--no-session", "--no-approve"];
+    const args = ["--mode", "rpc", "--no-approve"];
+    if (request.session) {
+        args.push("--session-dir", request.session.path, "--session-id", request.session.id);
+        if (request.session.name)
+            args.push("--name", request.session.name);
+    }
+    else {
+        args.push("--no-session");
+    }
     if (request.provider)
         args.push("--provider", request.provider);
     if (request.model)
@@ -124,6 +134,24 @@ export async function runPiAgent(request, options = {}) {
     if ((request.provider === undefined) !== (request.model === undefined)) {
         throw new Error("Pi Run provider and model must either both be set or both be omitted");
     }
+    if (request.session) {
+        if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(request.session.id)) {
+            throw new Error("Pi session ID is invalid");
+        }
+        if (!isAbsolute(request.session.path)) {
+            throw new Error("Pi session path must be absolute");
+        }
+        if (request.session.name !== undefined && !request.session.name.trim()) {
+            throw new Error("Pi session name must not be empty");
+        }
+        try {
+            await mkdir(request.session.path, { recursive: true, mode: 0o700 });
+            await chmod(request.session.path, 0o700);
+        }
+        catch (error) {
+            throw new PiRuntimeError("runtime_spawn_failed", `Cannot prepare Pi session directory: ${request.session.path}`, { cause: error });
+        }
+    }
     const executable = options.executable ?? "pi";
     const timeoutMs = options.timeoutMs ?? 5 * 60_000;
     const terminateGraceMs = options.terminateGraceMs ?? 1_000;

package/dist/schedule-trigger.js

@@ -0,0 +1,81 @@
+import { randomUUID } from "node:crypto";
+import { loadGlobalConfig } from "./config/global.js";
+import { loadProfileRegistry } from "./config/registry.js";
+import { loadFeishuCredentials } from "./config/secrets.js";
+import { createFeishuGateway } from "./feishu/gateway.js";
+import { startOutcomeServer } from "./outcome/server.js";
+import { createPiRunOrchestrator } from "./run/create-pi-orchestrator.js";
+import { RunQueue } from "./run/queue.js";
+import { TriggerStore } from "./state/trigger-store.js";
+function findSchedule(profile, scheduleId) {
+    const schedule = profile.schedules.find((candidate) => candidate.id === scheduleId);
+    if (!schedule) {
+        throw new Error(`Unknown Schedule in Profile ${profile.id}: ${scheduleId}`);
+    }
+    return schedule;
+}
+export async function triggerScheduleOnce(options) {
+    const schedule = findSchedule(options.profile, options.scheduleId);
+    const scheduledFor = (options.now ?? (() => new Date()))().toISOString();
+    const invocationId = (options.id ?? randomUUID)();
+    const claim = await options.store.claim({
+        sourceKey: ["manual-schedule", schedule.id, invocationId],
+        target: { kind: "chat", chatId: schedule.delivery.chatId },
+        ingress: {
+            invocation: "manual",
+            scheduleId: schedule.id,
+            scheduledFor,
+            text: schedule.input,
+        },
+    });
+    if (!claim.created) {
+        throw new Error(`Duplicate manual Schedule invocation: ${invocationId}`);
+    }
+    await options.process(claim.record.triggerKey, async () => ({
+        kind: "schedule",
+        scheduleId: schedule.id,
+        scheduledFor,
+        text: schedule.input,
+    }));
+    const record = (await options.store.list()).find((candidate) => candidate.triggerKey === claim.record.triggerKey);
+    if (!record?.run) {
+        throw new Error(`Schedule Trigger produced no Run record: trigger_id=${claim.record.triggerId}`);
+    }
+    if (record.run.state !== "succeeded" ||
+        record.delivery?.state !== "delivered") {
+        const failure = record.run.failure?.code ?? record.delivery?.failure?.code ?? "unknown";
+        throw new Error(`Schedule Trigger failed (run_id=${record.run.runId}): ${failure}`);
+    }
+    return record;
+}
+export async function runScheduleTrigger(configPath, profileId, scheduleId) {
+    const global = await loadGlobalConfig(configPath);
+    const profiles = await loadProfileRegistry(global.profilesDirectory);
+    const profile = profiles.find((candidate) => candidate.id === profileId);
+    if (!profile)
+        throw new Error(`Unknown Profile: ${profileId}`);
+    findSchedule(profile, scheduleId);
+    const credentials = await loadFeishuCredentials(profile.id, global.secretsPath);
+    const outcomes = await startOutcomeServer();
+    try {
+        const store = new TriggerStore(profile.directory, profile.id);
+        const orchestrator = createPiRunOrchestrator({
+            config: global,
+            profile,
+            store,
+            queue: new RunQueue(global.runs.maxConcurrent, global.runs.maxQueued),
+            outcomes,
+            delivery: createFeishuGateway(credentials),
+        });
+        const record = await triggerScheduleOnce({
+            profile,
+            scheduleId,
+            store,
+            process: (triggerKey, normalize) => orchestrator.process(triggerKey, normalize),
+        });
+        console.log(`[beacon] Schedule Trigger succeeded run_id=${record.run.runId}`);
+    }
+    finally {
+        await outcomes.close();
+    }
+}

package/dist/state/trigger-store.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, mkdir, open, readdir, readFile, rename, } from "node:fs/promises";
-import { join } from "node:path";
+import { basename, dirname, isAbsolute, join } from "node:path";
 import { z } from "zod";
 import { failureCodes, } from "../domain/types.js";
 const timestamp = z.string().datetime({ offset: true });
@@ -44,6 +44,15 @@ const inputSchema = z.discriminatedUnion("kind", [
 const runSchema = z
     .object({
     runId: z.string().min(1),
+    sessionId: z
+        .string()
+        .regex(/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/)
+        .optional(),
+    sessionPath: z
+        .string()
+        .min(1)
+        .refine(isAbsolute, "Pi session path must be absolute")
+        .optional(),
     state: z.enum(["queued", "starting", "running", "succeeded", "failed"]),
     queuedAt: timestamp,
     startedAt: timestamp.optional(),
@@ -96,6 +105,17 @@ function keyFor(profileId, sourceKey) {
 }
 function validateRecord(value) {
     const record = triggerRecordSchema.parse(value);
+    if (record.run &&
+        (record.run.sessionId === undefined) !==
+            (record.run.sessionPath === undefined)) {
+        throw new Error("Run record must contain both Pi sessionId and sessionPath or neither");
+    }
+    if (record.run?.sessionId &&
+        (record.run.sessionId !== record.run.runId ||
+            basename(record.run.sessionPath) !== record.run.runId ||
+            basename(dirname(record.run.sessionPath)) !== record.profileId)) {
+        throw new Error("Run Pi session identity must map to its Profile ID and Run ID");
+    }
     if (record.delivery && !record.finalOutcome) {
         throw new Error("Trigger record with Delivery must contain a Final Outcome");
     }

package/examples/config.yaml

@@ -3,6 +3,7 @@ profiles_directory: profiles
 pi:
   executable: /ABSOLUTE/PATH/TO/pi
   coding_agent_directory: /Users/USERNAME/.pi/agent
+  session_directory: /Users/USERNAME/.beacon/sessions
 runs:
   max_concurrent: 2
   max_queued: 100

package/package.json

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