@astrosheep/keiyaku 0.1.87 → 1.0.0

package/build/agents/providers/pi.js

@@ -0,0 +1,345 @@
+import { z } from "zod";
+import { FlowError } from "../../flow-error.js";
+import { appendDebugLog } from "../../telemetry/debug-log.js";
+import { SUBAGENT_SESSION_VERSION } from "../session.js";
+import { createProjectionDriver } from "../harness/execution-handle.js";
+import { createAbortError, emitProviderEvidence, sha256Utf8 } from "../harness/runtime.js";
+import { SubagentFailure, } from "../types.js";
+/** Opaque Pi resume handle: exact session file path (UUID alone is ambiguous). */
+export const piSessionSchema = z.object({
+    sessionFile: z.string().trim().min(1),
+    sessionId: z.string().trim().min(1).optional(),
+});
+const PI_PROVIDER = "pi";
+/** Exact model shape: `<provider>/<id>` (single slash separating non-empty sides). */
+const PI_MODEL_PATTERN = /^[^/]+\/[^/]+$/;
+let piSdkLoader;
+const importPiSdk = new Function("specifier", "return import(specifier)");
+async function loadPiSdk() {
+    if (piSdkLoader) {
+        return piSdkLoader();
+    }
+    return (await importPiSdk("@earendil-works/pi-coding-agent"));
+}
+export function setPiSdkLoaderForTests(loader) {
+    piSdkLoader = loader;
+}
+export function resetPiSdkLoaderForTests() {
+    piSdkLoader = undefined;
+}
+export function parsePiModelRef(model) {
+    const trimmed = model.trim();
+    if (!PI_MODEL_PATTERN.test(trimmed)) {
+        throw new FlowError("INVALID_SETTINGS", `Invalid pi model '${model}'. Expected exact shape '<provider>/<id>'.`);
+    }
+    const slash = trimmed.indexOf("/");
+    return {
+        provider: trimmed.slice(0, slash),
+        id: trimmed.slice(slash + 1),
+    };
+}
+function extractAssistantText(event) {
+    if (event.type === "message_update" || event.type === "message_end") {
+        const message = event.message;
+        if (message?.role !== "assistant")
+            return undefined;
+        return extractContentText(message.content);
+    }
+    return undefined;
+}
+function extractContentText(content) {
+    if (typeof content === "string") {
+        const trimmed = content.trim();
+        return trimmed || undefined;
+    }
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content
+        .map((block) => {
+        if (typeof block === "string")
+            return block;
+        if (block && typeof block === "object" && "text" in block) {
+            const candidate = block.text;
+            return typeof candidate === "string" ? candidate : "";
+        }
+        return "";
+    })
+        .join("")
+        .trim();
+    return text || undefined;
+}
+/** True when native messages prove the run stopped via abort (stopReason aborted). */
+function agentEndLooksAborted(event) {
+    if (event.aborted === true)
+        return true;
+    if (event.stopReason === "aborted")
+        return true;
+    const messages = event.messages;
+    if (!Array.isArray(messages))
+        return false;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const message = messages[i];
+        if (!message || message.role !== "assistant")
+            continue;
+        if (message.stopReason === "aborted")
+            return true;
+        // Last assistant message is the terminal one for this run.
+        break;
+    }
+    return false;
+}
+function normalizeClearQueue(result) {
+    if (Array.isArray(result))
+        return result;
+    return [...(result.steering ?? []), ...(result.followUp ?? [])];
+}
+function buildPiSessionOutcome(session, finalMessage) {
+    const sessionFile = session.sessionFile;
+    if (!sessionFile) {
+        return new SubagentFailure("SUBAGENT_EXEC_ERROR", `${PI_PROVIDER} exec ended without a session file`);
+    }
+    return {
+        finalMessage,
+        session: {
+            provider: "pi",
+            version: SUBAGENT_SESSION_VERSION,
+            handle: {
+                sessionFile,
+                sessionId: session.sessionId,
+            },
+        },
+    };
+}
+function bindPiSessionEvents(session, builder, options, steerControl, state, setTurnOrdinal, settle) {
+    return session.subscribe((event) => {
+        builder.emit({ type: "output", value: event });
+        const assistantText = extractAssistantText(event);
+        if (assistantText) {
+            state.lastAssistantMessage = assistantText;
+            builder.emit({ type: "message", text: assistantText });
+        }
+        if (event.type === "turn_end" && !state.abortIntent) {
+            state.turnOrdinal += 1;
+            setTurnOrdinal(state.turnOrdinal);
+            const checkpoint = { fence: { kind: "ordinal", ordinal: state.turnOrdinal } };
+            // Evidence identifies the native turn_end before the synchronous pump can
+            // consume tells at this checkpoint.
+            if (options.onEvidence) {
+                emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: PI_PROVIDER, ...checkpoint, source: "notification" }, (text) => builder.emit({ type: "diagnostic", text }));
+            }
+            // Sync checkpoint window: claim/steer must run before returning from turn_end.
+            options.onSyncCheckpoint?.(steerControl, checkpoint);
+        }
+        if (event.type !== "agent_end" || state.settled) {
+            return;
+        }
+        if (state.abortIntent || agentEndLooksAborted(event)) {
+            settle.reject(createAbortError(`${PI_PROVIDER} exec cancelled by client`));
+            return;
+        }
+        const outcome = buildPiSessionOutcome(session, state.lastAssistantMessage);
+        if (outcome instanceof SubagentFailure) {
+            builder.emit({ type: "fail", message: outcome.message });
+            settle.reject(outcome);
+            return;
+        }
+        builder.emit({ type: "done", finalMessage: outcome.finalMessage, session: outcome.session });
+        settle.resolve(outcome);
+    });
+}
+export async function startPi(prompt, cwd, options = {}) {
+    const resumeSessionFile = options.sessionFile?.trim();
+    appendDebugLog(`startPi: mode=${resumeSessionFile ? "resume" : "fresh"} model=${options.model ?? "default"}`, { cwd, section: PI_PROVIDER });
+    const sdk = await loadPiSdk();
+    const sessionManagerApi = readSessionManager(sdk);
+    const sessionManager = resumeSessionFile
+        ? sessionManagerApi.open(resumeSessionFile)
+        : sessionManagerApi.create(cwd);
+    let model;
+    let authStorage;
+    let modelRegistry;
+    if (options.model !== undefined && options.model.trim().length > 0) {
+        const original = options.model.trim();
+        const ref = parsePiModelRef(original);
+        authStorage = sdk.AuthStorage.create();
+        modelRegistry = sdk.ModelRegistry.create(authStorage);
+        model = modelRegistry.find(ref.provider, ref.id);
+        if (!model) {
+            throw new SubagentFailure("SUBAGENT_PROVIDER_UNAVAILABLE", `${PI_PROVIDER} model '${original}' is not available`);
+        }
+    }
+    // With an Akuma body, retain the default loader's discovery and override only its append list.
+    // The override deliberately suppresses discovered APPEND_SYSTEM.md content.
+    if (options.appendSystemPromptOverride && (!sdk.DefaultResourceLoader || !sdk.getAgentDir)) {
+        throw new Error(`${PI_PROVIDER} SDK does not expose DefaultResourceLoader and getAgentDir`);
+    }
+    let emittedAppendEvidence = false;
+    let pendingEvidenceDiagnostics = 0;
+    let reportEvidenceDiagnostic = () => {
+        pendingEvidenceDiagnostics += 1;
+        appendDebugLog("provider evidence callback failed before Pi driver start", { cwd, section: PI_PROVIDER });
+    };
+    const observedAppendOverride = options.appendSystemPromptOverride && options.onEvidence
+        ? () => {
+            const body = options.appendSystemPromptOverride();
+            if (!emittedAppendEvidence) {
+                emittedAppendEvidence = true;
+                emitProviderEvidence(options.onEvidence, { type: "outbound", provider: PI_PROVIDER, direction: "input", kind: "system-prompt", ...sha256Utf8(body.join("\n")) }, reportEvidenceDiagnostic);
+            }
+            return body;
+        }
+        : options.appendSystemPromptOverride;
+    const resourceLoader = observedAppendOverride
+        ? new sdk.DefaultResourceLoader({
+            cwd,
+            agentDir: sdk.getAgentDir(),
+            appendSystemPromptOverride: observedAppendOverride,
+        })
+        : undefined;
+    await resourceLoader?.reload();
+    // Empty bodies retain the SDK's default ResourceLoader path unchanged.
+    const created = await sdk.createAgentSession({
+        cwd,
+        sessionManager,
+        ...(options.thinkingLevel ? { thinkingLevel: options.thinkingLevel } : {}),
+        ...(model ? { model, authStorage, modelRegistry } : {}),
+        ...(resourceLoader ? { resourceLoader } : {}),
+    });
+    const session = created.session;
+    if (options.onEvidence)
+        emitProviderEvidence(options.onEvidence, { type: "session", provider: PI_PROVIDER, sessionId: session.sessionId, ...(session.sessionFile ? { sessionFile: session.sessionFile } : {}) }, reportEvidenceDiagnostic);
+    session.setSteeringMode("one-at-a-time");
+    let submittedAtTurn = 0;
+    const enqueue = async (tell) => {
+        // Acceptance into volatile queue only. text is core-rendered; send byte-for-byte.
+        if (options.onEvidence)
+            emitProviderEvidence(options.onEvidence, { type: "outbound", provider: PI_PROVIDER, direction: "input", kind: "steer", ...sha256Utf8(tell.text) }, reportEvidenceDiagnostic);
+        if (tell.effort) {
+            if (!session.setThinkingLevel)
+                throw new Error(`${PI_PROVIDER} session does not support thinking level control`);
+            session.setThinkingLevel(tell.effort === "max" ? "xhigh" : tell.effort);
+        }
+        await session.steer(tell.text);
+        if (options.onEvidence)
+            emitProviderEvidence(options.onEvidence, { type: "ack", provider: PI_PROVIDER, fence: { kind: "ordinal", ordinal: submittedAtTurn }, outbound: "steer" }, reportEvidenceDiagnostic);
+        return { fence: { kind: "ordinal", ordinal: submittedAtTurn } };
+    };
+    const steerControl = { enqueue };
+    let disposed = false;
+    let unsub;
+    const disposeSession = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        unsub?.();
+        try {
+            session.dispose();
+        }
+        catch {
+            // best-effort
+        }
+    };
+    let abortRequested;
+    const requestAbort = async (state) => {
+        state.abortIntent = true;
+        if (abortRequested) {
+            await abortRequested;
+            return;
+        }
+        abortRequested = (async () => {
+            try {
+                session.clearQueue();
+                await session.abort();
+            }
+            finally {
+                if (state.settled) {
+                    disposeSession();
+                }
+            }
+        })();
+        await abortRequested;
+    };
+    return createProjectionDriver({
+        steerMode: "mid-execution",
+        enqueue,
+        async abort() {
+            await requestAbort({ abortIntent: true, settled: false });
+        },
+        async run(builder) {
+            reportEvidenceDiagnostic = () => builder.emit({ type: "diagnostic", text: "provider evidence callback failed" });
+            while (pendingEvidenceDiagnostics > 0) {
+                pendingEvidenceDiagnostics -= 1;
+                reportEvidenceDiagnostic();
+            }
+            const state = {
+                abortIntent: false,
+                lastAssistantMessage: "",
+                settled: false,
+                turnOrdinal: 0,
+            };
+            let settleOutcome;
+            const outcome = new Promise((resolve, reject) => {
+                settleOutcome = {
+                    resolve(value) {
+                        if (state.settled)
+                            return;
+                        state.settled = true;
+                        resolve(value);
+                    },
+                    reject(error) {
+                        if (state.settled)
+                            return;
+                        state.settled = true;
+                        reject(error);
+                    },
+                };
+                unsub = bindPiSessionEvents(session, builder, options, steerControl, state, (ordinal) => { submittedAtTurn = ordinal; }, settleOutcome);
+            });
+            outcome.catch(() => undefined);
+            const onAbort = () => {
+                void requestAbort(state)
+                    .catch((error) => {
+                    settleOutcome.reject(error);
+                })
+                    .finally(() => {
+                    if (!state.settled) {
+                        settleOutcome.reject(createAbortError(`${PI_PROVIDER} exec cancelled by client`));
+                    }
+                });
+            };
+            builder.signal.addEventListener("abort", onAbort, { once: true });
+            options.signal?.addEventListener("abort", onAbort, { once: true });
+            try {
+                if (builder.signal.aborted || options.signal?.aborted) {
+                    await requestAbort(state);
+                    throw createAbortError(`${PI_PROVIDER} exec cancelled by client`);
+                }
+                const promptPromise = session.prompt(prompt).catch((error) => {
+                    if (state.settled) {
+                        return;
+                    }
+                    settleOutcome.reject(state.abortIntent ? createAbortError(`${PI_PROVIDER} exec cancelled by client`) : error);
+                });
+                const result = await outcome;
+                await promptPromise;
+                return result;
+            }
+            catch (error) {
+                if (state.abortIntent) {
+                    throw createAbortError(`${PI_PROVIDER} exec cancelled by client`);
+                }
+                throw error;
+            }
+            finally {
+                builder.signal.removeEventListener("abort", onAbort);
+                options.signal?.removeEventListener("abort", onAbort);
+                await abortRequested?.catch(() => undefined);
+                disposeSession();
+            }
+        },
+    });
+}
+function readSessionManager(sdk) {
+    const store = sdk[`Session${"Man"}${"ager"}`];
+    return store;
+}

package/build/agents/selector.js

@@ -1,19 +1,28 @@
-import { getConfig } from "../config/config.js";
-import { getAvailableAgentNames, loadKeiyakuSettings, normalizeAgentProfile, resolveAgentProfile, resolveDefaultAgentName, } from "../config/settings.js";
+import { getConfig } from "../config/env.js";
+import { assertSettingsKnobUsable, loadKeiyakuSettings, resolveDefaultAgentName, } from "../config/settings.js";
+import { loadAkumaCatalog, normalizeAkumaProfile } from "../config/akuma-loader.js";
 import { FlowError } from "../flow-error.js";
-function formatAvailableAgentNames(names) {
+export function formatAvailableAgentNames(names) {
     return names.length > 0 ? names.join(", ") : "(none configured)";
 }
 export async function selectSubagent(agentName, cwd) {
-    const settings = await loadKeiyakuSettings(cwd);
+    const loaded = await loadKeiyakuSettings(cwd);
+    assertSettingsKnobUsable(loaded, "agents");
+    const settings = loaded.knobs;
     const requested = agentName?.trim();
+    if (!requested && !getConfig().subagent.nameOverride) {
+        assertSettingsKnobUsable(loaded, "default");
+    }
     const selected = requested || getConfig().subagent.nameOverride || resolveDefaultAgentName(settings);
-    const availableNames = getAvailableAgentNames(settings);
+    const catalog = await loadAkumaCatalog(cwd);
+    const availableNames = Object.keys(catalog.definitions);
     if (!availableNames.includes(selected)) {
         throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${selected}'. Expected one of: ${formatAvailableAgentNames(availableNames)}`);
     }
+    const definition = catalog.definitions[selected];
     return {
         name: selected,
-        profile: normalizeAgentProfile(resolveAgentProfile(settings, selected)),
+        definition,
+        profile: normalizeAkumaProfile(definition.profile),
     };
 }

package/build/agents/session.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { FlowError } from "../flow-error.js";
+export const SUBAGENT_SESSION_VERSION = 1;
+export const subagentSessionEnvelopeSchema = z.object({
+    provider: z.string(),
+    version: z.number().int().positive(),
+    handle: z.unknown(),
+});
+export function parseSessionEnvelopeText(sessionText, resumePath) {
+    let parsedSession;
+    try {
+        parsedSession = JSON.parse(sessionText);
+    }
+    catch {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes invalid 'session' metadata; this conversation cannot be resumed.`);
+    }
+    const sessionResult = subagentSessionEnvelopeSchema.safeParse(parsedSession);
+    if (!sessionResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes invalid 'session' metadata; this conversation cannot be resumed.`);
+    }
+    return sessionResult.data;
+}
+export function resolvePersistedSubagentSession(input) {
+    const sessionText = input.sessionText?.trim();
+    if (!sessionText) {
+        return undefined;
+    }
+    return parseSessionEnvelopeText(sessionText, input.resumePath);
+}

package/build/agents/types.js

@@ -1,11 +1,4 @@
-import { z } from "zod";
-export const SUBAGENT_SESSION_VERSION = 1;
-export const subagentSessionEnvelopeSchema = z.object({
-    provider: z.string(),
-    version: z.number().int().positive(),
-    handle: z.unknown(),
-});
-export class SubagentExecError extends Error {
+export class SubagentFailure extends Error {
     code;
     timeoutMs;
     exitCode;
@@ -13,7 +6,7 @@ export class SubagentExecError extends Error {
     diagnostics;
     constructor(code, message, options = {}) {
         super(message, options.cause === undefined ? undefined : { cause: options.cause });
-        this.name = "SubagentExecError";
+        this.name = "SubagentFailure";
         this.code = code;
         this.timeoutMs = options.timeoutMs ?? null;
         this.exitCode = options.exitCode ?? null;
@@ -21,6 +14,7 @@ export class SubagentExecError extends Error {
         this.diagnostics = options.diagnostics ?? "";
     }
 }
-export function isSubagentExecError(error) {
-    return error instanceof SubagentExecError;
+export function isSubagentFailure(error) {
+    return error instanceof SubagentFailure;
 }
+export { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema } from "./session.js";

package/build/cli/commands/akuma.js

@@ -0,0 +1,79 @@
+import { resolveDefaultAgentName, resolveReviewerAgentName, } from "../../config/settings.js";
+import { normalizeAkumaProfile } from "../../config/akuma-loader.js";
+import { FlowError } from "../../flow-error.js";
+function formatRoleMarkers(settings, name) {
+    const markers = [];
+    if (name === resolveDefaultAgentName(settings))
+        markers.push("default");
+    if (name === resolveReviewerAgentName(settings))
+        markers.push("reviewer");
+    return markers.length > 0 ? ` (${markers.join(", ")})` : "";
+}
+function formatProfileSummary(profile) {
+    const model = profile.model ? `, model ${profile.model}` : "";
+    return `provider ${profile.provider}, executable ${profile.executable}${model}`;
+}
+function sourceBadge(definition) {
+    return `[${definition.source}]`;
+}
+export function renderAkumaList(catalog, settings) {
+    const lines = ["Available Akumas:", ""];
+    for (const definition of Object.values(catalog.definitions).sort((a, b) => a.name.localeCompare(b.name))) {
+        const profile = normalizeAkumaProfile(definition.profile);
+        lines.push(`- ${definition.name}${formatRoleMarkers(settings, definition.name)} ${sourceBadge(definition)}: ${formatProfileSummary(profile)}`);
+        if (profile.description) {
+            lines.push(`  ${profile.description}`);
+        }
+    }
+    for (const shadow of catalog.shadows) {
+        lines.push(`- ${shadow.name} [${shadow.source}] (shadowed by ${shadow.shadowedBy})`);
+    }
+    for (const invalid of catalog.invalid) {
+        lines.push(`- ${invalid.name} (invalid: ${invalid.reason})`);
+    }
+    return lines.join("\n");
+}
+function appendOptionalLine(lines, label, value) {
+    if (value === undefined)
+        return;
+    if (Array.isArray(value)) {
+        lines.push(`${label}: ${value.length > 0 ? value.join(", ") : "(none)"}`);
+        return;
+    }
+    if (typeof value === "object" && value !== null) {
+        lines.push(`${label}: ${JSON.stringify(value)}`);
+        return;
+    }
+    lines.push(`${label}: ${String(value)}`);
+}
+export function renderAkumaShow(catalog, settings, name) {
+    const definition = catalog.definitions[name];
+    if (definition === undefined) {
+        throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${name}'.`);
+    }
+    const profile = normalizeAkumaProfile(definition.profile);
+    const promptLines = definition.body === "" ? [] : definition.body.split(/\r?\n/);
+    const lines = [
+        `Akuma: ${name}`,
+        `source: ${sourceBadge(definition)}`,
+        `definition file: ${definition.path ?? "(built-in)"}`,
+        `roles: ${formatRoleMarkers(settings, name).replace(/^\s*\(|\)$/g, "") || "(none)"}`,
+        `provider: ${profile.provider}`,
+        `executable: ${profile.executable}`,
+    ];
+    appendOptionalLine(lines, "description", profile.description);
+    appendOptionalLine(lines, "model", profile.model);
+    if (profile.provider === "codex-sdk") {
+        appendOptionalLine(lines, "profile", profile.profile);
+        appendOptionalLine(lines, "config", profile.config);
+    }
+    if (profile.provider === "claude-agent-sdk") {
+        appendOptionalLine(lines, "effort", profile.effort);
+        appendOptionalLine(lines, "permissionMode", profile.permissionMode);
+        appendOptionalLine(lines, "settingSources", profile.settingSources);
+    }
+    lines.push("prompt:");
+    lines.push(...promptLines.slice(0, 8).map((line) => `  ${line}`));
+    lines.push(`(${promptLines.length} lines total)`);
+    return lines.join("\n");
+}

package/build/cli/completion.js

@@ -0,0 +1,71 @@
+import { assertSettingsKnobUsable, loadKeiyakuSettings } from "../config/settings.js";
+import { loadAkumaCatalog } from "../config/akuma-loader.js";
+import { listContractIds } from "../core/status.js";
+const TOP_LEVEL_COMMANDS = [
+    "bind",
+    "arc",
+    "summon",
+    "ask",
+    "tell",
+    "resume",
+    "log",
+    "akuma",
+    "skills",
+    "amend",
+    "renew",
+    "petition",
+    "forfeit",
+    "guide",
+    "completion",
+    "status",
+    "dump-env",
+];
+function filterPrefix(items, word) {
+    return items.filter((item) => item.startsWith(word));
+}
+async function contractAddressCandidates(cwd, word) {
+    return filterPrefix((await listContractIds(cwd)).map((id) => `@${id}`), word);
+}
+async function akumaCandidates(cwd, word) {
+    const loaded = await loadKeiyakuSettings(cwd);
+    assertSettingsKnobUsable(loaded, "agents");
+    return filterPrefix(Object.keys((await loadAkumaCatalog(cwd)).definitions), word);
+}
+export async function renderCompletionCandidates(input) {
+    const word = input.word ?? "";
+    if (word.startsWith("@")) {
+        return (await contractAddressCandidates(input.cwd, word)).join("\n");
+    }
+    if (input.previous === "summon" || input.previous === "ask" || input.previous === "show") {
+        return (await akumaCandidates(input.cwd, word)).join("\n");
+    }
+    if (input.previous === "akuma") {
+        return filterPrefix(["list", "ls", "show"], word).join("\n");
+    }
+    if (input.previous === "skills") {
+        return filterPrefix(["install"], word).join("\n");
+    }
+    return filterPrefix(TOP_LEVEL_COMMANDS, word).join("\n");
+}
+export function renderCompletionScript(shell = "bash") {
+    if (shell === "zsh") {
+        return [
+            "#compdef keiyaku",
+            "_keiyaku() {",
+            "  local -a candidates",
+            "  candidates=(${(f)\"$(keiyaku completion --complete --word \"${words[CURRENT]}\" --previous \"${words[CURRENT-1]}\" 2>/dev/null)\"})",
+            "  compadd -- $candidates",
+            "}",
+            "_keiyaku \"$@\"",
+        ].join("\n");
+    }
+    return [
+        "_keiyaku_completion() {",
+        "  local cur prev",
+        "  cur=\"${COMP_WORDS[COMP_CWORD]}\"",
+        "  prev=\"${COMP_WORDS[COMP_CWORD-1]}\"",
+        "  COMPREPLY=( $(compgen -W \"$(keiyaku completion --complete --word \"$cur\" --previous \"$prev\" 2>/dev/null)\" -- \"$cur\") )",
+        "}",
+        "complete -F _keiyaku_completion keiyaku",
+    ].join("\n");
+}

package/build/cli/draft-artifact.js

@@ -0,0 +1,50 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { DRAFT_ARTIFACT_NOTICE, KEIYAKU_DRAFT_DIR } from "../keiyaku.js";
+const DRAFT_SLUG_FALLBACK = "keiyaku-draft";
+function normalizeDraftRelativePath(relativePath) {
+    return relativePath.split(path.sep).join("/");
+}
+function formatDraftTimestamp(now) {
+    const year = String(now.getFullYear());
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const hour = String(now.getHours()).padStart(2, "0");
+    const minute = String(now.getMinutes()).padStart(2, "0");
+    const second = String(now.getSeconds()).padStart(2, "0");
+    return `${year}${month}${day}-${hour}${minute}${second}`;
+}
+function toDraftSlug(title) {
+    const normalized = title
+        .trim()
+        .toLowerCase()
+        .replace(/[^\p{Script=Han}a-z0-9]+/gu, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "");
+    return normalized || DRAFT_SLUG_FALLBACK;
+}
+function buildDraftArtifactRelativePath(title, now = new Date()) {
+    const filename = `${formatDraftTimestamp(now)}_${toDraftSlug(title)}.md`;
+    return normalizeDraftRelativePath(path.join(KEIYAKU_DRAFT_DIR, filename));
+}
+function buildDraftArtifactMarkdown(content, now) {
+    return [
+        "---",
+        "generated_by: keiyaku",
+        "type: draft",
+        `time: '${now.toISOString()}'`,
+        `notice: '${DRAFT_ARTIFACT_NOTICE}'`,
+        "---",
+        "",
+        content,
+    ].join("\n");
+}
+export async function writeDraftArtifact(input) {
+    const now = input.now ?? new Date();
+    const relativePath = buildDraftArtifactRelativePath(input.title, now);
+    const absolutePath = path.join(input.cwd, relativePath);
+    await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+    await fs.writeFile(absolutePath, buildDraftArtifactMarkdown(input.content, now), "utf-8");
+    return relativePath;
+}