qlogicagent 2.13.5 → 2.13.6

package/dist/cli/core-tools/config-tool-service.js

@@ -1,86 +0,0 @@
-/**
- * Config tool service — backs the `config` tool onto the REAL tunables system
- * (settings.tunables.*), the same store the UI settings page manages via the
- * config.updateTunable RPC. ModelRegistry.getTunable() re-reads settings.json
- * per call, so every write here is hot — no restart needed.
- */
-import { getDefaultPathService } from "../../runtime/infra/default-path-service.js";
-import { getTunableDefaults } from "../../runtime/config/tunable-defaults.js";
-import { clearTunableOverride, coerceTunableValue, readTunableOverrides, validateTunableUpdate, writeTunableOverride, } from "../tunable-store.js";
-/** Keys whose values must never be echoed back to the model verbatim. */
-const SECRET_KEY_RE = /apikey|api_key|secret|token|password/i;
-function maskIfSecret(key, value) {
-    if (!SECRET_KEY_RE.test(key))
-        return value;
-    return typeof value === "string" && value.length > 0 ? "(set, hidden)" : value;
-}
-function tunableType(value) {
-    if (typeof value === "boolean")
-        return "boolean";
-    if (typeof value === "number")
-        return "number";
-    return "string";
-}
-export function createConfigToolService(options = {}) {
-    const settingsPath = options.settingsPath ?? getDefaultPathService().getUserSettingsPath();
-    const buildSetting = (key) => {
-        const defaults = getTunableDefaults();
-        if (!(key in defaults))
-            return null;
-        const overrides = readTunableOverrides(settingsPath);
-        const overridden = key in overrides;
-        const value = overridden ? overrides[key] : defaults[key];
-        return {
-            key,
-            value: maskIfSecret(key, value),
-            type: tunableType(defaults[key]),
-            description: overridden ? `overridden (default: ${JSON.stringify(maskIfSecret(key, defaults[key]))})` : "default",
-        };
-    };
-    return {
-        getConfig: async (key) => {
-            const setting = buildSetting(key);
-            if (!setting) {
-                return { success: false, error: `Unknown tunable key: "${key}". Use action='list' to see all keys.` };
-            }
-            return { success: true, setting };
-        },
-        setConfig: async (key, value) => {
-            const prev = buildSetting(key);
-            const coerced = coerceTunableValue(key, value);
-            const error = validateTunableUpdate(key, coerced);
-            if (error)
-                return { success: false, error };
-            await writeTunableOverride(settingsPath, key, coerced);
-            return {
-                success: true,
-                previousValue: prev?.value,
-                setting: buildSetting(key) ?? undefined,
-            };
-        },
-        listConfig: async () => {
-            const defaults = getTunableDefaults();
-            const overrides = readTunableOverrides(settingsPath);
-            const settings = Object.keys(defaults).map((key) => {
-                const overridden = key in overrides;
-                const value = overridden ? overrides[key] : defaults[key];
-                return {
-                    key,
-                    value: maskIfSecret(key, value),
-                    type: tunableType(defaults[key]),
-                    description: overridden ? "overridden" : "default",
-                };
-            });
-            return { success: true, settings };
-        },
-        resetConfig: async (key) => {
-            const defaults = getTunableDefaults();
-            if (!(key in defaults)) {
-                return { success: false, error: `Unknown tunable key: "${key}".` };
-            }
-            await clearTunableOverride(settingsPath, key);
-            return { success: true, setting: buildSetting(key) ?? undefined };
-        },
-        isValidKey: (key) => key in getTunableDefaults(),
-    };
-}

package/dist/cli/core-tools/config-tool-service.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/core-tools/config-tool-service.test.js

@@ -1,69 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { getTunableDefaults } from "../../runtime/config/tunable-defaults.js";
-import { createConfigToolService } from "./config-tool-service.js";
-const tmpRoots = [];
-function tempSettingsPath() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "qlogicagent-config-tool-"));
-    tmpRoots.push(dir);
-    return path.join(dir, "settings.json");
-}
-afterEach(() => {
-    for (const root of tmpRoots.splice(0)) {
-        fs.rmSync(root, { recursive: true, force: true });
-    }
-});
-describe("config tool service (tunables-backed)", () => {
-    it("lists the REAL tunables, not a toy namespace", async () => {
-        const svc = createConfigToolService({ settingsPath: tempSettingsPath() });
-        const r = await svc.listConfig();
-        const keys = (r.settings ?? []).map((s) => s.key);
-        expect(keys).toContain("defaultMaxRounds");
-        expect(keys).toContain("defaultTemperature");
-        expect(keys).toContain("teamBudgetTokens");
-        expect(keys.length).toBe(Object.keys(getTunableDefaults()).length);
-        // The old fake namespace must be gone.
-        expect(keys).not.toContain("theme");
-        expect(keys).not.toContain("language");
-    });
-    it("set persists to settings.tunables.* — the store getTunable() re-reads (hot)", async () => {
-        const settingsPath = tempSettingsPath();
-        const svc = createConfigToolService({ settingsPath });
-        const r = await svc.setConfig("defaultMaxRounds", 40);
-        expect(r.success).toBe(true);
-        // On-disk shape is exactly what ModelRegistry.getTunable re-reads per call.
-        const raw = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-        expect(raw.tunables?.defaultMaxRounds).toBe(40);
-        const got = await svc.getConfig("defaultMaxRounds");
-        expect(got.setting?.value).toBe(40);
-        expect(got.setting?.description).toContain("overridden");
-    });
-    it("coerces numeric strings before validating", async () => {
-        const settingsPath = tempSettingsPath();
-        const svc = createConfigToolService({ settingsPath });
-        const r = await svc.setConfig("defaultMaxRounds", "35");
-        expect(r.success).toBe(true);
-        const raw = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-        expect(raw.tunables?.defaultMaxRounds).toBe(35);
-    });
-    it("rejects unknown keys and type mismatches (fail-loud, same rules as the RPC)", async () => {
-        const svc = createConfigToolService({ settingsPath: tempSettingsPath() });
-        const unknown = await svc.setConfig("theme", "dark");
-        expect(unknown.success).toBe(false);
-        const badType = await svc.setConfig("defaultMaxRounds", "not-a-number");
-        expect(badType.success).toBe(false);
-        expect(badType.error).toContain("expected number");
-    });
-    it("reset removes the override and falls back to the default", async () => {
-        const settingsPath = tempSettingsPath();
-        const svc = createConfigToolService({ settingsPath });
-        await svc.setConfig("defaultMaxRounds", 40);
-        const r = await svc.resetConfig("defaultMaxRounds");
-        expect(r.success).toBe(true);
-        expect(r.setting?.value).toBe(getTunableDefaults().defaultMaxRounds);
-        const raw = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-        expect(raw.tunables && "defaultMaxRounds" in raw.tunables).toBe(false);
-    });
-});

package/dist/cli/core-tools/cron-tool-bootstrap.d.ts

@@ -1,8 +0,0 @@
-import type { ToolCatalog } from "../../runtime/ports/index.js";
-export interface CronToolRegistrationDeps {
-    toolCatalog: ToolCatalog;
-    host: {
-        getActiveProjectRoot(): string;
-    };
-}
-export declare function registerCronTool({ host, toolCatalog }: CronToolRegistrationDeps): void;

package/dist/cli/core-tools/cron-tool-bootstrap.js

@@ -1,8 +0,0 @@
-import { createCronTool } from "../../skills/tools/cron-tool.js";
-import { createCronWorkflowService } from "./cron-workflow-service.js";
-export function registerCronTool({ host, toolCatalog }) {
-    const service = createCronWorkflowService({
-        getProjectRoot: () => host.getActiveProjectRoot(),
-    });
-    toolCatalog.addTool(createCronTool(service));
-}

package/dist/cli/core-tools/cron-workflow-service.d.ts

@@ -1,7 +0,0 @@
-import type { CronToolDeps } from "../../skills/tools/cron-tool.js";
-export interface CronWorkflowServiceOptions {
-    getProjectRoot(): string;
-    idFactory?: () => string;
-}
-export type CronWorkflowService = CronToolDeps;
-export declare function createCronWorkflowService(options: CronWorkflowServiceOptions): CronWorkflowService;

package/dist/cli/core-tools/cron-workflow-service.js

@@ -1,206 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { WorkflowController } from "../../orchestration/workflow/workflow-controller.js";
-import { getWorkflowController } from "../../orchestration/workflow/workflow-service.js";
-import { WorkflowStore } from "../../orchestration/workflow/workflow-store.js";
-import { validateCron } from "../../orchestration/workflow/trigger-validation.js";
-const authoringOnlyFactory = () => {
-    throw new Error("cron workflow service: running requires the initialized workflow engine");
-};
-export function createCronWorkflowService(options) {
-    const idFactory = options.idFactory ?? (() => randomUUID().slice(0, 8));
-    function resolve() {
-        const store = new WorkflowStore(options.getProjectRoot());
-        const live = getWorkflowController();
-        const controller = new WorkflowController(store, authoringOnlyFactory);
-        return { controller, live, store };
-    }
-    return {
-        async createJob(params) {
-            const unsupported = unsupportedCronFields(params);
-            if (unsupported)
-                return unsupported;
-            const schedule = normalizeSchedule(params.schedule);
-            const scheduleError = validateSchedule(schedule);
-            if (scheduleError)
-                return { success: false, error: scheduleError };
-            const id = `cron_${idFactory().slice(0, 8)}`;
-            const name = params.name ?? `Scheduled task ${id}`;
-            const def = buildPromptWorkflowDef(id, params.prompt);
-            const { controller, store } = resolve();
-            try {
-                await controller.create({ id, name, def, active: false, concurrency: "queue" });
-                await controller.patch(id, {
-                    patch: [{ op: "set_trigger", trigger: { type: "schedule", cron: schedule } }],
-                });
-                // D31: the agent-built def IS the intended running version — publish, then activate
-                // (cron fires execute the published snapshot; activation requires one).
-                await controller.publish(id);
-                await controller.patch(id, {
-                    patch: [{ op: "set_meta", meta: { active: true } }],
-                });
-                const record = await store.require(id);
-                return { success: true, job: toCronJob(record) };
-            }
-            catch (err) {
-                await store.delete(id);
-                throw err;
-            }
-        },
-        async listJobs() {
-            const jobs = (await resolve().store.list())
-                .filter(isScheduleWorkflow)
-                .map((record) => toCronJob(record));
-            return { success: true, jobs };
-        },
-        async getJob(jobId) {
-            const record = await loadScheduleWorkflow(resolve().store, jobId);
-            if (!record)
-                return { success: false, error: `Scheduled workflow not found: ${jobId}` };
-            return { success: true, job: toCronJob(record) };
-        },
-        async updateJob(jobId, updates) {
-            const unsupported = unsupportedCronFields(updates);
-            if (unsupported)
-                return unsupported;
-            const { controller, store } = resolve();
-            const record = await loadScheduleWorkflow(store, jobId);
-            if (!record)
-                return { success: false, error: `Scheduled workflow not found: ${jobId}` };
-            const patch = [];
-            let def;
-            let name;
-            if (updates.prompt !== undefined)
-                def = withPrompt(record.def, updates.prompt);
-            if (updates.name !== undefined)
-                name = updates.name;
-            if (updates.schedule !== undefined) {
-                const schedule = normalizeSchedule(updates.schedule);
-                const scheduleError = validateSchedule(schedule);
-                if (scheduleError)
-                    return { success: false, error: scheduleError };
-                patch.push({ op: "set_trigger", trigger: { type: "schedule", cron: schedule } });
-            }
-            if (updates.enabled !== undefined) {
-                patch.push({ op: "set_meta", meta: { active: updates.enabled } });
-            }
-            if (def || name !== undefined)
-                await controller.update(jobId, { def, name });
-            if (patch.length > 0)
-                await controller.patch(jobId, { patch });
-            return { success: true, job: toCronJob(await store.require(jobId)) };
-        },
-        async deleteJob(jobId) {
-            const { store } = resolve();
-            const record = await loadScheduleWorkflow(store, jobId);
-            if (!record)
-                return { success: false, error: `Scheduled workflow not found: ${jobId}` };
-            await store.delete(jobId);
-            return { success: true };
-        },
-        async pauseJob(jobId) {
-            const { controller, store } = resolve();
-            const record = await loadScheduleWorkflow(store, jobId);
-            if (!record)
-                return { success: false, error: `Scheduled workflow not found: ${jobId}` };
-            return { success: true, job: toCronJob(await controller.setActive(jobId, false)) };
-        },
-        async resumeJob(jobId) {
-            const { controller, store } = resolve();
-            const record = await loadScheduleWorkflow(store, jobId);
-            if (!record)
-                return { success: false, error: `Scheduled workflow not found: ${jobId}` };
-            return { success: true, job: toCronJob(await controller.setActive(jobId, true)) };
-        },
-        async triggerJob(jobId) {
-            const { live, store } = resolve();
-            const record = await loadScheduleWorkflow(store, jobId);
-            if (!record)
-                return { success: false, error: `Scheduled workflow not found: ${jobId}` };
-            if (!live) {
-                throw new Error("cron trigger requires the initialized workflow engine; activate/run from the app host");
-            }
-            const trigger = { type: "manual", payload: { source: "cron.trigger" } };
-            const outcome = await live.run(jobId, trigger);
-            return { success: true, job: toCronJob(record, outcome.status === "completed" ? "success" : "error") };
-        },
-        validateSchedule(schedule) {
-            return validateSchedule(normalizeSchedule(schedule));
-        },
-    };
-}
-function buildPromptWorkflowDef(id, prompt) {
-    return {
-        id,
-        nodes: [
-            { id: "trigger", kind: "trigger", name: "Schedule trigger" },
-            { id: "agent", kind: "agent", name: "Run prompt", params: { prompt } },
-        ],
-        edges: [{ from: "trigger", to: "agent" }],
-    };
-}
-function withPrompt(def, prompt) {
-    const nodes = def.nodes.map((node) => {
-        if (node.kind !== "agent")
-            return node;
-        return { ...node, params: { ...(node.params ?? {}), prompt } };
-    });
-    if (!nodes.some((node) => node.kind === "agent")) {
-        throw new Error(`Scheduled workflow "${def.id}" has no agent node to update`);
-    }
-    return { ...def, nodes };
-}
-function promptOf(def) {
-    const node = def.nodes.find((candidate) => candidate.kind === "agent");
-    const prompt = node?.params?.prompt;
-    return typeof prompt === "string" ? prompt : "";
-}
-function normalizeSchedule(schedule) {
-    const trimmed = schedule.trim();
-    const shorthand = /^(\d+)([smhd])$/.exec(trimmed);
-    if (!shorthand)
-        return trimmed;
-    const amount = Number(shorthand[1]);
-    const unit = shorthand[2];
-    if (!Number.isInteger(amount) || amount <= 0)
-        return trimmed;
-    switch (unit) {
-        case "s": return `*/${amount} * * * * *`;
-        case "m": return `*/${amount} * * * *`;
-        case "h": return `0 */${amount} * * *`;
-        case "d": return `0 0 */${amount} * *`;
-        default: return trimmed;
-    }
-}
-function validateSchedule(schedule) {
-    const errors = validateCron(schedule);
-    return errors.length === 0 ? null : errors.join("; ");
-}
-function isScheduleWorkflow(record) {
-    return record.trigger?.type === "schedule";
-}
-async function loadScheduleWorkflow(store, id) {
-    const record = await store.load(id);
-    return record && isScheduleWorkflow(record) ? record : undefined;
-}
-function toCronJob(record, lastStatus = null) {
-    const schedule = record.trigger?.type === "schedule" ? record.trigger.cron : "";
-    return {
-        id: record.id,
-        name: record.name,
-        prompt: promptOf(record.def),
-        schedule,
-        scheduleDisplay: schedule,
-        state: record.active ? "scheduled" : "paused",
-        enabled: record.active,
-        lastStatus,
-    };
-}
-function unsupportedCronFields(input) {
-    if (input.repeat !== undefined && input.repeat !== null) {
-        return { success: false, error: "repeat is not a cron-layer field in the unified workflow scheduler; model finite repeats inside the workflow graph" };
-    }
-    if (input.allowedTools !== undefined && input.allowedTools.length > 0) {
-        return { success: false, error: "allowedTools is not a cron-layer field in the unified workflow scheduler; enforce tool access through permission rules or workflow nodes" };
-    }
-    return null;
-}

package/dist/cli/core-tools/cron-workflow-service.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/core-tools/cron-workflow-service.test.js

@@ -1,78 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { afterEach, describe, expect, it } from "vitest";
-import { WorkflowStore } from "../../orchestration/workflow/workflow-store.js";
-import { createCronWorkflowService } from "./cron-workflow-service.js";
-const cleanup = [];
-async function createWorkspace() {
-    const dir = await mkdtemp(join(tmpdir(), "qla-cron-workflow-"));
-    cleanup.push(dir);
-    return dir;
-}
-afterEach(async () => {
-    await Promise.all(cleanup.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
-});
-describe("cron workflow service", () => {
-    it("creates active schedule workflows instead of independent cron jobs", async () => {
-        const workspace = await createWorkspace();
-        const service = createCronWorkflowService({
-            getProjectRoot: () => workspace,
-            idFactory: () => "abc12345",
-        });
-        const created = await service.createJob({
-            prompt: "ship the release",
-            schedule: "5m",
-            name: "Release",
-        });
-        const storeRecord = await new WorkflowStore(workspace).require("cron_abc12345");
-        expect(created.success).toBe(true);
-        expect(created.job).toMatchObject({
-            id: "cron_abc12345",
-            name: "Release",
-            prompt: "ship the release",
-            schedule: "*/5 * * * *",
-            state: "scheduled",
-            enabled: true,
-        });
-        expect(created.job).not.toHaveProperty("repeat");
-        expect(storeRecord.active).toBe(true);
-        expect(storeRecord.trigger).toEqual({ type: "schedule", cron: "*/5 * * * *" });
-        expect(storeRecord.def.nodes.find((node) => node.kind === "agent")?.params).toMatchObject({
-            prompt: "ship the release",
-        });
-    });
-    it("lists, updates, pauses, resumes, and deletes schedule workflows through the workflow store", async () => {
-        const workspace = await createWorkspace();
-        const service = createCronWorkflowService({
-            getProjectRoot: () => workspace,
-            idFactory: () => "abc12345",
-        });
-        await service.createJob({ prompt: "first", schedule: "0 9 * * *", name: "Morning" });
-        expect((await service.listJobs()).jobs).toHaveLength(1);
-        const updated = await service.updateJob("cron_abc12345", {
-            prompt: "second",
-            schedule: "1h",
-            name: "Hourly",
-        });
-        expect(updated.job).toMatchObject({
-            name: "Hourly",
-            prompt: "second",
-            schedule: "0 */1 * * *",
-        });
-        expect((await service.pauseJob("cron_abc12345")).job?.state).toBe("paused");
-        expect((await service.resumeJob("cron_abc12345")).job?.state).toBe("scheduled");
-        expect((await service.deleteJob("cron_abc12345")).success).toBe(true);
-        expect((await service.listJobs()).jobs).toEqual([]);
-    });
-    it("rejects legacy cron-only fields instead of silently pretending they are enforced", async () => {
-        const workspace = await createWorkspace();
-        const service = createCronWorkflowService({ getProjectRoot: () => workspace });
-        const repeat = await service.createJob({ prompt: "x", schedule: "5m", repeat: 2 });
-        const allowedTools = await service.createJob({ prompt: "x", schedule: "5m", allowedTools: ["read"] });
-        expect(repeat).toMatchObject({ success: false });
-        expect(repeat.error).toContain("repeat is not a cron-layer field");
-        expect(allowedTools).toMatchObject({ success: false });
-        expect(allowedTools.error).toContain("allowedTools is not a cron-layer field");
-    });
-});

package/dist/cli/core-tools/fork-system-prompt.d.ts

@@ -1,45 +0,0 @@
-/**
- * Subagent system-prompt assembly.
- *
- * A forked subagent starts FRESH (no parent conversation by default), but it
- * still needs three things the parent has, injected by policy:
- *   1. Persona — who it is and how it should behave (agent definition).
- *   2. Project rules — the same .qlogicagent/rules + AGENTS.md the parent loads.
- *   3. Memory — the lightweight memory INDEX (user preferences / project facts).
- *
- * Without these the subagent produces off-convention work and ignores standing
- * user/project context. This mirrors Claude Code's "compose a delegation
- * message" model: the brief is the prompt, the standing context is injected here.
- */
-import type { HookRegistry } from "../../contracts/hooks.js";
-import type { AgentDefinition } from "../../orchestration/subagent/agent-registry.js";
-export interface SubagentSystemPromptInput {
-    /** Behavioral framing — who the subagent is and how it should act. */
-    persona: string;
-    /** Project root, for loading rules/AGENTS (only when includeRules). */
-    cwd?: string;
-    /** Hook registry (instruction loader uses it). */
-    hooks?: HookRegistry;
-    /** Lightweight memory INDEX block (memdir.getIndexForPrompt()), or null. */
-    memoryIndex: string | null;
-    /**
-     * Inject project rules / AGENTS. True for the in-process fork (it has no turn
-     * pipeline of its own). False for a subprocess team member, which assembles its
-     * own rules from its worktree — skip to avoid duplicating them.
-     */
-    includeRules?: boolean;
-}
-/** Build the persona section for a built-in fork agent (type + behavioral suffix). */
-export declare function personaForAgentDefinition(agentDef: AgentDefinition): string;
-/** Build the persona section for a team member (name + role + coordination note). */
-export declare function personaForTeamMember(name: string, role: string): string;
-/**
- * Shared subagent context assembly — used by BOTH the in-process fork (agent tool)
- * and the subprocess team member, so their standing context is identical:
- *   1. persona   — who the subagent is / how it behaves (caller-supplied)
- *   2. project rules / AGENTS — the same getInstructions the parent loads
- *   3. memory    — the lightweight memdir INDEX (preferences / project facts)
- *
- * Returns undefined when there is genuinely nothing to inject.
- */
-export declare function buildSubagentSystemPrompt(input: SubagentSystemPromptInput): Promise<string | undefined>;

package/dist/cli/core-tools/fork-system-prompt.js

@@ -1,66 +0,0 @@
-/**
- * Subagent system-prompt assembly.
- *
- * A forked subagent starts FRESH (no parent conversation by default), but it
- * still needs three things the parent has, injected by policy:
- *   1. Persona — who it is and how it should behave (agent definition).
- *   2. Project rules — the same .qlogicagent/rules + AGENTS.md the parent loads.
- *   3. Memory — the lightweight memory INDEX (user preferences / project facts).
- *
- * Without these the subagent produces off-convention work and ignores standing
- * user/project context. This mirrors Claude Code's "compose a delegation
- * message" model: the brief is the prompt, the standing context is injected here.
- */
-import { getInstructions, buildInstructionsPrompt } from "../../runtime/prompt/instruction-loader.js";
-/** Base delegation framing shared by every subagent persona. */
-const DELEGATION_FRAMING = [
-    "You were delegated a focused task. Work autonomously and return a concise,",
-    "self-contained final answer covering exactly what was asked — the delegating agent",
-    "only sees your final response, not your intermediate steps.",
-].join("\n");
-/** Build the persona section for a built-in fork agent (type + behavioral suffix). */
-export function personaForAgentDefinition(agentDef) {
-    const lines = [`You are the "${agentDef.name}" sub-agent. ${agentDef.description}`, DELEGATION_FRAMING];
-    if (agentDef.systemPromptSuffix?.trim())
-        lines.push("", agentDef.systemPromptSuffix.trim());
-    return lines.join("\n");
-}
-/** Build the persona section for a team member (name + role + coordination note). */
-export function personaForTeamMember(name, role) {
-    return [
-        `You are the "${name}" team member. Role: ${role}.`,
-        DELEGATION_FRAMING,
-        "You are part of a team. Inbound teammate messages arrive as tasks; answer them directly — your reply is delivered back to the sender automatically.",
-    ].join("\n");
-}
-/**
- * Shared subagent context assembly — used by BOTH the in-process fork (agent tool)
- * and the subprocess team member, so their standing context is identical:
- *   1. persona   — who the subagent is / how it behaves (caller-supplied)
- *   2. project rules / AGENTS — the same getInstructions the parent loads
- *   3. memory    — the lightweight memdir INDEX (preferences / project facts)
- *
- * Returns undefined when there is genuinely nothing to inject.
- */
-export async function buildSubagentSystemPrompt(input) {
-    const { persona, cwd, hooks, memoryIndex, includeRules = true } = input;
-    const sections = [persona.trim()];
-    // 2. Project rules / AGENTS — same source the parent agent loads.
-    if (includeRules && cwd) {
-        try {
-            const files = await getInstructions(cwd, hooks);
-            const block = files.length ? buildInstructionsPrompt(files) : "";
-            if (block.trim())
-                sections.push(block.trim());
-        }
-        catch {
-            // Non-fatal: a subagent without rules is degraded, not broken.
-        }
-    }
-    // 3. Memory INDEX — lightweight standing context (preferences / project facts).
-    if (memoryIndex?.trim()) {
-        sections.push(["## Your Memory (project-level notes — always visible)", "", memoryIndex.trim()].join("\n"));
-    }
-    const out = sections.filter(Boolean).join("\n\n").trim();
-    return out.length > 0 ? out : undefined;
-}

package/dist/cli/core-tools/fork-system-prompt.test.d.ts

@@ -1 +0,0 @@
-export {};