@workflow-cannon/workspace-kit 0.17.0 → 0.24.0

package/dist/modules/agent-behavior/index.js

@@ -0,0 +1,461 @@
+export { BUILTIN_PROFILES, DEFAULT_BUILTIN_PROFILE_ID } from "./builtins.js";
+export { validateBehaviorProfile, mergeDimensions } from "./validate.js";
+import { BUILTIN_PROFILES, DEFAULT_BUILTIN_PROFILE_ID } from "./builtins.js";
+import { diffProfiles, summarizeProfileMarkdown } from "./explain.js";
+import { buildDraftProfileFromInterview, INTERVIEW_QUESTIONS, dimensionsFromAnswers } from "./interview.js";
+import { clearBehaviorInterviewSession, persistBehaviorInterviewSession, readBehaviorInterviewSession } from "./interview-session-file.js";
+import { loadBehaviorWorkspaceState, saveBehaviorWorkspaceState } from "./persistence.js";
+import { BehaviorProfileStore, materializeCustomFromBase } from "./store.js";
+import { mergeDimensions, validateBehaviorProfile } from "./validate.js";
+async function withStore(ctx, fn) {
+    const raw = await loadBehaviorWorkspaceState(ctx);
+    const store = new BehaviorProfileStore(raw);
+    const result = await fn(store);
+    if (result.ok) {
+        await saveBehaviorWorkspaceState(ctx, store.getState());
+    }
+    return result;
+}
+export const agentBehaviorModule = {
+    registration: {
+        id: "agent-behavior",
+        version: "0.1.0",
+        contractVersion: "1",
+        stateSchema: 1,
+        capabilities: ["agent-behavior"],
+        dependsOn: [],
+        optionalPeers: [],
+        enabledByDefault: true,
+        config: {
+            path: "src/modules/agent-behavior/config.md",
+            format: "md",
+            description: "Advisory agent interaction profiles (soft layer; subordinate to PRINCIPLES and policy)."
+        },
+        instructions: {
+            directory: "src/modules/agent-behavior/instructions",
+            entries: [
+                { name: "list-behavior-profiles", file: "list-behavior-profiles.md", description: "List builtin and custom behavior profile ids." },
+                { name: "get-behavior-profile", file: "get-behavior-profile.md", description: "Get one behavior profile by id (resolved)." },
+                { name: "resolve-behavior-profile", file: "resolve-behavior-profile.md", description: "Effective profile + provenance for the workspace." },
+                { name: "set-active-behavior-profile", file: "set-active-behavior-profile.md", description: "Set or clear the workspace active behavior profile." },
+                { name: "create-behavior-profile", file: "create-behavior-profile.md", description: "Create a custom profile, optionally forked from a base." },
+                { name: "update-behavior-profile", file: "update-behavior-profile.md", description: "Patch a custom behavior profile." },
+                { name: "delete-behavior-profile", file: "delete-behavior-profile.md", description: "Delete a custom behavior profile." },
+                { name: "diff-behavior-profiles", file: "diff-behavior-profiles.md", description: "Structured diff of two profiles." },
+                { name: "explain-behavior-profiles", file: "explain-behavior-profiles.md", description: "Deterministic markdown summary or compare." },
+                { name: "interview-behavior-profile", file: "interview-behavior-profile.md", description: "Guided interview to draft a custom profile." }
+            ]
+        }
+    },
+    async onCommand(command, ctx) {
+        const args = command.args ?? {};
+        const name = command.name;
+        if (name === "list-behavior-profiles") {
+            const raw = await loadBehaviorWorkspaceState(ctx);
+            const store = new BehaviorProfileStore(raw);
+            return {
+                ok: true,
+                code: "behavior-profiles-listed",
+                data: { profiles: store.listIds(), scope: "agent-behavior" }
+            };
+        }
+        if (name === "get-behavior-profile") {
+            const profileId = typeof args.profileId === "string" ? args.profileId.trim() : "";
+            if (!profileId) {
+                return { ok: false, code: "invalid-args", message: "get-behavior-profile requires profileId" };
+            }
+            const raw = await loadBehaviorWorkspaceState(ctx);
+            const store = new BehaviorProfileStore(raw);
+            const resolved = store.resolveProfile(profileId);
+            if (!resolved) {
+                return { ok: false, code: "profile-not-found", message: `Profile '${profileId}' not found` };
+            }
+            return {
+                ok: true,
+                code: "behavior-profile-retrieved",
+                data: { profile: resolved }
+            };
+        }
+        if (name === "resolve-behavior-profile") {
+            const raw = await loadBehaviorWorkspaceState(ctx);
+            const store = new BehaviorProfileStore(raw);
+            const { effective, provenance } = store.resolveEffectiveWithProvenance();
+            return {
+                ok: true,
+                code: "behavior-profile-resolved",
+                data: {
+                    effective,
+                    provenance,
+                    schemaVersion: 1
+                }
+            };
+        }
+        if (name === "set-active-behavior-profile") {
+            return withStore(ctx, async (store) => {
+                const clear = args.clear === true;
+                const profileId = typeof args.profileId === "string" ? args.profileId.trim() : "";
+                if (!clear && !profileId) {
+                    return {
+                        ok: false,
+                        code: "invalid-args",
+                        message: "Provide profileId or clear:true"
+                    };
+                }
+                if (clear) {
+                    store.setActiveProfileId(null);
+                    return {
+                        ok: true,
+                        code: "behavior-active-cleared",
+                        message: "Active behavior profile cleared (fallback to default)",
+                        data: { activeProfileId: null }
+                    };
+                }
+                const resolved = store.resolveProfile(profileId);
+                if (!resolved) {
+                    return {
+                        ok: false,
+                        code: "profile-not-found",
+                        message: `Profile '${profileId}' not found`
+                    };
+                }
+                store.setActiveProfileId(profileId);
+                return {
+                    ok: true,
+                    code: "behavior-active-set",
+                    message: `Active behavior profile set to '${profileId}'`,
+                    data: { activeProfileId: profileId }
+                };
+            });
+        }
+        if (name === "create-behavior-profile") {
+            return withStore(ctx, async (store) => {
+                const newId = typeof args.id === "string" ? args.id.trim() : "";
+                if (!newId.startsWith("custom:") || newId.length < 9) {
+                    return {
+                        ok: false,
+                        code: "invalid-args",
+                        message: "create-behavior-profile requires id custom:<slug>"
+                    };
+                }
+                if (store.getRawProfile(newId)) {
+                    return { ok: false, code: "duplicate-profile-id", message: `Profile '${newId}' already exists` };
+                }
+                const baseId = typeof args.baseProfileId === "string" && args.baseProfileId.trim().length > 0
+                    ? args.baseProfileId.trim()
+                    : DEFAULT_BUILTIN_PROFILE_ID;
+                const dims = typeof args.dimensions === "object" && args.dimensions !== null && !Array.isArray(args.dimensions)
+                    ? args.dimensions
+                    : undefined;
+                const partialDims = dims
+                    ? {
+                        deliberationDepth: dims.deliberationDepth,
+                        changeAppetite: dims.changeAppetite,
+                        checkInFrequency: dims.checkInFrequency,
+                        explanationVerbosity: dims.explanationVerbosity,
+                        explorationStyle: dims.explorationStyle,
+                        ambiguityHandling: dims.ambiguityHandling
+                    }
+                    : undefined;
+                const mat = materializeCustomFromBase(baseId, store, newId, {
+                    label: typeof args.label === "string" ? args.label : undefined,
+                    summary: typeof args.summary === "string" ? args.summary : undefined,
+                    dimensions: partialDims,
+                    interactionNotes: typeof args.interactionNotes === "string" ? args.interactionNotes : undefined
+                });
+                if (!mat.ok) {
+                    return { ok: false, code: "invalid-profile", message: mat.message };
+                }
+                store.putCustomProfile(mat.profile);
+                return {
+                    ok: true,
+                    code: "behavior-profile-created",
+                    data: { profile: mat.profile }
+                };
+            });
+        }
+        if (name === "update-behavior-profile") {
+            return withStore(ctx, async (store) => {
+                const profileId = typeof args.profileId === "string" ? args.profileId.trim() : "";
+                if (!profileId.startsWith("custom:")) {
+                    return { ok: false, code: "invalid-args", message: "update-behavior-profile requires custom profileId" };
+                }
+                const existing = store.getRawProfile(profileId);
+                if (!existing || BUILTIN_PROFILES[profileId]) {
+                    return { ok: false, code: "profile-not-found", message: `Custom profile '${profileId}' not found` };
+                }
+                const updates = typeof args.updates === "object" && args.updates !== null ? args.updates : {};
+                const next = { ...existing };
+                if (typeof updates.label === "string")
+                    next.label = updates.label.trim();
+                if (typeof updates.summary === "string")
+                    next.summary = updates.summary.trim();
+                if (updates.dimensions && typeof updates.dimensions === "object" && !Array.isArray(updates.dimensions)) {
+                    next.dimensions = mergeDimensions(existing.dimensions, updates.dimensions);
+                }
+                if (updates.interactionNotes !== undefined) {
+                    next.interactionNotes =
+                        typeof updates.interactionNotes === "string" ? updates.interactionNotes.trim() : undefined;
+                }
+                next.metadata = {
+                    ...(existing.metadata ?? {}),
+                    updatedAt: new Date().toISOString()
+                };
+                const v = validateBehaviorProfile(next);
+                if (!v.ok) {
+                    return { ok: false, code: "invalid-profile", message: v.message };
+                }
+                store.putCustomProfile(v.profile);
+                return { ok: true, code: "behavior-profile-updated", data: { profile: v.profile } };
+            });
+        }
+        if (name === "delete-behavior-profile") {
+            return withStore(ctx, async (store) => {
+                const profileId = typeof args.profileId === "string" ? args.profileId.trim() : "";
+                if (!profileId.startsWith("custom:")) {
+                    return { ok: false, code: "invalid-args", message: "delete-behavior-profile requires custom profileId" };
+                }
+                if (BUILTIN_PROFILES[profileId]) {
+                    return { ok: false, code: "invalid-args", message: "Cannot delete builtin profile" };
+                }
+                if (!store.getRawProfile(profileId)) {
+                    return { ok: false, code: "profile-not-found", message: `Profile '${profileId}' not found` };
+                }
+                if (store.getActiveProfileId() === profileId) {
+                    return {
+                        ok: false,
+                        code: "profile-active",
+                        message: `Profile '${profileId}' is active; clear or change active before delete`
+                    };
+                }
+                store.deleteCustomProfile(profileId);
+                return { ok: true, code: "behavior-profile-deleted", data: { profileId } };
+            });
+        }
+        if (name === "diff-behavior-profiles") {
+            const a = typeof args.profileIdA === "string" ? args.profileIdA.trim() : "";
+            const b = typeof args.profileIdB === "string" ? args.profileIdB.trim() : "";
+            if (!a || !b) {
+                return { ok: false, code: "invalid-args", message: "diff-behavior-profiles requires profileIdA and profileIdB" };
+            }
+            const raw = await loadBehaviorWorkspaceState(ctx);
+            const store = new BehaviorProfileStore(raw);
+            const pa = store.resolveProfile(a);
+            const pb = store.resolveProfile(b);
+            if (!pa || !pb) {
+                return { ok: false, code: "profile-not-found", message: "One or both profiles not found" };
+            }
+            return {
+                ok: true,
+                code: "behavior-profiles-diffed",
+                data: { diff: diffProfiles(pa, pb), profileIdA: a, profileIdB: b }
+            };
+        }
+        if (name === "explain-behavior-profiles") {
+            const mode = typeof args.mode === "string" ? args.mode : "summarize";
+            const raw = await loadBehaviorWorkspaceState(ctx);
+            const store = new BehaviorProfileStore(raw);
+            if (mode === "compare") {
+                const ids = Array.isArray(args.profileIds) ? args.profileIds.filter((x) => typeof x === "string") : [];
+                if (ids.length < 2) {
+                    return {
+                        ok: false,
+                        code: "invalid-args",
+                        message: "compare mode requires profileIds array with at least two ids"
+                    };
+                }
+                const sections = [];
+                for (const id of ids) {
+                    const p = store.resolveProfile(id);
+                    if (!p) {
+                        return { ok: false, code: "profile-not-found", message: `Profile '${id}' not found` };
+                    }
+                    sections.push(summarizeProfileMarkdown(p));
+                }
+                return {
+                    ok: true,
+                    code: "behavior-profiles-explained",
+                    data: { mode: "compare", markdown: sections.join("\n\n---\n\n") }
+                };
+            }
+            const profileId = typeof args.profileId === "string" && args.profileId.trim().length > 0
+                ? args.profileId.trim()
+                : DEFAULT_BUILTIN_PROFILE_ID;
+            const p = store.resolveProfile(profileId);
+            if (!p) {
+                return { ok: false, code: "profile-not-found", message: `Profile '${profileId}' not found` };
+            }
+            return {
+                ok: true,
+                code: "behavior-profiles-explained",
+                data: { mode: "summarize", markdown: summarizeProfileMarkdown(p) }
+            };
+        }
+        if (name === "interview-behavior-profile") {
+            const action = typeof args.action === "string" ? args.action : "";
+            const ws = ctx.workspacePath;
+            if (action === "discard") {
+                await clearBehaviorInterviewSession(ws);
+                return { ok: true, code: "behavior-interview-discarded", data: {} };
+            }
+            if (action === "start") {
+                await persistBehaviorInterviewSession(ws, { stepIndex: 0, answers: {} });
+                const q = INTERVIEW_QUESTIONS[0];
+                return {
+                    ok: true,
+                    code: "behavior-interview-started",
+                    data: {
+                        stepIndex: 0,
+                        totalSteps: INTERVIEW_QUESTIONS.length,
+                        question: q,
+                        resumeCli: `workspace-kit run interview-behavior-profile '{"action":"answer","value":"<option>"}'`
+                    }
+                };
+            }
+            let session = await readBehaviorInterviewSession(ws);
+            if (!session && action === "answer") {
+                return {
+                    ok: false,
+                    code: "invalid-args",
+                    message: "No interview session; run action:start first"
+                };
+            }
+            if (action === "back") {
+                if (!session) {
+                    return { ok: false, code: "invalid-args", message: "No interview session" };
+                }
+                if (session.stepIndex <= 0) {
+                    return { ok: true, code: "behavior-interview-back", data: { stepIndex: 0, atStart: true } };
+                }
+                const prevIndex = session.stepIndex - 1;
+                const prevQ = INTERVIEW_QUESTIONS[prevIndex];
+                const nextAnswers = { ...session.answers };
+                delete nextAnswers[INTERVIEW_QUESTIONS[session.stepIndex - 1].id];
+                await persistBehaviorInterviewSession(ws, { stepIndex: prevIndex, answers: nextAnswers });
+                return {
+                    ok: true,
+                    code: "behavior-interview-back",
+                    data: {
+                        stepIndex: prevIndex,
+                        question: prevQ
+                    }
+                };
+            }
+            if (action === "answer") {
+                session = session ?? { schemaVersion: 1, updatedAt: "", stepIndex: 0, answers: {} };
+                const value = typeof args.value === "string" ? args.value.trim() : "";
+                const q = INTERVIEW_QUESTIONS[session.stepIndex];
+                if (!q) {
+                    return { ok: false, code: "invalid-state", message: "Interview already complete; use finalize" };
+                }
+                const allowed = new Set(q.options.map((o) => o.value));
+                if (!allowed.has(value)) {
+                    return {
+                        ok: false,
+                        code: "invalid-args",
+                        message: `Invalid value for step ${session.stepIndex}; choose one of: ${[...allowed].join(", ")}`
+                    };
+                }
+                const answers = { ...session.answers, [q.id]: value };
+                const nextIndex = session.stepIndex + 1;
+                await persistBehaviorInterviewSession(ws, { stepIndex: nextIndex, answers });
+                if (nextIndex >= INTERVIEW_QUESTIONS.length) {
+                    return {
+                        ok: true,
+                        code: "behavior-interview-complete",
+                        data: {
+                            stepIndex: nextIndex,
+                            complete: true,
+                            answers,
+                            next: "Run action:finalize with custom id and optional apply:true"
+                        }
+                    };
+                }
+                const nq = INTERVIEW_QUESTIONS[nextIndex];
+                return {
+                    ok: true,
+                    code: "behavior-interview-progress",
+                    data: {
+                        stepIndex: nextIndex,
+                        totalSteps: INTERVIEW_QUESTIONS.length,
+                        question: nq,
+                        answers
+                    }
+                };
+            }
+            if (action === "finalize") {
+                session = await readBehaviorInterviewSession(ws);
+                if (!session || session.stepIndex < INTERVIEW_QUESTIONS.length) {
+                    return {
+                        ok: false,
+                        code: "invalid-state",
+                        message: "Interview not complete; answer all questions first"
+                    };
+                }
+                const customId = typeof args.customId === "string" ? args.customId.trim() : "";
+                if (!customId.startsWith("custom:")) {
+                    return {
+                        ok: false,
+                        code: "invalid-args",
+                        message: "finalize requires customId (custom:<slug>)"
+                    };
+                }
+                const dims = dimensionsFromAnswers(session.answers);
+                if (!dims) {
+                    return { ok: false, code: "invalid-state", message: "Missing answers" };
+                }
+                let built;
+                try {
+                    built = buildDraftProfileFromInterview(session.answers, customId, typeof args.label === "string" ? args.label : undefined);
+                }
+                catch (e) {
+                    return { ok: false, code: "invalid-profile", message: e.message };
+                }
+                const vr = validateBehaviorProfile(built);
+                if (!vr.ok) {
+                    return { ok: false, code: "invalid-profile", message: vr.message };
+                }
+                const draft = vr.profile;
+                const apply = args.apply === true;
+                if (apply) {
+                    const persist = await withStore(ctx, async (store) => {
+                        if (store.getRawProfile(customId)) {
+                            return {
+                                ok: false,
+                                code: "duplicate-profile-id",
+                                message: `Profile '${customId}' already exists`
+                            };
+                        }
+                        store.putCustomProfile(draft);
+                        store.setActiveProfileId(customId);
+                        return { ok: true, code: "ok", data: { profile: draft, activeProfileId: customId } };
+                    });
+                    if (!persist.ok) {
+                        return persist;
+                    }
+                    await clearBehaviorInterviewSession(ws);
+                    return {
+                        ok: true,
+                        code: "behavior-interview-finalized",
+                        data: persist.data
+                    };
+                }
+                await clearBehaviorInterviewSession(ws);
+                return {
+                    ok: true,
+                    code: "behavior-interview-draft",
+                    data: { profile: draft, apply: false }
+                };
+            }
+            return {
+                ok: false,
+                code: "invalid-args",
+                message: "interview-behavior-profile requires action: start | answer | back | finalize | discard"
+            };
+        }
+        return {
+            ok: false,
+            code: "unknown-command",
+            message: `agent-behavior: unknown command '${name}'`
+        };
+    }
+};

package/dist/modules/agent-behavior/interview-session-file.d.ts

@@ -0,0 +1,9 @@
+export type BehaviorInterviewSessionV1 = {
+    schemaVersion: 1;
+    updatedAt: string;
+    stepIndex: number;
+    answers: Record<string, string>;
+};
+export declare function persistBehaviorInterviewSession(workspacePath: string, snapshot: Omit<BehaviorInterviewSessionV1, "schemaVersion" | "updatedAt">): Promise<void>;
+export declare function clearBehaviorInterviewSession(workspacePath: string): Promise<void>;
+export declare function readBehaviorInterviewSession(workspacePath: string): Promise<BehaviorInterviewSessionV1 | null>;

package/dist/modules/agent-behavior/interview-session-file.js

@@ -0,0 +1,43 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const REL_DIR = path.join(".workspace-kit", "agent-behavior");
+const FILE_NAME = "interview-session.json";
+function sessionPath(workspacePath) {
+    return path.join(workspacePath, REL_DIR, FILE_NAME);
+}
+export async function persistBehaviorInterviewSession(workspacePath, snapshot) {
+    const dir = path.join(workspacePath, REL_DIR);
+    await fs.mkdir(dir, { recursive: true });
+    const full = {
+        schemaVersion: 1,
+        updatedAt: new Date().toISOString(),
+        ...snapshot
+    };
+    await fs.writeFile(sessionPath(workspacePath), `${JSON.stringify(full, null, 2)}\n`, "utf8");
+}
+export async function clearBehaviorInterviewSession(workspacePath) {
+    try {
+        await fs.unlink(sessionPath(workspacePath));
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT")
+            throw err;
+    }
+}
+export async function readBehaviorInterviewSession(workspacePath) {
+    try {
+        const raw = await fs.readFile(sessionPath(workspacePath), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.schemaVersion !== 1)
+            return null;
+        if (typeof parsed.stepIndex !== "number")
+            return null;
+        if (!parsed.answers || typeof parsed.answers !== "object")
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/modules/agent-behavior/interview.d.ts

@@ -0,0 +1,13 @@
+import type { BehaviorDimensions, BehaviorProfile } from "./types.js";
+export declare const INTERVIEW_QUESTIONS: {
+    id: string;
+    prompt: string;
+    options: {
+        value: string;
+        label: string;
+    }[];
+}[];
+export declare function dimensionsFromAnswers(answers: Record<string, string>): BehaviorDimensions | null;
+export declare function buildDraftProfileFromInterview(answers: Record<string, string>, customId: string, label?: string): Omit<BehaviorProfile, "metadata"> & {
+    metadata?: Record<string, unknown>;
+};

package/dist/modules/agent-behavior/interview.js

@@ -0,0 +1,88 @@
+import { BEHAVIOR_PROFILE_SCHEMA_VERSION } from "./types.js";
+export const INTERVIEW_QUESTIONS = [
+    {
+        id: "changeAppetite",
+        prompt: "When suggesting code changes, how aggressive should the agent be?",
+        options: [
+            { value: "conservative", label: "Conservative — smallest diffs, extra caution" },
+            { value: "balanced", label: "Balanced — sensible defaults" },
+            { value: "bold", label: "Bold — willing to propose larger refactors when helpful" }
+        ]
+    },
+    {
+        id: "deliberationDepth",
+        prompt: "How much should the agent think out loud before acting?",
+        options: [
+            { value: "low", label: "Low — get to the point" },
+            { value: "medium", label: "Medium — short reasoning" },
+            { value: "high", label: "High — explicit tradeoffs and checks" }
+        ]
+    },
+    {
+        id: "explanationVerbosity",
+        prompt: "How verbose should explanations be?",
+        options: [
+            { value: "terse", label: "Terse" },
+            { value: "normal", label: "Normal" },
+            { value: "verbose", label: "Verbose — more context and structure" }
+        ]
+    },
+    {
+        id: "explorationStyle",
+        prompt: "When exploring solutions, prefer:",
+        options: [
+            { value: "linear", label: "Linear — one path at a time" },
+            { value: "parallel", label: "Parallel — briefly compare alternatives" }
+        ]
+    },
+    {
+        id: "ambiguityHandling",
+        prompt: "When requirements are ambiguous:",
+        options: [
+            { value: "ask", label: "Ask the user before assuming" },
+            { value: "decide", label: "Make a reasonable assumption and state it" }
+        ]
+    },
+    {
+        id: "checkInFrequency",
+        prompt: "How often should the agent pause for your confirmation on non-policy judgment calls?",
+        options: [
+            { value: "rare", label: "Rarely — only when high impact" },
+            { value: "normal", label: "Normal" },
+            { value: "often", label: "Often — prefer checkpoints" }
+        ]
+    }
+];
+export function dimensionsFromAnswers(answers) {
+    const keys = [
+        "changeAppetite",
+        "deliberationDepth",
+        "explanationVerbosity",
+        "explorationStyle",
+        "ambiguityHandling",
+        "checkInFrequency"
+    ];
+    const out = {};
+    for (const k of keys) {
+        const v = answers[k];
+        if (typeof v !== "string" || !v.length) {
+            return null;
+        }
+        out[k] = v;
+    }
+    return out;
+}
+export function buildDraftProfileFromInterview(answers, customId, label) {
+    const dimensions = dimensionsFromAnswers(answers);
+    if (!dimensions) {
+        throw new Error("Incomplete interview answers");
+    }
+    return {
+        schemaVersion: BEHAVIOR_PROFILE_SCHEMA_VERSION,
+        id: customId,
+        label: label?.trim() || "Interview profile",
+        summary: "Custom profile produced from interview-behavior-profile.",
+        dimensions,
+        metadata: { source: "interview", createdAt: new Date().toISOString() }
+    };
+}

package/dist/modules/agent-behavior/persistence.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleLifecycleContext } from "../../contracts/module-contract.js";
+import type { BehaviorWorkspaceStateV1 } from "./types.js";
+export declare function behaviorPersistenceMode(effectiveConfig: Record<string, unknown> | undefined): "json" | "sqlite";
+export declare function behaviorSqliteRelativePath(effectiveConfig: Record<string, unknown> | undefined): string;
+export declare function loadBehaviorWorkspaceState(ctx: ModuleLifecycleContext): Promise<BehaviorWorkspaceStateV1>;
+export declare function saveBehaviorWorkspaceState(ctx: ModuleLifecycleContext, state: BehaviorWorkspaceStateV1): Promise<void>;