@wowyuarm/dsh-agent-team 0.1.14-alpha.2 → 0.1.14

package/packages/agent-team/lib/types/context-continuity-host.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The Agent Team's binding of the context-continuity engine: how one Member
+ * resolves to its live Agent and back, how a Member Session's fold state is
+ * read, how a prepared generation swap runs in the Member lifecycle, and the
+ * two domain dimensions the engine refuses to own (which queued messages are
+ * Team notices, and how a rollover's durable identity is named).
+ *
+ * The engine owns every mechanic this module does not state: the idle-boundary
+ * swap, carried input, checkpoint continuations, crash repair. Team owns the
+ * Member vocabulary and the ledger-backed lifecycle behind
+ * {@link TeamContextContinuityOptions.executeTransition}.
+ *
+ * The projection state this host hands the coordinator is the engine's own
+ * (`ContextProjectionState`), read from the unit `context-projection.ts`
+ * registers once per Host — one state shape, one fold, no translation.
+ * @module @wowyuarm/dsh-agent-team/context-continuity-host
+ */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import type { UserMessage } from '@deepseek-ai/dsh-llm';
+import { ContextContinuityCoordinator, ContextMessageCodec, type ContextContinuityHost, type ContextProjectionState, type ContextSubject, type RolloverIdentity, type TransitionPlan } from '@wowyuarm/dsh-context-continuity';
+import type { AgentTeamAgentMember, AgentTeamMemberId } from './types.ts';
+/**
+ * The one writer of context-continuity messages for Team. Section names are
+ * the engine's fixed vocabulary; only the plugin identity and the two
+ * subject-facing prose lines are Team's, and both are frozen by history —
+ * durable logs written by earlier generations are read back through this same
+ * identity, so `handoffIntro` and `handoffVerifyNote` reproduce them byte for
+ * byte.
+ */
+export declare const TEAM_CONTEXT_CODEC: ContextMessageCodec;
+export interface TeamContextContinuityOptions {
+    /** Resolve the live Agent of one Member; undefined leaves intent parked. */
+    readonly agentForMember: (memberId: AgentTeamMemberId) => Agent | undefined;
+    /** Resolve the durable Member of one live Agent. */
+    readonly memberForAgent: (agent: Agent) => AgentTeamAgentMember | undefined;
+    /**
+     * Read one Member Session's engine-folded continuity state: the unit
+     * registered by `context-projection.ts`, or undefined when the Member has no
+     * live Session with that id (the coordinator leaves intent parked).
+     */
+    readonly projectionForMember: (memberId: AgentTeamMemberId, sessionId: SessionId) => ContextProjectionState | undefined;
+    /**
+     * Execute one prepared Member generation swap at a true idle boundary:
+     * commit, dispose, archive, create/activate, deliver the handoff first,
+     * then carried input and the rederived Inbox. Returns once the Member runs
+     * its new generation.
+     */
+    readonly executeTransition: (memberId: AgentTeamMemberId, plan: TransitionPlan) => Promise<void>;
+    /** Log one coordinator diagnostic. */
+    readonly log: (message: string) => void;
+}
+/**
+ * Team's `ContextContinuityHost`. Every method is a straight delegation except
+ * the three that decide domain meaning: the durable rollover identity, which
+ * queued messages are rederived Team notices, and the projection bridge.
+ */
+export declare class TeamContextContinuityHost implements ContextContinuityHost<AgentTeamMemberId> {
+    private readonly options;
+    constructor(options: TeamContextContinuityOptions);
+    agentForSubject(memberId: AgentTeamMemberId): Agent | undefined;
+    subjectForAgent(agent: Agent): ContextSubject<AgentTeamMemberId> | undefined;
+    projectionForSubject(memberId: AgentTeamMemberId, sessionId: SessionId): ContextProjectionState | undefined;
+    executeTransition(memberId: AgentTeamMemberId, plan: TransitionPlan): Promise<void>;
+    /**
+     * Rollover identity, unchanged from the in-repo coordinator: stable key over
+     * the previous Session and the successful tool call, JSON-encoded so no
+     * delimiter can alias across the two unconstrained fields, then hashed to a
+     * fixed-length digest. Both names are durable — in-flight recovery converges
+     * on `agent-team-rollover-<digest>`, and the ledger records the request id.
+     */
+    rolloverIdentity(previousSessionId: SessionId, toolCallId: string): RolloverIdentity;
+    /**
+     * A queued message the successor generation rederives from ledger facts: any
+     * Team-attributed message. The engine excludes the handoff and continuation
+     * envelopes before consulting this, so the two are ordinary delivered
+     * context the next generation keeps.
+     */
+    isEphemeralNotice(message: UserMessage): boolean;
+    log(message: string): void;
+}
+/** Build the engine coordinator over Team's Member lifecycle. */
+export declare function createTeamContextManagement(options: TeamContextContinuityOptions): ContextContinuityCoordinator<AgentTeamMemberId>;
+//# sourceMappingURL=context-continuity-host.d.ts.map

package/packages/agent-team/lib/types/context-continuity-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-continuity-host.d.ts","sourceRoot":"","sources":["../../src/context-continuity-host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAEvD,OAAO,EACL,4BAA4B,EAC5B,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACpB,MAAM,kCAAkC,CAAA;AAGzC,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAmC,MAAM,YAAY,CAAA;AAE1G;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,qBAI7B,CAAA;AAEF,MAAM,WAAW,4BAA4B;IAC3C,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,KAAK,GAAG,SAAS,CAAA;IAC3E,oDAAoD;IACpD,QAAQ,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,oBAAoB,GAAG,SAAS,CAAA;IAC3E;;;;OAIG;IACH,QAAQ,CAAC,mBAAmB,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,SAAS,EAAE,SAAS,KAAK,sBAAsB,GAAG,SAAS,CAAA;IACvH;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAChG,sCAAsC;IACtC,QAAQ,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CACxC;AAED;;;;GAIG;AACH,qBAAa,yBAA0B,YAAW,qBAAqB,CAAC,iBAAiB,CAAC;IAC5E,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,4BAA4B;IAElE,eAAe,CAAC,QAAQ,EAAE,iBAAiB,GAAG,KAAK,GAAG,SAAS;IAI/D,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc,CAAC,iBAAiB,CAAC,GAAG,SAAS;IAM5E,oBAAoB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,SAAS,EAAE,SAAS,GAAG,sBAAsB,GAAG,SAAS;IAI3G,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAInF;;;;;;OAMG;IACH,gBAAgB,CAAC,iBAAiB,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,gBAAgB;IAQpF;;;;;OAKG;IACH,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO;IAKhD,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAG3B;AAED,iEAAiE;AACjE,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,4BAA4B,GAAG,4BAA4B,CAAC,iBAAiB,CAAC,CAElI"}

package/packages/agent-team/lib/types/context-projection.d.ts

@@ -1,160 +1,51 @@
 /**
- * Host-only Session projection for Agent Team context management.
+ * Team's projection contribution to the context-continuity engine: the durable
+ * ref naming, the Team-notice rule, and the domain judgement that decides which
+ * events anchor a timeline boundary and what each boundary is attributable to.
  *
- * One pure synchronous fold over a Member Session log derives every
- * context-management fact the Host needs: pending rollover intent (a
- * successful `context_rollover` call/result pair — under the legacy
- * `new_context` name for Sessions recorded before the rename), explicit
- * checkpoints (a
- * successful `context_checkpoint` pair resolved by its containing `turn/end`),
- * handoff/compaction boundaries, and quiet-continuation delivery state. The
- * fold is the single authority for these facts — no second store, and callers
- * never re-derive intent from raw events.
+ * The fold itself is the engine's (`createContextProjectionDefinition`): one
+ * registered unit per Host folds every Session's durable log and owns the
+ * universal structure — checkpoints, the pending rollover intent, quiet
+ * continuation delivery, carry candidates, open calls, turn cursors. This
+ * module supplies only what the engine deliberately refuses to know:
  *
- * A seeded child Session folds with `inheritedEventCount` respected: events
- * inherited from the fork prefix are already resolved history, never fresh
- * intent. The cold fold and the registered unit both start past the inherited
- * cut, so an inherited historical rollover call can never schedule
- * another transition in the child.
+ * - the durable refs Team's existing logs already carry
+ *   (`context-checkpoint-<sha256>`, `team-boundary-<sha256>`), frozen because
+ *   recorded history is read back through them;
+ * - which queued messages are Team-owned notices the successor rederives;
+ * - which successful Team calls anchor a boundary, and which Threads each
+ *   boundary is attributable to. A claim mutation resolves its Task's Thread
+ *   through the ledger; that binding is written once at Task creation, so a
+ *   re-fold reproduces the same attribution, and a missing ledger or mapping
+ *   yields no attribution instead of failing the fold.
+ *
+ * The remaining exports are read views over the engine's state that Team still
+ * owns: the anchor lookups the rollover guard revalidates a cited ref through,
+ * the accumulated Thread attribution that guard and the timeline both judge a
+ * boundary by, and carried-message resolution — the engine keys carry
+ * candidates by message id, and the durable log is where the message body
+ * lives.
  * @module @wowyuarm/dsh-agent-team/context-projection
  */
 import type { UserMessage } from '@deepseek-ai/dsh-llm';
-import type { SessionEvent, SessionLogOffset } from '@deepseek-ai/dsh-session';
-import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection';
-import type { AgentTeamContextCheckpointRef } from './types.ts';
-import { isCheckpointContinuationMessage } from './context-source.ts';
-import type { SessionEventFold } from './session-event-cursor.ts';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import { CONTEXT_CHECKPOINT_TOOL_NAME, CONTEXT_ROLLOVER_TOOL_NAME, createContextProjectionDefinition, type ContextCheckpointEntry, type ContextFoldTarget, type ContextProjectionConfig, type ContextProjectionHost, type ContextProjectionState, type DomainBoundary, type DomainBoundaryContribution, type DomainBoundaryInput } from '@wowyuarm/dsh-context-continuity';
+import type { AgentTeamContextCheckpointRef, AgentTeamTaskRef, AgentTeamThreadRef } from './types/entities.ts';
 /** Whether one notice summary is a pure reminder (never a semantic Team fact). */
 export declare function isReminderNoticeSummary(summary: string): boolean;
-/** Stable tool names the projection recognizes. */
-export declare const CONTEXT_CHECKPOINT_TOOL_NAME = "context_checkpoint";
-export declare const CONTEXT_ROLLOVER_TOOL_NAME = "context_rollover";
+/** Stable tool names the fold recognizes under their current names. */
+export { CONTEXT_CHECKPOINT_TOOL_NAME, CONTEXT_ROLLOVER_TOOL_NAME };
 /**
  * Legacy decoder name: the rollover tool was renamed `new_context` →
  * `context_rollover`, and Sessions recorded before the rename still carry
- * durable `new_context` call/result pairs. The projection keeps folding them
- * — pending rollovers and crash recovery of existing Members depend on old
+ * durable `new_context` call/result pairs. The fold keeps decoding them —
+ * pending rollovers and crash recovery of existing Members depend on old
  * events still resolving intent — but this is a log decoder, not a tool
  * alias: no new call can carry the old name.
  */
 export declare const NEW_CONTEXT_TOOL_NAME = "new_context";
-/** One completed-turn checkpoint anchor in this Session lineage. */
-export interface ContextCheckpointEntry {
-    /** Opaque stable ref; selection authority, never derived from the name. */
-    readonly checkpointRef: AgentTeamContextCheckpointRef;
-    /** Display label supplied by the model. */
-    readonly name: string;
-    /** Seq of the successful tool result that recorded the checkpoint. */
-    readonly resultSeq: number;
-    /** Turn the checkpoint concluded; the completed-turn boundary anchor. */
-    readonly turn: number;
-    /** Seq of the `turn/end` that resolved the checkpoint; -1 until resolved. */
-    readonly turnEndSeq: number;
-}
-/** Arguments the model passed to one successful rollover call. */
-export interface RolloverToolArguments {
-    readonly handoff: string;
-    readonly checkpointRef?: AgentTeamContextCheckpointRef | undefined;
-    readonly relatedFiles: readonly {
-        readonly path: string;
-        readonly reason: string;
-    }[];
-}
-/** Rollover intent waiting for the containing turn to finish and the Agent to idle. */
-export interface PendingRolloverIntent extends RolloverToolArguments {
-    /** The provider-issued call id of the successful rollover call. */
-    readonly toolCallId: string;
-    /** Seq of the successful rollover tool result. */
-    readonly resultSeq: number;
-    /** Turn containing the successful call; the swap waits for its end. */
-    readonly turn: number;
-    /** Seq of the `turn/end` that released the intent for the swap; -1 until observed. */
-    readonly turnEndSeq: number;
-}
-/** Quiet-continuation delivery state for one checkpoint, keyed by checkpointRef. */
-export interface ContinuationDeliveryState {
-    /** The checkpoint the continuation follows. */
-    readonly checkpointRef: AgentTeamContextCheckpointRef;
-    /** Seq of the delivered continuation notice in this Session; -1 until delivered. */
-    readonly deliveredSeq: number;
-}
-/** One non-Team message queued after the pending intent; a carry candidate. */
-export interface CarriedCandidate {
-    /** The queued message itself, verbatim. */
-    readonly message: UserMessage;
-    /** The turn that surfaced the message onto the model-visible input, if any. */
-    readonly surfacedTurn: number;
-    /** Whether a completed assistant answer proved the old generation handled it. */
-    readonly consumed: boolean;
-}
-/** State of the `agentTeamContext` projection for one Session. */
-export interface AgentTeamContextProjectionState {
-    /** Checkpoints recorded by a successful call, resolved ones anchored to their turn end. */
-    readonly checkpoints: readonly ContextCheckpointEntry[];
-    /** Rollover intent awaiting its containing turn end, at most one. */
-    readonly pending: PendingRolloverIntent | null;
-    /** Quiet continuations recorded (with or without delivery), keyed by checkpoint ref. */
-    readonly continuations: readonly ContinuationDeliveryState[];
-    /**
-     * Non-Team messages queued into the inbox after the pending intent's tool
-     * result. The durable `agent/inbox/spliced` log is the truth: the
-     * transition delivers every candidate the old generation never answered
-     * (a claimed-but-rejected or canceled message stays a candidate), deduped
-     * by message id. Empty until an intent exists.
-     */
-    readonly carriedCandidates: readonly CarriedCandidate[];
-    /** The most recently opened turn; user/message events carry no turn of their own. */
-    readonly lastTurn: number;
-    /**
-     * Context-tool calls whose results have not landed yet. Part of the state so
-     * the live unit folds one event at a time and still pairs call to result; a
-     * dangling call at any cut simply never becomes intent or a checkpoint.
-     */
-    readonly openCalls: readonly {
-        readonly callId: string;
-        readonly name: string;
-        readonly arguments: string;
-    }[];
-    /**
-     * Timeline boundaries beyond explicit checkpoints, resolved to their
-     * containing completed turn: handoff deliveries (each generation begins
-     * with one), compaction notices, and Team semantic facts that entered
-     * model context (successful claim-state tool results or structured Team
-     * notification delivery). Each is a structural timeline candidate with the
-     * same completed-turn anchor contract as a checkpoint.
-     */
-    readonly boundaries: readonly TimelineBoundary[];
-    /**
-     * Threads whose first delivery already anchored a boundary. The first
-     * arrival of a Thread's facts is the one preserved push-face anchor; every
-     * later re-delivery of the same Thread is noise and produces no boundary.
-     * Fold-internal by design: cold and live folds replay it identically from
-     * the event log, so no query-time rescan exists.
-     */
-    readonly seenThreads: readonly string[];
-    /** Seq of the latest resolved `turn/end`; the head boundary of the timeline. */
-    readonly lastTurnEndSeq: number;
-}
-/** One non-checkpoint timeline candidate resolved at a completed turn. */
-export interface TimelineBoundary {
-    /** Stable identity for the timeline: kind plus the anchoring event seq. */
-    readonly key: string;
-    /** Which structural source produced this boundary. */
-    readonly source: 'team-boundary' | 'handoff' | 'compaction';
-    /** Human-facing label derived from the boundary's own data. */
-    readonly label: string;
-    /** Seq of the boundary's own anchoring event (delivery or tool result). */
-    readonly seq: number;
-    /** Turn the boundary landed in. */
-    readonly turn: number;
-    /** Seq of the `turn/end` that resolved it; -1 until resolved. */
-    readonly turnEndSeq: number;
-}
-declare module '@deepseek-ai/dsh-session-projection/types' {
-    interface SessionProjectionStateMap {
-        agentTeamContext: AgentTeamContextProjectionState;
-    }
-}
+/** Every recorded tool name a rollover call may carry, current name first. */
+export declare const TEAM_ROLLOVER_TOOL_NAMES: readonly string[];
 /**
  * Deterministic checkpoint ref from the recording session and tool call
  * identity: a bounded, collision-resistant opaque token. Provider call ids
@@ -166,8 +57,8 @@ declare module '@deepseek-ai/dsh-session-projection/types' {
  */
 export declare function checkpointRefFor(sessionId: string, callId: string): AgentTeamContextCheckpointRef;
 /**
- * Deterministic default-boundary ref for one delivered Team boundary: the
- * same session-scoped hash shape as checkpoint refs, keyed on the boundary's
+ * Deterministic boundary ref for one delivered Team boundary: the same
+ * session-scoped hash shape as checkpoint refs, keyed on the boundary's
  * anchoring event seq. Consecutive generations routinely repeat event seqs,
  * so the Session identity must be part of the key or two generations'
  * boundaries at the same seq collide — the timeline would silently drop the
@@ -175,53 +66,107 @@ export declare function checkpointRefFor(sessionId: string, callId: string): Age
  */
 export declare function boundaryRefFor(sessionId: string, seq: number): AgentTeamContextCheckpointRef;
 /**
- * Cold-fold one immutable event log into the projection state. Events at or
- * before `inheritedEventCount` belong to the fork prefix and are resolved
- * history in this Session, so they never produce fresh intent. `sessionId` is
- * the log's own Session identity — it keys checkpoint refs, so the same
- * provider call id in two different Sessions produces two distinct refs.
+ * Whether one queued message is a Team-owned notice the rederived Inbox
+ * replaces. Handoff and continuation envelopes carry the same plugin
+ * attribution but are ordinary delivered context the new generation keeps, so
+ * they are excluded rather than dropped.
  */
-export declare function foldContextProjection(events: readonly SessionEvent[], inheritedEventCount?: SessionLogOffset, sessionId?: string): AgentTeamContextProjectionState;
+export declare function isTeamNotice(message: UserMessage): boolean;
+/** What Team's fold needs from the rest of the Host. */
+export interface TeamContextProjectionOptions {
+    /**
+     * Resolve the Thread one Task's facts belong to, for claim-boundary
+     * attribution. Absent (or returning undefined) leaves the boundary
+     * unattributed: it still anchors the timeline, it is simply not selectable
+     * as a single-Thread return target.
+     */
+    readonly threadForTask?: (taskRef: AgentTeamTaskRef) => AgentTeamThreadRef | undefined;
+}
 /**
- * The same fold as {@link foldContextProjection}, as the `{ start, step }` pair
- * the incremental Session cursor consumes. The cursor route and the cold fold
- * therefore share one transition function: a Session's projection cannot
- * depend on which of the two read it.
+ * Team's domain half of the context-continuity projection. Every method is a
+ * pure judgement over the event the engine hands it plus Team's own durable
+ * vocabulary; the engine keeps the state machine.
  */
-export declare const contextProjectionFold: (sessionId: string) => SessionEventFold<AgentTeamContextProjectionState, SessionEvent>;
+export declare class TeamContextProjectionHost implements ContextProjectionHost {
+    private readonly options;
+    constructor(options?: TeamContextProjectionOptions);
+    /** Durable checkpoint ref: Team's existing log vocabulary, unchanged. */
+    checkpointRefFor(sessionId: string, toolCallId: string): AgentTeamContextCheckpointRef;
+    /** Durable boundary ref: the same session-scoped hash shape. */
+    boundaryRefFor(sessionId: string, seq: number): AgentTeamContextCheckpointRef;
+    /** A Team-owned notice the successor generation rederives from ledger facts. */
+    isEphemeralNotice(message: UserMessage): boolean;
+    /**
+     * Only a Team-effect call that can produce a boundary is tracked at all:
+     * `list` on a claim, `read` on a Thread, and `dm` are not semantic timeline
+     * candidates, so their results must never open an anchor.
+     */
+    tracksCall(name: string, raw: string): boolean;
+    /** Team's boundary for one event, or undefined when the event anchors nothing. */
+    domainBoundaryOf(input: DomainBoundaryInput): DomainBoundaryContribution | undefined;
+    /**
+     * Structural boundary from one delivered user message: a rollover handoff
+     * starts a generation; a compaction notice rewrites the visible surface. A
+     * structured Team notification is a boundary ONLY on the first arrival of
+     * each Thread's facts into this Session — the preserved "work just arrived"
+     * anchor; every later re-delivery of the same Thread is noise. Reminder
+     * notices (progress nudges, recovery instructions) never anchor. Plain
+     * Human/agent prose and quiet checkpoint continuations are not boundaries.
+     */
+    private boundaryFromUserMessage;
+    /**
+     * Effect boundary from one successful Team-effect call — the attribution
+     * matrix: claim mutation → the Thread its Task was created in (resolved
+     * through the ledger, whose binding is immutable); team_message committed →
+     * the Thread from the call arguments or, for a start, from the structured
+     * presentation meta (`kind === 'committed'` guards every typed rejection; no
+     * meta means no boundary — old logs refold without start anchors by design,
+     * never by parsing render text); team_thread follow/unfollow → the threadRef
+     * from its call arguments. An unresolvable attribution leaves the boundary
+     * anchored but not single-Thread selectable.
+     */
+    private boundaryFromToolResult;
+}
 /**
- * The host-only projection unit; no wire view is published. The definition is
- * a factory: each Session folds with its own identity so checkpoint refs
- * derive from that Session's exact `(sessionId, callId)` pairs.
+ * The engine fold configured for Team: the codec Team's durable envelopes are
+ * written with, Team's projection host, and every recorded rollover name
+ * (current and legacy). One config drives both the registered unit and every
+ * cold fold, so a replayed log and the live unit converge on one state.
  */
-export declare const agentTeamContextProjectionDefinition: (sessionId: string) => ProjectionDefinition<"agentTeamContext", AgentTeamContextProjectionState>;
-/** The carried input one transition must deliver: unconsumed post-intent candidates, in queue order. */
-export declare function carriedInputOf(state: AgentTeamContextProjectionState): readonly UserMessage[];
-/** Whether a quiet continuation for one checkpoint was already delivered in this Session. */
-export declare function continuationDelivered(state: AgentTeamContextProjectionState, checkpointRef: AgentTeamContextCheckpointRef): boolean;
-/** Record that a continuation for one checkpoint is scheduled (delivery not yet seen). */
-export declare function withScheduledContinuation(state: AgentTeamContextProjectionState, checkpointRef: AgentTeamContextCheckpointRef): AgentTeamContextProjectionState;
-export { isCheckpointContinuationMessage };
-/** One structural timeline candidate, projection view: anchor plus identity. */
-export interface TimelineCandidate {
-    /** Stable selection ref (checkpoint refs for agent checkpoints; the boundary key otherwise). */
-    readonly ref: string;
-    /** Semantic label: the model-supplied checkpoint name or the boundary label. */
-    readonly label: string;
-    /** Which structural source produced this candidate. */
-    readonly source: 'agent' | 'team-boundary' | 'handoff' | 'compaction' | 'head';
-    /** Seq of the anchoring event (the tool result or delivery message). */
-    readonly seq: number;
-    /** Seq of the completed `turn/end` that resolved the candidate; -1 while unresolved. */
-    readonly turnEndSeq: number;
-}
+export declare function createTeamContextProjectionConfig(host: ContextProjectionHost): ContextProjectionConfig;
+/**
+ * Cold-fold one immutable Team Session log through the engine's fold with
+ * Team's config. The registered unit uses the same config, so the two agree.
+ */
+export declare function foldTeamContextProjection(events: readonly SessionEvent[], target: ContextFoldTarget, host?: ContextProjectionHost): ContextProjectionState;
+/**
+ * The host-only projection unit for Team Members. Register it **once per
+ * Host**: the framework keeps one unit per projection key and drives it for
+ * every Session, so the definition closes over no Session identity.
+ */
+export declare function createTeamContextProjectionDefinition(host: ContextProjectionHost): ReturnType<typeof createContextProjectionDefinition>;
 /**
- * Bounded structural timeline candidates, newest first: explicit checkpoints
- * (resolved only), structural boundaries, then the current head. The Host
- * prices retained/discarded tokens and applies restorability guards on top;
- * this view is the single source of candidate anchors and labels.
+ * The Threads Team's own fold attributed to boundaries resolved by one
+ * completed turn, order-stable and deduplicated: a delivered notice's first
+ * arrival, a claim mutation's Task→Thread binding, a committed Thread effect.
+ *
+ * This is the accumulated attribution of the RETAINED PREFIX through that
+ * turn, and it is one set with two readers — the timeline publishes it as the
+ * item's affected Threads, and the rollover guard refuses a boundary whose
+ * prefix spans more than one Thread, so a ref the timeline offers is a ref
+ * `context_rollover` accepts.
  */
-export declare function timelineCandidates(state: AgentTeamContextProjectionState, limit: number): readonly TimelineCandidate[];
+export declare function retainedTopicsThrough(state: ContextProjectionState, turnEndSeq: number): readonly string[];
 /** Find one resolved checkpoint entry by its stable ref, if it exists. */
-export declare function checkpointByRef(state: AgentTeamContextProjectionState, checkpointRef: string): ContextCheckpointEntry | undefined;
+export declare function checkpointByRef(state: ContextProjectionState, checkpointRef: string): ContextCheckpointEntry | undefined;
+/** Whether one engine-held boundary is the recorded anchor of `ref` in this state's Session. */
+export declare function boundaryByRef(state: ContextProjectionState, ref: string): DomainBoundary | undefined;
+/**
+ * The carried input one transition must deliver: unconsumed post-intent
+ * candidates in queue order, resolved to their durable message bodies. The
+ * engine keys carry candidates by message id (that is what the transition
+ * dedupes on); the `agent/inbox/spliced` events that recorded them are where
+ * the message itself lives, so the log stays the only authority.
+ */
+export declare function carriedInputOf(state: ContextProjectionState, events: readonly SessionEvent[]): readonly UserMessage[];
 //# sourceMappingURL=context-projection.d.ts.map

package/packages/agent-team/lib/types/context-projection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context-projection.d.ts","sourceRoot":"","sources":["../../src/context-projection.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"context-projection.d.ts","sourceRoot":"","sources":["../../src/context-projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EACL,4BAA4B,EAC5B,0BAA0B,EAC1B,iCAAiC,EAEjC,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,0BAA0B,EAC/B,KAAK,mBAAmB,EACzB,MAAM,kCAAkC,CAAA;AAGzC,OAAO,KAAK,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AA8C9G,kFAAkF;AAClF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED,uEAAuE;AACvE,OAAO,EAAE,4BAA4B,EAAE,0BAA0B,EAAE,CAAA;AAEnE;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,gBAAgB,CAAA;AAElD,8EAA8E;AAC9E,eAAO,MAAM,wBAAwB,EAAE,SAAS,MAAM,EAAwD,CAAA;AAE9G;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,6BAA6B,CAEjG;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,6BAA6B,CAE5F;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAG1D;AAyDD,wDAAwD;AACxD,MAAM,WAAW,4BAA4B;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,kBAAkB,GAAG,SAAS,CAAA;CACvF;AAED;;;;GAIG;AACH,qBAAa,yBAA0B,YAAW,qBAAqB;IACzD,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,GAAE,4BAAiC;IAEvE,yEAAyE;IACzE,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,6BAA6B;IAItF,gEAAgE;IAChE,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,6BAA6B;IAI7E,gFAAgF;IAChF,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO;IAIhD;;;;OAIG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAO9C,kFAAkF;IAClF,gBAAgB,CAAC,KAAK,EAAE,mBAAmB,GAAG,0BAA0B,GAAG,SAAS;IAMpF;;;;;;;;OAQG;IACH,OAAO,CAAC,uBAAuB;IAwB/B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,sBAAsB;CAyB/B;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,qBAAqB,GAAG,uBAAuB,CAOtG;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,SAAS,YAAY,EAAE,EAC/B,MAAM,EAAE,iBAAiB,EACzB,IAAI,GAAE,qBAAuD,GAC5D,sBAAsB,CAExB;AAED;;;;GAIG;AACH,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,qBAAqB,GAAG,UAAU,CAAC,OAAO,iCAAiC,CAAC,CAEvI;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAS1G;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS,CAExH;AAED,gGAAgG;AAChG,wBAAgB,aAAa,CAAC,KAAK,EAAE,sBAAsB,EAAE,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEpG;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,sBAAsB,EAAE,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,WAAW,EAAE,CAcrH"}

package/packages/agent-team/lib/types/context-source.d.ts

@@ -1,10 +1,14 @@
 /**
- * Producer-attributed message sources for Agent Team context management.
+ * Plugin-attributed message sources for Agent Team context management.
  *
- * Both sources ride ordinary `UserMessage`s under this plugin's own
- * producer kind with the `snapshot` context form — Session format V4 admits
- * exactly that shape and refuses the retired `{ kind: 'plugin', plugin: … }`
- * wrapper at write time. See `docs/dsh-release-compatibility.md`
+ * Both sources ride ordinary `UserMessage`s under the shipped `plugin` kind
+ * with the `snapshot` context form — the same shape the Harness's own
+ * system-prompt producer writes. This module declares no `MessageSourceMap`
+ * member of its own, and carries no bespoke source members: Session format
+ * migration validates a `plugin` source against a closed member list
+ * (`kind`, `plugin`, `form`, `sections`, `summary`), and refuses every logged
+ * Session that carries anything else. A plugin-declared kind is type-legal yet
+ * refused the same way. See `docs/dsh-release-compatibility.md`
  * § "Session message sources".
  *
  * Everything the Host needs to read back therefore rides the admitted payload
@@ -15,55 +19,19 @@
  * snapshot-aware surface.
  *
  * The validators below are the single place that recognizes these messages, so
- * callers never match on localized body text.
+ * callers never match on localized body text. Writing them belongs to the
+ * context-continuity engine's codec, which Team constructs with its own plugin
+ * identity and prose (`context-continuity-host.ts`): one writer, so the
+ * envelope Team reads back can never drift from the one it wrote.
  * @module @wowyuarm/dsh-agent-team/context-source
  */
-import type { ContextFormed, ContextSnapshotSection, MessageSource, UserMessage } from '@deepseek-ai/dsh-llm';
-/** The producer kind attributing every Agent Team message source. */
+import type { ContextSnapshotSection, UserMessage } from '@deepseek-ai/dsh-llm';
+/** Plugin identity attributing every Agent Team message source. */
 export declare const AGENT_TEAM_PLUGIN_ID = "@wowyuarm/dsh-agent-team";
-/**
- * The kind the Harness's V4 read-time conversion renames this plugin's
- * released V3 `plugin` sources into: `plugin:` + the producer id, with the
- * `plugin` key dropped and every payload field (`form`, `sections`,
- * `summary`) preserved. History read through the new line carries exactly
- * this shape, so the read side recognizes both identities below.
- */
-export declare const AGENT_TEAM_V3_RENAMED_KIND = "plugin:@wowyuarm/dsh-agent-team";
-declare module '@deepseek-ai/dsh-llm' {
-    interface MessageSourceMap {
-        /** The kind this plugin writes now; V4 admission requires a producer-owned kind. */
-        [AGENT_TEAM_PLUGIN_ID]: {
-            kind: typeof AGENT_TEAM_PLUGIN_ID;
-        } & ContextFormed;
-        /** The converted shape of this plugin's released V3 history; read-side only. */
-        [AGENT_TEAM_V3_RENAMED_KIND]: {
-            kind: typeof AGENT_TEAM_V3_RENAMED_KIND;
-        } & ContextFormed;
-    }
-}
-/** The source shapes carrying this plugin's attribution: its current kind and the read-time conversion of its V3 history. */
-export type AgentTeamMessageSource = Extract<MessageSource, {
-    kind: typeof AGENT_TEAM_PLUGIN_ID | typeof AGENT_TEAM_V3_RENAMED_KIND;
-}>;
-/** The kind the read-time conversion renames one producer's released V3 sources into. */
-export declare const v3RenamedSourceKind: <const P extends string>(producer: P) => `plugin:${P}`;
-/**
- * Whether one message source carries this plugin's own attribution. Both
- * identities are matched by exact kind equality — never by a `plugin:`
- * prefix test, which would claim third-party producers' rows as Team facts.
- */
-export declare function isAgentTeamSource(source: MessageSource): source is AgentTeamMessageSource;
-/**
- * Whether one source kind carries this plugin's attribution, for call sites
- * whose sources arrive untyped. Exact identities only, never a prefix test.
- */
-export declare function isAgentTeamSourceKind(kind: string | undefined): boolean;
 /** Handoff snapshot section name carrying the model-authored prose. */
 export declare const HANDOFF_SECTION_NAME = "HANDOFF";
 /** Stable section name marking a checkpoint continuation and carrying its ref. */
 export declare const CHECKPOINT_SECTION_NAME = "Checkpoint";
-/** Fixed text of the quiet checkpoint continuation delivered on the next turn. */
-export declare const CHECKPOINT_CONTINUATION_TEXT = "A context checkpoint was recorded at the end of the previous turn. Continue the work you were doing.";
 /**
  * The rollover handoff envelope: the model-authored prose plus the verifiable
  * Host facts, all as named snapshot contributions.
@@ -84,38 +52,6 @@ export interface AgentTeamContextHandoff {
     /** Named contributions, starting with the model-authored handoff prose. */
     readonly sections: readonly ContextSnapshotSection[];
 }
-/**
- * Build the first model-facing context of one rollover generation. The Host
- * owns only the verifiable envelope; the prose is the Member's own handoff.
- *
- * The envelope sections are additive structure, not the only carrier of these
- * facts: {@link handoffBody} already states them in the model-facing text, so a
- * surface that renders only the body loses nothing.
- */
-export declare function createHandoffMessage(input: {
-    readonly handoff: string;
-    readonly previousSessionId: string;
-    readonly newSessionId: string;
-    readonly trigger: 'model' | 'pressure';
-    readonly handoffEventSeq: number;
-    readonly checkpointRef?: string;
-    readonly relatedFiles?: readonly {
-        readonly path: string;
-        readonly reason?: string;
-    }[];
-}): UserMessage;
-/**
- * Build the quiet follow-up that continues work after an explicit checkpoint
- * concluded its turn. Delivery is scheduled only after the checkpoint's
- * successful tool result is durable, so a result-render failure can never
- * leave a ghost continuation behind.
- *
- * This is a `snapshot` rather than a `notice` for one reason: the projection
- * must read the checkpoint ref back out of the durable log to record delivery,
- * and `sections` is the only admitted payload slot that carries structure. A
- * notice would have forced the ref into its human-readable one-line summary.
- */
-export declare function createCheckpointContinuationMessage(checkpointRef: string): UserMessage;
 /**
  * The rollover handoff one message carries, when it is one.
  * @param message - candidate user message.
@@ -139,8 +75,8 @@ export declare function isCheckpointContinuationMessage(message: UserMessage, ch
  */
 export declare function isAgentTeamContextSource(message: UserMessage): boolean;
 /** Envelope section names; stable, because they are read back from the log.
- * One shared vocabulary for writer and reader — no drift between the shape
- * published at rollover and the shape the projection folds back. */
+ * Exported for the legacy-artifact remediation, which rewrites pre-0.1.10
+ * envelopes into exactly these names — one shared vocabulary, no drift. */
 export declare const HANDOFF_PREVIOUS_SESSION = "Previous session";
 export declare const HANDOFF_NEW_SESSION = "New session";
 export declare const HANDOFF_TRIGGER = "Trigger";

package/packages/agent-team/lib/types/context-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context-source.d.ts","sourceRoot":"","sources":["../../src/context-source.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"context-source.d.ts","sourceRoot":"","sources":["../../src/context-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAE/E,mEAAmE;AACnE,eAAO,MAAM,oBAAoB,6BAA6B,CAAA;AAE9D,uEAAuE;AACvE,eAAO,MAAM,oBAAoB,YAAY,CAAA;AAE7C,kFAAkF;AAClF,eAAO,MAAM,uBAAuB,eAAe,CAAA;AAEnD;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,iDAAiD;IACjD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAClC,mDAAmD;IACnD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,iCAAiC;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAAA;IACtC,wFAAwF;IACxF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,2EAA2E;IAC3E,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B,0DAA0D;IAC1D,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACzC,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,SAAS,sBAAsB,EAAE,CAAA;CACrD;AAsCD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,uBAAuB,GAAG,SAAS,CAwBnF;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAKpF;AAED,+DAA+D;AAC/D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAE9D;AAED,4FAA4F;AAC5F,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAGrG;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAEtE;AAED;;2EAE2E;AAC3E,eAAO,MAAM,wBAAwB,qBAAqB,CAAA;AAC1D,eAAO,MAAM,mBAAmB,gBAAgB,CAAA;AAChD,eAAO,MAAM,eAAe,YAAY,CAAA;AACxC,eAAO,MAAM,iBAAiB,sBAAsB,CAAA;AACpD,eAAO,MAAM,kBAAkB,8BAA8B,CAAA;AAC7D,eAAO,MAAM,qBAAqB,kBAAkB,CAAA"}