dsh-continual-evolve 0.11.0 → 0.12.1

package/lib/fate.js

@@ -1,350 +0,0 @@
-import { createUserMessage } from "@deepseek-ai/dsh-llm";
-import { EVOLVE_MESSAGE_SOURCE } from "./message-source.js";
-import { DEFAULT_PROMOTION_POLICY } from "./promotion.js";
-import { questionServiceOf } from "./approval.js";
-import { fateConsultCopy, resolveDialogLanguage } from "./copy.js";
-import { resolveRecordLanguage } from "./record-language.js";
-import { assessLocalEntries, candidateKey, filterPromotable, listLocalCandidates, splitArchiveGuards, splitPromoteBlocked, splitPromoteProposals, wholePromoteProposals, } from "./wrapup.js";
-/** Turns a declined local-fate proposal stays silent before being offered again. */
-export const FATE_CONSULT_COOLDOWN_TURNS = 10;
-/**
- * Partition an assessed wrap-up classification into concrete fate actions,
- * re-running the deterministic guards against the LIVE global store (state
- * may have changed while the LLM call was in flight). Pure and unit-tested;
- * mirrors the partition step of the wrap-up command.
- */
-export function planLocalFates(items, candidates, globalState, policy = DEFAULT_PROMOTION_POLICY) {
-    const byKey = new Map(candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
-    const { promotable, skipped } = filterPromotable(items, globalState, candidates, policy);
-    const promoteItems = promotable.filter((item) => item.verdict === "promote");
-    const archiveItems = items.filter((item) => item.verdict === "archive");
-    const splits = [];
-    const splitSkipped = [];
-    for (const item of archiveItems) {
-        if (!item.promote)
-            continue;
-        const candidate = byKey.get(item.key);
-        if (!candidate) {
-            splitSkipped.push({ key: item.key, reason: "not in the audited candidate list" });
-            continue;
-        }
-        const blocked = splitPromoteBlocked(item, globalState, candidate.kind, policy, candidate.metadata);
-        if (blocked) {
-            splitSkipped.push({ key: item.key, reason: blocked });
-            continue;
-        }
-        splits.push({ item, candidate });
-    }
-    const plainArchives = archiveItems.filter((item) => !item.promote);
-    const { silent: silentArchives, review: reviewArchives } = splitArchiveGuards(plainArchives, candidates);
-    return { candidates, promotable: promoteItems, splits, silentArchives, reviewArchives, skipped, splitSkipped };
-}
-/**
- * The cooldown key of a candidate set: the sorted `kind:id` list. The set is
- * the unit of consultation — a declined proposal is not offered again within
- * the cooldown window, and a changed set (new entries appeared) starts a
- * fresh consultation.
- */
-export function fateSetKey(candidates) {
-    return candidates
-        .map((candidate) => candidateKey(candidate.kind, candidate.id))
-        .sort()
-        .join("|");
-}
-/**
- * Whether the local-fate dimension is due for this gate run. Turn-interval
- * gates respect the fate cadence (an independent counter — goal-driven
- * sessions run the review EVERY round, the fate assessment must not);
- * compaction is unconditional: experiences about to be summarized away get
- * their fate check regardless. Goal-blocked assessments are unconditional
- * here too — the gate's own streak counter (auto.ts runGoalBlockedFate)
- * already gates their frequency, so the cadence must not re-block them.
- */
-export function fateCadenceDue(state, reason, intervalTurns) {
-    // Compact and goal-blocked assessments bypass the cadence (see header).
-    if (reason === "compact" || reason === "goal_blocked")
-        return true;
-    return state.turns - state.lastFateAt >= intervalTurns;
-}
-/**
- * Ask the user whether to execute the gate's local-fate proposal. ONE dialog
- * covers every governed action (promotes, split promotions, review-required
- * archives) — the gate never spams questions. Conservative on every edge:
- * no question service → not approved; the question call fails → not approved;
- * the same candidate set was declined within the cooldown → not asked again.
- * A decline records the cooldown (the consultSkillEdits pattern).
- */
-export async function consultLocalFates(ctx, agent, plan, gate, language) {
-    const needsDialog = plan.promotable.length + plan.splits.length + plan.reviewArchives.length > 0;
-    if (!needsDialog) {
-        return { approved: true, asked: false, reason: "nothing-to-ask" };
-    }
-    const setKey = fateSetKey(plan.candidates);
-    const lastReject = gate.fateRejects.get(setKey);
-    if (lastReject !== undefined && gate.turns - lastReject < FATE_CONSULT_COOLDOWN_TURNS) {
-        return { approved: false, asked: false, reason: "cooldown" };
-    }
-    const userQuestions = questionServiceOf(ctx);
-    if (!userQuestions) {
-        return { approved: false, asked: false, reason: "unavailable" };
-    }
-    const lang = language ?? resolveDialogLanguage(ctx);
-    try {
-        const copy = fateConsultCopy(sectionsOf(plan, lang), lang);
-        const answer = await userQuestions.ask({
-            questions: [
-                {
-                    id: "evolve-fate-consult",
-                    question: copy.question,
-                    options: copy.options,
-                },
-            ],
-            agent,
-        });
-        const selected = answer.answers?.find((entry) => entry.id === "evolve-fate-consult")?.selected ?? [];
-        const approved = selected.includes("执行") || selected.includes("Proceed");
-        if (!approved) {
-            gate.fateRejects.set(setKey, gate.turns);
-        }
-        return { approved, asked: true, reason: approved ? "consented" : "declined" };
-    }
-    catch {
-        return { approved: false, asked: true, reason: "error" };
-    }
-}
-/** Split a fate plan into pre-rendered per-group lines for the dialog copy. */
-function sectionsOf(plan, lang) {
-    const byKey = new Map(plan.candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
-    const promotable = [];
-    const splits = [];
-    const reviewArchives = [];
-    for (const item of plan.promotable) {
-        promotable.push(`- ${item.key}「${byKey.get(item.key)?.title ?? item.key}」 — ${item.reason}`);
-    }
-    for (const { item } of plan.splits) {
-        splits.push(lang === "zh"
-            ? `- ${item.key} → 拆出提升「${item.promote?.title}」（原条目随之归档）`
-            : `- ${item.key} → split-promote "${item.promote?.title}" (original archived alongside)`);
-    }
-    for (const item of plan.reviewArchives) {
-        reviewArchives.push(`- ${item.key}「${byKey.get(item.key)?.title ?? item.key}」 — ${item.reason}`);
-    }
-    return { promotable, splits, reviewArchives };
-}
-/**
- * Deterministically apply the fate plan. `"full"` applies everything
- * (promotes, splits, silent + review archives); `"silent-only"` applies only
- * the deterministic silent archives (the compaction path — nothing governed).
- * Promotes go through the SAME proposals as the wrap-up command
- * (wholePromoteProposals / splitPromoteProposals), so both paths write
- * identical global entries and local retirement stamps.
- */
-export function applyLocalFates(engine, sessionId, plan, localState, mode) {
-    const applied = [];
-    const results = [];
-    const byKey = new Map(plan.candidates.map((candidate) => [candidateKey(candidate.kind, candidate.id), candidate]));
-    if (mode === "full") {
-        for (const item of plan.promotable) {
-            const candidate = byKey.get(item.key);
-            if (!candidate)
-                continue;
-            const proposals = wholePromoteProposals(item, candidate, sessionId);
-            const globalResult = engine.apply("global", undefined, proposals.global, { scope: "global" });
-            const createdId = globalResult.appliedEdits.find((edit) => edit.applied)?.id ?? candidate.id;
-            const localResult = engine.apply("local", sessionId, proposals.localStamp(createdId), {
-                scope: "local",
-                baselineState: localState,
-            });
-            results.push(globalResult, localResult);
-            applied.push(`提升 ${item.key} → 全局 store（global:${createdId}，本地副本已归档）`);
-        }
-        for (const { item, candidate } of plan.splits) {
-            if (!item.promote)
-                continue;
-            const proposals = splitPromoteProposals(item, candidate, sessionId);
-            const globalResult = engine.apply("global", undefined, proposals.global, { scope: "global" });
-            const createdId = globalResult.appliedEdits.find((edit) => edit.applied)?.id ?? candidate.id;
-            const localResult = engine.apply("local", sessionId, proposals.localStamp(createdId), {
-                scope: "local",
-                baselineState: localState,
-            });
-            results.push(globalResult, localResult);
-            applied.push(`拆解 ${item.key} → 清洗「${item.promote.title}」入全局（原条目已归档）`);
-        }
-    }
-    const archives = mode === "full" ? [...plan.silentArchives, ...plan.reviewArchives] : plan.silentArchives;
-    for (const item of archives) {
-        const candidate = byKey.get(item.key);
-        if (!candidate)
-            continue;
-        const proposal = {
-            summary: `gate fate: archive local ${item.key} — ${item.reason}`,
-            rationale: item.reason,
-            expectedOutcome: "The entry stops being injected but stays restorable.",
-            edits: [{ action: "archive", kind: candidate.kind, id: candidate.id }],
-        };
-        const result = engine.apply("local", sessionId, proposal, { scope: "local", baselineState: localState });
-        results.push(result);
-        applied.push(`归档 ${item.key}「${candidate.title}」`);
-    }
-    return { applied, results };
-}
-/**
- * The gate's local-fate phase. Runs after the review phase on every gate
- * trigger (turn_snapshot / compact), subject to cadence and cooldown. All
- * failures are contained and recorded — a broken fate dimension never
- * disturbs the agent loop.
- */
-export async function runLocalFatePhase(ctx, engine, agent, config, state, reason, record) {
-    if (!config.localFate)
-        return;
-    const logger = ctx.logger("continual-evolve");
-    const sessionId = agent.id;
-    const tokenUsage = {
-        baseDir: engine.baseDir,
-        sessionId,
-        retain: engine.retention.tokenUsage,
-        onError: (cause) => logger.warn(`token-usage ledger failed for ${sessionId}: ${cause instanceof Error ? cause.message : String(cause)}`),
-    };
-    const localState = engine.load("local", sessionId);
-    const globalState = engine.load("global", undefined);
-    const candidates = listLocalCandidates(localState, globalState, engine.baseDir);
-    if (candidates.length === 0)
-        return;
-    if (!fateCadenceDue(state, reason, config.fateIntervalTurns))
-        return;
-    const setKey = fateSetKey(candidates);
-    const lastReject = state.fateRejects.get(setKey);
-    if (lastReject !== undefined && state.turns - lastReject < FATE_CONSULT_COOLDOWN_TURNS) {
-        logger.info(`auto-review local-fate skipped [${sessionId}]: candidate set declined ${state.turns - lastReject} turns ago (cooldown)`);
-        return;
-    }
-    const turnsSinceFate = state.turns - state.lastFateAt;
-    state.lastFateAt = state.turns;
-    let assessment;
-    const fateLanguage = resolveRecordLanguage({ configured: config.recordLanguage, ctx });
-    try {
-        assessment = await assessLocalEntries(ctx, agent, candidates, { tokenUsage, tokenUsagePhase: "fate", language: fateLanguage });
-    }
-    catch (cause) {
-        const message = cause instanceof Error ? cause.message : String(cause);
-        logger.warn(`auto-review local-fate failed for ${sessionId}: ${message}`);
-        record({
-            sessionId,
-            reason,
-            turnsSinceLastReview: turnsSinceFate,
-            outcome: "failed",
-            rationale: `fate assessment error: ${message}`,
-        });
-        return;
-    }
-    const plan = planLocalFates(assessment.items, candidates, globalState, config.promotionPolicy);
-    const needsDialog = plan.promotable.length + plan.splits.length + plan.reviewArchives.length > 0;
-    let consent = { approved: false, asked: false, reason: "nothing-to-ask" };
-    // Turn-path tightening (2026-09-25): turn_snapshot/turn_interval never open
-    // a dialog — governed actions are deferred to `/evolve wrapup`. Only an
-    // explicit goal_blocked signal (own streak counter) may consult.
-    if (reason === "goal_blocked" && needsDialog) {
-        consent = await consultLocalFates(ctx, agent, plan, state, fateLanguage);
-    }
-    if (consent.approved) {
-        const { applied, results } = applyLocalFates(engine, sessionId, plan, localState, "full");
-        logger.info(`auto-review local-fate approved (${reason}) [${sessionId}]: ${plan.promotable.length} promoted, ${plan.splits.length} split, ${plan.reviewArchives.length} review-archived, ${plan.silentArchives.length} silent-archived — ${assessment.rationale}`);
-        record({
-            sessionId,
-            reason,
-            turnsSinceLastReview: turnsSinceFate,
-            outcome: "approved",
-            rationale: `fate: ${assessment.rationale} (${applied.join("; ")})`,
-            refinementId: results.map((result) => result.id).join(","),
-        });
-        return;
-    }
-    if (consent.reason === "declined" || consent.reason === "unavailable" || consent.reason === "error") {
-        const withheld = consent.reason;
-        const outcome = withheld === "declined" ? "declined" : "deferred";
-        logger.info(`auto-review local-fate ${outcome} (${reason}) [${sessionId}]: ${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives withheld — ${assessment.rationale}`);
-        record({
-            sessionId,
-            reason,
-            turnsSinceLastReview: turnsSinceFate,
-            outcome,
-            rationale: `fate ${withheld}: ${assessment.rationale} (${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives withheld)`,
-        });
-        return;
-    }
-    if (needsDialog && reason !== "goal_blocked") {
-        // Turn/compact path: no dialog. Only deterministic silent archives apply;
-        // governed actions are deferred with an audit record pointing at wrapup.
-        const { applied, results } = applyLocalFates(engine, sessionId, plan, localState, "silent-only");
-        if (applied.length > 0) {
-            logger.info(`auto-review local-fate (${reason}) [${sessionId}]: silent-archived ${applied.length} — ${assessment.rationale}`);
-            record({
-                sessionId,
-                reason,
-                turnsSinceLastReview: turnsSinceFate,
-                outcome: "approved",
-                rationale: `fate (${reason}): ${assessment.rationale} (${applied.join("; ")})`,
-                refinementId: results.map((result) => result.id).join(","),
-            });
-        }
-        record({
-            sessionId,
-            reason,
-            turnsSinceLastReview: turnsSinceFate,
-            outcome: "deferred",
-            rationale: `fate (${reason}): ${plan.promotable.length} promotes, ${plan.splits.length} splits, ${plan.reviewArchives.length} review-archives deferred — run /evolve wrapup for a full session exit`,
-        });
-        return;
-    }
-    // Silent archives on a plain turn-interval gate with nothing to ask.
-    if (plan.silentArchives.length > 0) {
-        const { applied, results } = applyLocalFates(engine, sessionId, plan, localState, "silent-only");
-        logger.info(`auto-review local-fate (${reason}) [${sessionId}]: silent-archived ${applied.length} covered/operational entries — ${assessment.rationale}`);
-        record({
-            sessionId,
-            reason,
-            turnsSinceLastReview: turnsSinceFate,
-            outcome: "approved",
-            rationale: `fate: ${assessment.rationale} (${applied.join("; ")})`,
-            refinementId: results.map((result) => result.id).join(","),
-        });
-        if (config.notifyOnAutoReview && (reason === "turn_snapshot" || reason === "turn_interval")) {
-            notifyFateApplied(ctx, agent, applied);
-        }
-        return;
-    }
-    // Assessed, nothing to do.
-    logger.info(`auto-review local-fate assessed (${reason}) [${sessionId}]: ${candidates.length} candidates, no action — ${assessment.rationale}`);
-    record({
-        sessionId,
-        reason,
-        turnsSinceLastReview: turnsSinceFate,
-        outcome: "assessed",
-        rationale: `fate: ${assessment.rationale} (${candidates.length} candidates, no action)`,
-    });
-}
-/** The user-visible notice after the gate applied local-fate actions. */
-export function buildFateNotice(applied) {
-    return [
-        "🔎 自动进化门禁：本会话 local 条目归宿处理完成：",
-        applied.map((line) => `- ${line}`).join("\n"),
-        "查看全部条目：/evolve list；撤销：/evolve rollback <refinement id>",
-        "请用一句话简短确认即可，不要调用任何工具。",
-    ].join("\n");
-}
-/** Queue the follow-up notice turn (successful-turn path only). */
-function notifyFateApplied(ctx, agent, applied) {
-    try {
-        agent.followup(createUserMessage({
-            content: [{ type: "text", text: buildFateNotice(applied) }],
-            source: EVOLVE_MESSAGE_SOURCE,
-        }));
-    }
-    catch (cause) {
-        ctx
-            .logger("continual-evolve")
-            .warn(`local-fate notice failed for ${agent.id}: ${cause instanceof Error ? cause.message : String(cause)}`);
-    }
-}
-//# sourceMappingURL=fate.js.map

package/lib/goal-command.d.ts

@@ -1,7 +0,0 @@
-/**
- * The `/evolve goal` subcommand handler. Extracted from command.ts (P2-2).
- */
-import type { Context } from "@deepseek-ai/cordis";
-import type { CommandInvocation, CommandResult } from "@deepseek-ai/dsh-commands";
-export declare function executeGoalCommand(ctx: Context, invocation: CommandInvocation, rest: string[]): CommandResult;
-//# sourceMappingURL=goal-command.d.ts.map

package/lib/goal-command.js

@@ -1,37 +0,0 @@
-import { blockEvolutionGoal, completeEvolutionGoal, goalServiceOf, goalStatusText, upsertEvolutionGoal } from "./goal.js";
-function success(text) {
-    return { kind: "success", text };
-}
-function error(text) {
-    return { kind: "error", text };
-}
-export function executeGoalCommand(ctx, invocation, rest) {
-    const agent = invocation.agent;
-    const goals = goalServiceOf(ctx);
-    if (!goals) {
-        return error(`/evolve goal requires the goals service (load @deepseek-ai/dsh-goal)`);
-    }
-    const sub = rest[0] ?? "";
-    try {
-        if (sub === "done") {
-            const view = completeEvolutionGoal(ctx, agent);
-            return view ? success(`evolution goal completed: ${goalStatusText(view)}`) : success("(no goal to complete)");
-        }
-        if (sub === "block") {
-            const reason = rest.slice(1).join(" ") || "user requested block";
-            const view = blockEvolutionGoal(ctx, agent, reason);
-            return view ? success(`evolution goal blocked: ${goalStatusText(view)}`) : success("(no active goal to block)");
-        }
-        if (sub.length === 0) {
-            const current = goals.get(agent);
-            return current ? success(goalStatusText(current)) : success("(no evolution goal — /evolve goal <objective> to create one)");
-        }
-        const objective = rest.join(" ");
-        const view = upsertEvolutionGoal(ctx, agent, objective);
-        return success(`evolution goal ready: ${goalStatusText(view)}\n(active goal drives the review gate every round)`);
-    }
-    catch (cause) {
-        return error(cause instanceof Error ? cause.message : String(cause));
-    }
-}
-//# sourceMappingURL=goal-command.js.map

package/lib/goal.d.ts

@@ -1,72 +0,0 @@
-/**
- * Goal-driven evolution rounds (v3 optional item, design.md §6): a
- * same-session goal turns the auto-review into a per-round driver — while a
- * goal is active, the review gate runs every round instead of every
- * `reviewIntervalTurns`, so the "continual evolution loop" is driven by the
- * goal's round machine (goal-round-driver keeps the session continuing) and
- * stops when the goal is completed or blocked.
- *
- * The goal service (`ctx.goals`) is resolved lazily and never required
- * (FAQ #1 discipline): without it, `/evolve goal` reports the feature
- * unavailable and auto-review keeps its plain interval.
- */
-import type { Context } from "@deepseek-ai/cordis";
-import type { Agent } from "@deepseek-ai/dsh-agent";
-/** The durable goal phases we drive on. */
-export type GoalPhase = "active" | "paused" | "blocked" | "complete";
-/** Minimal structural view of a goal view (duck-typed against dsh-goal). */
-export interface GoalViewLike {
-    readonly id: string;
-    readonly revision: number;
-    readonly objective: string;
-    readonly phase: GoalPhase;
-    readonly maxGoalRounds: number;
-}
-export interface GoalRefLike {
-    readonly id: string;
-    readonly revision: number;
-}
-export interface GoalServiceLike {
-    get(agent: Agent): GoalViewLike | undefined;
-    create(agent: Agent, request: {
-        objective: string;
-        maxGoalRounds?: number;
-    }): GoalViewLike;
-    edit(agent: Agent, ref: GoalRefLike, request: {
-        objective?: string;
-        maxGoalRounds?: number;
-    }): GoalViewLike;
-    complete(agent: Agent, ref: GoalRefLike): GoalViewLike;
-    block?(agent: Agent, ref: GoalRefLike, reason: {
-        code: string;
-        reason: string;
-    }): GoalViewLike;
-}
-/** The default objective used by `/evolve goal` without an explicit one. */
-export declare const DEFAULT_EVOLVE_GOAL_OBJECTIVE = "\u6301\u7EED\u8FDB\u5316\u672C\u4F1A\u8BDD harness \u72B6\u6001\uFF1A\u6BCF\u8F6E\u6C89\u6DC0\u53EF\u590D\u7528\u7ECF\u9A8C\uFF08\u5931\u8D25/\u6218\u672F/\u4E8B\u5B9E/\u59D4\u6D3E\u89C4\u683C\uFF09\uFF0C\u4FDD\u6301\u6761\u76EE\u5C0F\u800C\u5E26\u8BC1\u636E";
-/**
- * Resolve the goal service lazily; undefined when the profile lacks it.
- * Uses `ctx.get("goals")` (the global service registry) — a direct property
- * access like `ctx.goals` walks only the caller's fiber ancestor chain and
- * throws "cannot get property \"goals\" without inject" for services
- * provided by sibling plugin entries (the goal plugin is a sibling of this
- * one in the profile tree).
- */
-export declare function goalServiceOf(ctx: Context): GoalServiceLike | undefined;
-/** True when a goal view exists and is in a round-driving phase (active). */
-export declare function goalDrivesRounds(view: GoalViewLike | undefined): boolean;
-/** True when a goal exists at all (any phase) — used to gate create vs edit. */
-export declare function goalExists(view: GoalViewLike | undefined): view is GoalViewLike;
-/** Human-readable one-line status for a goal view. */
-export declare function goalStatusText(view: GoalViewLike): string;
-/**
- * Create or edit the session's evolution goal. With no current goal: create.
- * With a current goal: edit its objective (create-on-first-use semantics are
- * enforced by the goal service itself; completed goals may be replaced).
- */
-export declare function upsertEvolutionGoal(ctx: Context, agent: Agent, objective?: string): GoalViewLike;
-/** Complete the current goal, returning the completed view or undefined. */
-export declare function completeEvolutionGoal(ctx: Context, agent: Agent): GoalViewLike | undefined;
-/** Block the current goal with a reason (when the service supports it). */
-export declare function blockEvolutionGoal(ctx: Context, agent: Agent, reason: string): GoalViewLike | undefined;
-//# sourceMappingURL=goal.d.ts.map

package/lib/goal.js

@@ -1,72 +0,0 @@
-/** The default objective used by `/evolve goal` without an explicit one. */
-export const DEFAULT_EVOLVE_GOAL_OBJECTIVE = "持续进化本会话 harness 状态：每轮沉淀可复用经验（失败/战术/事实/委派规格），保持条目小而带证据";
-/**
- * Resolve the goal service lazily; undefined when the profile lacks it.
- * Uses `ctx.get("goals")` (the global service registry) — a direct property
- * access like `ctx.goals` walks only the caller's fiber ancestor chain and
- * throws "cannot get property \"goals\" without inject" for services
- * provided by sibling plugin entries (the goal plugin is a sibling of this
- * one in the profile tree).
- */
-export function goalServiceOf(ctx) {
-    return ctx.get("goals");
-}
-/** True when a goal view exists and is in a round-driving phase (active). */
-export function goalDrivesRounds(view) {
-    return view?.phase === "active";
-}
-/** True when a goal exists at all (any phase) — used to gate create vs edit. */
-export function goalExists(view) {
-    return view !== undefined;
-}
-/** Human-readable one-line status for a goal view. */
-export function goalStatusText(view) {
-    const rounds = typeof view.roundsStarted === "number"
-        ? String(view.roundsStarted)
-        : "?";
-    return `[${view.phase}] ${view.objective} (rounds=${rounds}/${view.maxGoalRounds}, revision=${view.revision})`;
-}
-/**
- * Create or edit the session's evolution goal. With no current goal: create.
- * With a current goal: edit its objective (create-on-first-use semantics are
- * enforced by the goal service itself; completed goals may be replaced).
- */
-export function upsertEvolutionGoal(ctx, agent, objective) {
-    const goals = goalServiceOf(ctx);
-    if (!goals) {
-        throw new Error("evolve: /evolve goal requires the goals service (load @deepseek-ai/dsh-goal)");
-    }
-    const current = goals.get(agent);
-    const nextObjective = objective && objective.length > 0 ? objective : DEFAULT_EVOLVE_GOAL_OBJECTIVE;
-    if (goalExists(current)) {
-        if (current.phase === "active" || current.phase === "paused") {
-            return goals.edit(agent, { id: current.id, revision: current.revision }, { objective: nextObjective });
-        }
-    }
-    return goals.create(agent, { objective: nextObjective });
-}
-/** Complete the current goal, returning the completed view or undefined. */
-export function completeEvolutionGoal(ctx, agent) {
-    const goals = goalServiceOf(ctx);
-    if (!goals) {
-        throw new Error("evolve: /evolve goal requires the goals service (load @deepseek-ai/dsh-goal)");
-    }
-    const current = goals.get(agent);
-    if (!goalExists(current) || current.phase === "complete") {
-        return current;
-    }
-    return goals.complete(agent, { id: current.id, revision: current.revision });
-}
-/** Block the current goal with a reason (when the service supports it). */
-export function blockEvolutionGoal(ctx, agent, reason) {
-    const goals = goalServiceOf(ctx);
-    if (!goals || typeof goals.block !== "function") {
-        return undefined;
-    }
-    const current = goals.get(agent);
-    if (!goalExists(current) || current.phase !== "active") {
-        return current;
-    }
-    return goals.block(agent, { id: current.id, revision: current.revision }, { code: "evolve-blocked", reason });
-}
-//# sourceMappingURL=goal.js.map

package/lib/inject.d.ts

@@ -1,90 +0,0 @@
-/**
- * Real prompt/spec injection: the dynamic system-prompt section that makes
- * `prompt` entries visible to the model without a tool call, and `subagent`
- * entries available as reusable delegation specs at the delegation seam.
- *
- * Design (design.md §7 Phase 2):
- * - the section text is a provider evaluated at every assembly with the
- *   assembling agent; a section that renders to "" is dropped by the prompt
- *   renderer, so an empty store costs zero tokens;
- * - prompt entries render as an additive section (the base system prompt is
- *   never touched); subagent entries render as delegation specs the parent
- *   follows when delegating, and are inherited by child agents through the
- *   `SessionHeader.parentSession` chain so a freshly spawned subagent carries
- *   its parent's specs without any provider wrapping;
- * - every cap mirrors render.ts (6 entries/kind, 180 chars/entry, stable
- *   sort), keeping the injected cost bounded no matter how the store grows;
- * - full text stays one `evolve_list` call away: the injected block is a
- *   summary index, not a duplicate of the store.
- *
- * Split (2026-10-03 refactor): ranking lives in `injection-rank.ts`, the
- * entry directory in `injection-directory.ts`, shared caps in
- * `injection-caps.ts`; this module owns section rendering and the
- * three-store merge. Moved symbols are re-exported here so the public
- * surface stays on one module.
- */
-import type { HarnessEntry, HarnessState } from "./types.js";
-import type { EvolutionEngine } from "./service.js";
-import { type AgentLike } from "./injection-rank.js";
-/** Compat surface: ranking + directory + caps moved out 2026-10-03. */
-export { rankEntries, recencyScore, recentUserText, sessionEventsOf, tokenize } from "./injection-rank.js";
-export type { AgentLike, UserMessageEventLike } from "./injection-rank.js";
-export { RECENCY_HALF_LIFE_MS, MAX_QUERY_MESSAGES, MAX_QUERY_CHARS } from "./injection-rank.js";
-export { directoryLine, formatEntriesDirectory, formatEntriesDirectoryCapped, formatEntriesDirectoryRanked, rankedDirectoryEntries, DEFAULT_DIRECTORY_LINES, } from "./injection-directory.js";
-export { MAX_INJECTED_ENTRIES_PER_KIND, MAX_INJECTED_CONTENT_LENGTH } from "./injection-caps.js";
-/** How many `parentSession` hops a child walks to inherit entries. */
-export declare const MAX_PARENT_CHAIN_DEPTH = 8;
-/** The section-provider context shape we consume (subset of AssembleContext). */
-export interface InjectContext {
-    agent?: AgentLike;
-}
-/** True when the state carries at least one entry of any kind. */
-export declare function hasAnyEntries(state: HarnessState): boolean;
-/** The additive prompt-notes block (empty when there are no visible prompt entries). */
-export declare function formatPromptEntriesSection(entries: readonly HarnessEntry[], query?: string): string;
-/** The reusable delegation-specs block (empty when there are no visible subagent entries). */
-export declare function formatSubagentSpecsSection(entries: readonly HarnessEntry[], query?: string): string;
-/**
- * Walk the parent-session chain from `agent` upward and return the nearest
- * session whose local store is non-empty, if any. Children inherit their
- * ancestor's prompt notes and delegation specs; the chain walk stops at the
- * first store that has entries (deep descendants do not re-inject ancestors
- * beyond the nearest carrying store).
- */
-export declare function nearestLocalStateWithEntries(engine: EvolutionEngine, agent: AgentLike): HarnessState | undefined;
-/**
- * The single three-store merge every injection path reads from: the global
- * store merged with this project's store (when the session cwd resolves one)
- * and the nearest carrying local store (precedence global < project < local —
- * see {@link mergeHarnessStates}). One home, so the memory section and the
- * entry directory can never disagree about what the model can see.
- */
-export declare function mergedInjectionState(engine: EvolutionEngine, agent: AgentLike, opts?: {
-    projectKey?: string;
-}): HarnessState;
-/**
- * Compose the full injected block for one assembling agent: global entries
- * merged with this project's store (when the session cwd resolves one) and
- * the nearest carrying local store (precedence global < project < local).
- * The optional `query` — when absent, derived from the agent's most recent
- * direct user messages — ranks which entries fill the per-kind cap
- * (relevance first, then recency; see {@link rankEntries}). Returns "" when
- * nothing is injectable — the prompt renderer then drops the section, so an
- * empty store adds zero tokens to every assembly.
- *
- * `opts.directoryLines` caps the entry-directory index (2026-08-22 throttle);
- * `opts.projectKey` pins the project layer explicitly (tests, tools) —
- * otherwise it is derived from the agent's session cwd, best-effort.
- * `opts.includeMemoryDirectory` (default true) drops memory lines from the
- * directory when the memory section already carries them (evolve v2) — one
- * fact, one home, so the same memories are never paid for twice.
- * Usage recording covers ALL kinds — memories and skills appear as directory
- * lines, prompts/subagents as content — and is deduped per session so the
- * counts read "how many sessions saw this", not "how many prompt builds".
- */
-export declare function entriesSectionText(engine: EvolutionEngine, agent: AgentLike | undefined, query?: string, opts?: {
-    directoryLines?: number;
-    projectKey?: string;
-    includeMemoryDirectory?: boolean;
-}): string;
-//# sourceMappingURL=inject.d.ts.map