@llblab/pi-state-flow 0.9.1 → 0.9.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/AGENTS.md CHANGED
@@ -22,7 +22,7 @@
22
22
  - Read and write only regular non-symlink State Flow-owned files at those exact paths, publish each file by same-directory atomic rename, preserve arbitrary repository contents, and classify ownership exactly; never use repository-wide staging. Retain opaque source bytes for file identity and rollback, not decoded-text reconstructions. Use validated structural JSON equality for in-process semantic comparisons; reserve cryptographic hashes for compact identities that cross inference, persistence, process, or source-freshness boundaries. Serialize cooperating Git publications through a common-Git-directory publication lock; low-level file helpers require caller exclusion. Recheck prepared bases before each replacement/deletion and restore only bytes still matching the publisher's own output. Preserve detected concurrent changes and report unresolved rollback conflicts; do not claim kernel-atomic multi-file CAS against nonparticipating writers. Markdown discovery uses its independently configured source root, defaulting to `knowledge/` beneath Pi's agent directory; a storage-root override must not redirect source discovery.
23
23
  - At instance initialization resolve the repository, CWD key, and session key; load each scope's anchored checkpoint and tail, materialize at the selected temporal boundary, then overlay `global → cwd → session`. Install cached view and publication basis atomically only after successful restoration/initialization; unavailable publication is an error, not a semantic no-op. Preserve the selected revision across transient restore failure so an explicit start can retry it. A genuinely new session gets an empty session layer and inherits only global/CWD values; it must never reuse another same-CWD session layer.
24
24
  - Bind every loaded scope and active Pi branch/checkpoint to the corresponding State Flow Git revision. Resume and tree restoration must recover branch-correct runtime config and semantic layers from that revision without blindly importing Git `HEAD`; reading an older revision must use object-level Git reads and never reset or check out the shared repository worktree.
25
- - Every accepted semantic change, including session-only and response-only changes, atomically updates affected checkpoint/tail pairs and temporal metadata and creates one immediate local Git commit when Git is available; each commit stages the complete non-ignored worktree delta (`git add -A` semantics, including manual deletions) before overlaying exact prepared State Flow outputs, respects `.gitignore`, keeps State Flow-owned active files under compare-and-swap protection, and synchronizes the caller-visible index to the committed tree. `remotePublication` is branch runtime policy: `turn-end` queues only the newest accepted target for asynchronous non-interactive push, `off` remains local-only, and `transition` preserves synchronous legacy behavior. Queue state is operational metadata beneath the Git common directory, not semantic history; use exact targets, destination identity, symlink-safe atomic CAS, descendant-only coalescing, cross-process worker leases, restart recovery, and truthful failure diagnostics. Remote failure never rolls back accepted state or regenerates an answer. A repository with no remote is intentionally local-only; only Git executable `ENOENT` authorizes file-only mode.
25
+ - Every accepted semantic change, including session-only and response-only changes, atomically updates affected checkpoint/tail pairs and temporal metadata and creates one immediate local Git commit when Git is available; each commit stages the complete non-ignored worktree delta (`git add -A` semantics, including manual deletions) before overlaying exact prepared State Flow outputs, respects `.gitignore`, keeps State Flow-owned active files under compare-and-swap protection, and synchronizes the caller-visible index to the committed tree. `remotePublication` is branch runtime policy: `turn-end` queues only the newest accepted target for asynchronous non-interactive push, `off` remains local-only, and `transition` preserves synchronous legacy behavior. Queue state is operational metadata beneath the Git common directory, not semantic history; use exact targets, destination identity, symlink-safe atomic CAS, descendant coalescing with lineage-rewrite recovery that retargets the live commit, cross-process worker leases, restart recovery, and truthful failure diagnostics. Remote failure never rolls back accepted state or regenerates an answer. A repository with no remote is intentionally local-only; only Git executable `ENOENT` authorizes file-only mode.
26
26
  - Register `patch_state` as the sole model-authored semantic mutation protocol. It accepts optional fixed `global`, `cwd`, and `session` semantic patches plus optional `final:true`; require at least one scope or `final:true`, reject unknown fields, `final:false`, empty supplied scopes, material no-ops, and the retired `{scope, patch}` / `unchanged` grammar. Validate every supplied scope against one causal basis and publish it all-or-nothing with one identity, temporal boundary, and durable cohort. Never accept model-authored `response`.
27
27
  - Treat every semantic `patch_state` as a strict inference barrier. Give it sequential execution mode, inspect Pi's synchronized current assistant message during tool preflight, require exactly one `patch_state` call in that response, and block every sibling tool call before execution. Every enabled iteration begins terminal-ineligible; only a successful call containing `final:true` latches eligibility for the next accepted `turn_end`, without stopping later reasoning, tools, or patches. If a terminal draft ends before eligibility, preserve it as the runtime-owned response at that `turn_end` and start at most two same-run fallback turns whose only purpose is the `final:true` patch; an eligible draft whose final validation fails after a later acquisition follows the same path. Fallback turns never enter `response`, and their only instruction is to apply `patch_state` with any durable changes and `final:true`, or `{final:true}` alone. A successful fallback closes resolution with the preserved answer intact; two failed fallbacks close the iteration with the preserved answer and current state plus one bounded warning and a finalization diagnostic. Failed patch calls do not consume fallback turns. A subsequent legal patch remains possible, and only an accepted ordinary answer is reconciled.
28
28
  - Reconcile `response` only from the actually accepted ordinary assistant answer at `turn_end`; it remains runtime-owned. State Flow has no terminal HTML-comment mutation protocol and does not parse generic service comments. The first terminal draft that cannot be reconciled is preserved as the iteration response rather than discarded; fallback turns during pending resolution never reach `response`. Other extensions retain ownership of their own comments and output handling.
@@ -43,7 +43,7 @@
43
43
  - `/state-flow-stop` must persist only the current session/branch's `config.enabled = false` and necessary runtime provenance, preserving all semantic checkpoints/tails and creating no semantic transition. It must retain a same-physical-session bounded passive context handoff across reload, resume, and tree restoration so disabling semantics never re-exposes pre-stop raw history. Active restart replaces passive mode but uses that bounded boundary for its one migration run; new and forked physical sessions inherit neither projection. It does not rewrite agent-level `autoStart` or change its policy for future new sessions.
44
44
  - Keep the injected runtime protocol compact and normative; put rationale and extended explanation in README rather than the model prompt. Never parse or strip State Flow HTML comments; they are ordinary historical text, while foreign comment handling remains owned by other extensions.
45
45
  - Do not claim strict boundedness for state, the current run trajectory, the turn specification, or the external full trace.
46
- - Remain extension-agnostic in core semantics, storage, and inference: core modules never import, name, special-case, or encode policy for another extension or transport. One optional leaf presentation adapter (`lib/telegram.ts`) may import public `pi-telegram` membranes to mirror status and expose the same start/stop affordances already owned by `state-flow-start` and `state-flow-stop`; it must fail open when the transport is absent or its registry is unready and must never alter core behavior.
46
+ - Remain extension-agnostic in core semantics, storage, and inference: core modules never import, name, special-case, or encode policy for another extension or transport. One optional leaf presentation adapter (`lib/telegram.ts`) may import public `pi-telegram` membranes to mirror the live status on exactly one main-menu section button and expose the same start/stop affordances already owned by `state-flow-start` and `state-flow-stop`; it must fail open when the transport is absent or its registry is unready and must never alter core behavior.
47
47
  - Activate State Flow model tools only while enabled on the selected branch; preserve every unrelated active tool when toggling them. Keep mutation confined to `patch_state` and historical observation read-only.
48
48
  - Keep `.github/workflows/release.yml` as the sole version-tag release owner: it validates immutable tag identity, publishes through npm Trusted Publisher with provenance, verifies the public package, and only then creates the GitHub Release. Keep package, lockfile, tag, and changelog versions aligned; never add a long-lived npm token fallback.
49
49
  - Run `npm run validate` after retained code changes.
package/CHANGELOG.md CHANGED
@@ -2,6 +2,15 @@
2
2
 
3
3
  > Each release keeps at most 8 outcome records of at most 512 characters.
4
4
 
5
+ ## 0.9.3: Publication queue lineage-rewrite hotfix
6
+
7
+ - `Publication`: Retarget a queued target orphaned by a journal reset or re-initialization to the live lineage and keep publishing, instead of failing every `turn_end` with "Publication queue targets diverge"; the retired commit stays in local Git history.
8
+ - `Diagnostics`: Record the retired target in opt-in diagnostics and report a deferred remote publication accurately instead of claiming the final response could not be reconciled.
9
+
10
+ ## 0.9.2: Single Telegram surface
11
+
12
+ - `Interop`: State Flow now appears on Telegram exactly once. The inline main-menu section button before Settings carries the live status (`🌀 State Flow: #N`, `⚫️ State Flow` while off) and opens the existing start/stop submenu; the duplicated Status-screen row is removed, so the same value no longer renders in two places. Fail-open registration and shutdown disposal are unchanged.
13
+
5
14
  ## 0.9.1: Status text mirrors the terminal line
6
15
 
7
16
  - `Interop`: The `pi-telegram` surfaces now copy the compact terminal status instead of decorating it. The Status screen shows the terminal value itself (`State Flow: #N`) and hides entirely while State Flow is off; the main-menu button shows `🌀 State Flow: #N` or a plain `⚫️ State Flow` without on/off, starting, bootstrap, or separator text.
package/README.md CHANGED
@@ -66,7 +66,7 @@ Stopping changes the current session/branch configuration, preserves semantic ch
66
66
 
67
67
  The compact status is an accent `state-flow` and dim `#<step>`. Detailed status distinguishes runtime config/meta from semantic materialization, reports scope keys, the selected temporal head and runtime revision, available hot offsets, per-scope retained patch tails, artifact counts, stale Markdown reasons, and pending publication. Retained tails may include inherited pre-origin records, so their counts are not active history depth. It labels global/CWD/session/effective state without dumping source bodies. Failed inspection means unavailable evidence, never a falsely clean count.
68
68
 
69
- When the optional `pi-telegram` extension is installed, State Flow mirrors the same identity there: the Status screen shows `State Flow: #N` while enabled and hides the row while off, and the inline main menu places a `🌀 State Flow: #N` or `⚫️ State Flow` section button directly before Settings. The button opens a compact control submenu for the current session branch: `Start` or `Stop`, `Refresh`, and `Cancel start` while a start deferred behind an active run is pending. Starting while a run is active waits for that run to settle; stopping applies immediately. Registration fails open when the transport is absent, retries when the section registry becomes ready, and disposes on session shutdown; the `/state-flow-*` commands remain the authority and nothing changes for hosts without `pi-telegram`.
69
+ When the optional `pi-telegram` extension is installed, State Flow appears exactly once in Telegram: the inline main menu places a `🌀 State Flow: #N` or `⚫️ State Flow` section button directly before Settings, and that button's label carries the live status. The button opens a compact control submenu for the current session branch: `Start` or `Stop`, `Refresh`, and `Cancel start` while a start deferred behind an active run is pending. Starting while a run is active waits for that run to settle; stopping applies immediately. Registration fails open when the transport is absent, retries when the section registry becomes ready, and disposes on session shutdown; the `/state-flow-*` commands remain the authority and nothing changes for hosts without `pi-telegram`.
70
70
 
71
71
  ## State, scope, and time
72
72
 
@@ -175,7 +175,7 @@ Session `config.json` owns runtime behavior such as `enabled`. Session `meta.jso
175
175
 
176
176
  Git-backed Pi checkpoint data is exactly `{"revision":"<full commit hash>"}`; file-only checkpoints use `{"revision":"file:<64 lowercase hex>"}` for an exact current-cohort reference. `{"disabled":true}` denotes an ordinary disabled branch without durable runtime. Configuration, counters, specification, lineage, and semantic state are not copied into these entries. Older config/meta and state-bearing checkpoints remain read-only compatibility input. Invalid immutable pointer targets fall back through the selected branch; transient publication-lock failure instead retains the selected revision for retry. Explicit start on a pre-runtime branch establishes an empty session origin, even if a later branch already created same-session files. Shared streams remain unchanged and the later session state remains recoverable from its Git revision; it is not imported into the new origin. Legacy checkpoint syntax and immutable targets undergo the same fallback checks, while an unanchored legacy semantic payload cannot be silently reduced to an ordinary-disabled marker. Stop on an unproven branch fails visibly instead of turning failed recovery into permission to replace existing runtime; select a valid checkpoint before retrying.
177
177
 
178
- Every materially effective semantic transition, including response-only and session-only changes, immediately publishes affected checkpoint/tail pairs and necessary lineage metadata. In Git mode each accepted cohort gets its own consistent local commit; `turn-end` queues the newest target for asynchronous replication, `off` stays local, and compatibility `transition` attempts the push synchronously. Intermediate patches are not batched until turn end. With no remote configured, Git persistence is intentionally local-only, not a pending publication error. With Git absent, persistence remains file-only and does not report fake commits or pending pushes. One model-authored call may update global, CWD, and session together; every supplied scope shares one validation basis, transition identity, temporal boundary, and durable commit. Config-only changes may persist runtime state but never invent semantic transitions.
178
+ Every materially effective semantic transition, including response-only and session-only changes, immediately publishes affected checkpoint/tail pairs and necessary lineage metadata. In Git mode each accepted cohort gets its own consistent local commit; `turn-end` queues the newest target for asynchronous replication, `off` stays local, and compatibility `transition` attempts the push synchronously. A reset or re-initialized journal rewrites the lineage; the queue then retargets the live commit and keeps the retired one in local history instead of blocking later turns. Intermediate patches are not batched until turn end. With no remote configured, Git persistence is intentionally local-only, not a pending publication error. With Git absent, persistence remains file-only and does not report fake commits or pending pushes. One model-authored call may update global, CWD, and session together; every supplied scope shares one validation basis, transition identity, temporal boundary, and durable commit. Config-only changes may persist runtime state but never invent semantic transitions.
179
179
 
180
180
  Writes use regular non-symlink owned files, same-directory atomic rename, isolated Git indexes, and compare-and-swap against the reconciled base. Cooperating State Flow Git publishers hold a common-Git-directory publication lock through capture, commit, and rollback. Raw bytes own file identity and recovery; non-UTF-8 explanatory journals are not reconstructed from decoded strings. Per-file publication checks catch changed bases. Both semantic and migration publishers retain exact prepared-output receipts: Git commits those bytes, not later worktree contents, and rollback requires the receipt to preserve detected external changes rather than replacing them. Low-level file helpers require caller exclusion; this is not kernel-atomic multi-file CAS against writers ignoring the protocol. An existing publication lock fails before writes and is not silently stolen; reconcile its active or interrupted owner before retrying. Scope keys mirror Pi's CWD/session directory names and retain separately verified canonical identity provenance inside owned state. Conflicts fail rather than silently selecting another scope or auto-merging semantic state. Every Git commit stages the complete non-ignored worktree delta — tracked edits, new files, and manual deletions, respecting `.gitignore` — then overlays the exact prepared State Flow outputs and synchronizes the caller-visible index to the committed tree, so no artificial staged or unstaged entries remain; unrelated user worktree changes may therefore be committed while ignored files stay untouched. With distinct roots, the Knowledge repository's files, index, HEAD, locks, and remote are not used for state publication; keep custom stores separate from sources to retain this isolation.
181
181
 
@@ -132,7 +132,7 @@ The persisted `remotePublication` policy is:
132
132
 
133
133
  A destination is identified by canonical Git common directory, remote and full ref. Queue files live beneath the Git common directory and are not semantic history.
134
134
 
135
- The queue uses exact commit targets, strict versioned JSON, symlink-safe atomic writes, CAS receipts and exclusive writer locks. A proven descendant may supersede an older target; divergent targets and changed destinations fail closed.
135
+ The queue uses exact commit targets, strict versioned JSON, symlink-safe atomic writes, CAS receipts and exclusive writer locks. A proven descendant may supersede an older target; a journal lineage rewrite retargets the live commit and records the retired target, while changed destinations fail closed.
136
136
 
137
137
  After accepted response reconciliation, an asynchronous non-interactive worker pushes the newest target. Queue failure never rolls back semantic state or regenerates an answer. Failed and interrupted attempts remain retryable across restart. Destination-scoped worker leases prevent cross-process overlap, preserve live owners, recover proven-dead owners and use exact release tokens. Confirmation removes only the exact completed target; a newer descendant remains queued.
138
138
 
@@ -199,7 +199,7 @@ Unknown keys fail loading. State Flow memory ownership and global availability a
199
199
 
200
200
  `/state-flow-status` reports branch mode, runtime revision, temporal head/history depth, scope keys, patch tails, artifact freshness, memory-bearing scopes, external-promotion summaries, remote policy/queue state, and pending publication. Unavailable materialization is reported as unavailable, never fabricated as empty. Artifact source bodies are not read for status.
201
201
 
202
- With `pi-telegram` installed, the optional `telegram` adapter mirrors the same identity in Telegram: the Status screen row shows `State Flow: #N` while enabled and hides while off, and the main-menu section button before Settings opens the branch start/stop submenu. Registration is fail-open and retried on session start, disposal happens on session shutdown, the adapter reads the same snapshot as the compact terminal status, and its start/stop actions call the same functions as the commands.
202
+ With `pi-telegram` installed, the optional `telegram` adapter mirrors the same identity in Telegram: the main-menu section button before Settings carries the live `🌀 State Flow: #N` or `⚫️ State Flow` label and opens the branch start/stop submenu. Registration is fail-open and retried on session start, disposal happens on session shutdown, the adapter reads the same snapshot as the compact terminal status, and its start/stop actions call the same functions as the commands.
203
203
 
204
204
  Opt-in `logging` appends local JSONL diagnostics for rejected `patch_state` calls and preserved drafts plus fallback turns while turn resolution is pending. A rejected call retains its exact attempted arguments, the precise error, and, when available, tool identity, call id, resolution attempt, and terminal-eligibility state; accepted patches are never logged. Records preserve useful exact text blocks and reduce other blocks to structural identity without duplicating reasoning. They are never semantic state, scope `meta.json`, Pi checkpoints, or repository input. Write failure changes no resolution, enablement, or accepted state and reports at most one bounded local warning.
205
205
 
package/index.ts CHANGED
@@ -189,7 +189,6 @@ export {
189
189
  buildStateFlowSectionView,
190
190
  createStateFlowTelegramAdapter,
191
191
  formatStateFlowSectionLabel,
192
- formatStateFlowStatusLine,
193
192
  loadStateFlowTelegramModules,
194
193
  STATE_FLOW_TELEGRAM_ID,
195
194
  type StateFlowTelegramAdapter,
@@ -202,8 +201,6 @@ export {
202
201
  type StateFlowTelegramSectionContext,
203
202
  type StateFlowTelegramSectionModule,
204
203
  type StateFlowTelegramSnapshot,
205
- type StateFlowTelegramStatusLine,
206
- type StateFlowTelegramStatusModule,
207
204
  type StateFlowTelegramView
208
205
  } from "./lib/telegram.ts";
209
206
  export { advanceTemporalState, readTemporalState, type TemporalState } from "./lib/temporal.ts";
package/lib/extension.ts CHANGED
@@ -252,7 +252,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
252
252
  if (mode !== "turn-end" || target === undefined || !/^[0-9a-f]{40,64}$/.test(target)) return;
253
253
  turnPublicationTarget = target;
254
254
  try {
255
- enqueueTurnPublication();
255
+ enqueueTurnPublication(ctx);
256
256
  launchPublicationWorker();
257
257
  } catch (error) {
258
258
  ctx.ui.notify(
@@ -288,7 +288,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
288
288
  return true;
289
289
  }
290
290
 
291
- function enqueueTurnPublication(): void {
291
+ function enqueueTurnPublication(ctx: ExtensionContext): void {
292
292
  const target = turnPublicationTarget;
293
293
  turnPublicationTarget = undefined;
294
294
  if (!target) return;
@@ -297,7 +297,12 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
297
297
  const path = publicationQueuePath(destination);
298
298
  const previous = loadPublicationQueue(path);
299
299
  const next = previous
300
- ? coalescePublicationTarget(previous, destination, target, (ancestor, descendant) => isGitCommitAncestor(repositoryRoot, ancestor, descendant))
300
+ ? coalescePublicationTarget(previous, destination, target, (ancestor, descendant) => isGitCommitAncestor(repositoryRoot, ancestor, descendant), {
301
+ onDivergedLineage: (dropped) => recordDiagnostic(
302
+ `Retired publication queue target ${dropped.target} after a journal lineage rewrite; retargeting to ${target}`,
303
+ "publication-conflict", ctx,
304
+ ),
305
+ })
301
306
  : createPublicationQueue(destination, target);
302
307
  savePublicationQueue(path, next, previous);
303
308
  }
@@ -365,7 +370,7 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
365
370
  if (mode === "turn-end") {
366
371
  turnPublicationTarget = target;
367
372
  try {
368
- enqueueTurnPublication();
373
+ enqueueTurnPublication(ctx);
369
374
  launchPublicationWorker();
370
375
  } catch (error) {
371
376
  ctx.ui.notify(`State Flow retained local state; asynchronous publication recovery is deferred: ${error instanceof Error ? error.message : String(error)}`, "warning");
@@ -1035,17 +1040,21 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
1035
1040
  updateUi(ctx);
1036
1041
  return;
1037
1042
  }
1043
+ let responseCommitted = false;
1038
1044
  try {
1039
1045
  const response = finalizedAssistantResponse(event.message);
1040
1046
  const stage = stageScopedTransition(scopeStates, { transitions: [], response }, [], runtime!.causalBasis());
1041
1047
  commitStage(stage, ctx, true);
1048
+ responseCommitted = true;
1042
1049
  bootstrapContinuation = undefined;
1043
1050
  rehydrationPhase = "step";
1044
- enqueueTurnPublication();
1051
+ enqueueTurnPublication(ctx);
1045
1052
  if (snapshot.meta.remotePublication?.mode === "turn-end") launchPublicationWorker();
1046
1053
  } catch (error) {
1047
1054
  recordDiagnostic(error instanceof Error ? error.message : String(error), "finalization", ctx);
1048
- ctx.ui.notify(`State Flow could not reconcile the final response: ${error instanceof Error ? error.message : String(error)}`, "error");
1055
+ ctx.ui.notify(responseCommitted
1056
+ ? `State Flow committed the final response; remote publication is deferred: ${error instanceof Error ? error.message : String(error)}`
1057
+ : `State Flow could not reconcile the final response: ${error instanceof Error ? error.message : String(error)}`, "error");
1049
1058
  } finally {
1050
1059
  responseAwaitingReconciliation = false;
1051
1060
  }
@@ -81,13 +81,26 @@ export function createPublicationQueue(destination: RemotePublicationDestination
81
81
  return { version: 1, destination: structuredClone(destination), target, status: "pending", attempt: 0 };
82
82
  }
83
83
 
84
- export function coalescePublicationTarget(state: PublicationQueueState, destination: RemotePublicationDestination, target: string, isAncestor: CommitAncestor): PublicationQueueState {
84
+ export interface PublicationCoalesceObserver {
85
+ /** Called with the retired record when a journal lineage rewrite orphans its target. */
86
+ onDivergedLineage?: (previous: PublicationQueueState) => void;
87
+ }
88
+
89
+ export function coalescePublicationTarget(state: PublicationQueueState, destination: RemotePublicationDestination, target: string, isAncestor: CommitAncestor, observer?: PublicationCoalesceObserver): PublicationQueueState {
85
90
  validatePublicationQueue(state);
86
91
  if (!COMMIT.test(target)) throw new Error("Publication queue target must be an exact commit");
87
92
  if (remotePublicationDestinationKey(state.destination) !== remotePublicationDestinationKey(destination)) throw new Error("Publication queue destination changed");
88
93
  if (target === state.target || isAncestor(target, state.target)) return structuredClone(state);
89
- if (!isAncestor(state.target, target)) throw new Error("Publication queue targets diverge");
90
- return { ...structuredClone(state), target, status: "pending", attempt: 0, error: undefined };
94
+ const previous = structuredClone(state);
95
+ if (!isAncestor(state.target, target)) {
96
+ // A reset or re-initialized journal rewrites the lineage. The queued commit can never
97
+ // fast-forward the remote again, so retarget the live lineage instead of wedging every
98
+ // later turn-end; the retired commit stays in the local Git object store.
99
+ observer?.onDivergedLineage?.(previous);
100
+ const { confirmed: _confirmed, error: _error, ...live } = previous;
101
+ return { ...live, target, status: "pending", attempt: 0 };
102
+ }
103
+ return { ...previous, target, status: "pending", attempt: 0, error: undefined };
91
104
  }
92
105
 
93
106
  export function parsePublicationQueue(content: string): PublicationQueueState {
package/lib/telegram.ts CHANGED
@@ -1,13 +1,9 @@
1
- // Domain: optional pi-telegram presentation adapter for State Flow status and branch controls.
1
+ // Domain: optional pi-telegram presentation adapter for the State Flow main-menu section.
2
2
  //
3
3
  // This is a leaf adapter. Core semantics, storage, and inference never depend on it; when
4
4
  // pi-telegram is absent or its registry is not ready, registration fails open and retries.
5
5
 
6
6
  export const STATE_FLOW_TELEGRAM_ID = "@llblab/pi-state-flow";
7
- const STATUS_IMPORT_SPECIFIERS = [
8
- "@llblab/pi-telegram/status",
9
- new URL("../../pi-telegram/api/status.ts", import.meta.url).href,
10
- ];
11
7
  const SECTIONS_IMPORT_SPECIFIERS = [
12
8
  "@llblab/pi-telegram/sections",
13
9
  new URL("../../pi-telegram/api/sections.ts", import.meta.url).href,
@@ -20,11 +16,6 @@ export interface StateFlowTelegramSnapshot {
20
16
  startPending: boolean;
21
17
  }
22
18
 
23
- export interface StateFlowTelegramStatusLine {
24
- label: string;
25
- value: string;
26
- }
27
-
28
19
  export interface StateFlowTelegramButton {
29
20
  text: string;
30
21
  callback_data: string;
@@ -47,13 +38,6 @@ export interface StateFlowTelegramCallbackContext extends StateFlowTelegramSecti
47
38
  payload: string;
48
39
  }
49
40
 
50
- export interface StateFlowTelegramStatusModule {
51
- registerTelegramStatusLineProvider(
52
- provider: (ctx: { activeModel?: unknown }) => StateFlowTelegramStatusLine | undefined,
53
- options: { id: string },
54
- ): () => void;
55
- }
56
-
57
41
  export interface StateFlowTelegramSectionModule {
58
42
  registerTelegramSection(section: {
59
43
  id: string;
@@ -65,7 +49,6 @@ export interface StateFlowTelegramSectionModule {
65
49
  }
66
50
 
67
51
  export interface StateFlowTelegramModules {
68
- status?: StateFlowTelegramStatusModule;
69
52
  sections?: StateFlowTelegramSectionModule;
70
53
  }
71
54
 
@@ -90,12 +73,6 @@ export interface StateFlowTelegramAdapter {
90
73
  dispose(): void;
91
74
  }
92
75
 
93
- /** The Status screen mirrors the terminal status line: key plus step value, hidden while State Flow is off. */
94
- export function formatStateFlowStatusLine(snapshot: StateFlowTelegramSnapshot): StateFlowTelegramStatusLine | undefined {
95
- if (!snapshot.enabled) return undefined;
96
- return { label: "State Flow", value: `#${snapshot.step}` };
97
- }
98
-
99
76
  /** Main-menu section label doubles as the live status value; the disabled row carries no status text. */
100
77
  export function formatStateFlowSectionLabel(snapshot: StateFlowTelegramSnapshot): string {
101
78
  return snapshot.enabled ? `🌀 State Flow: #${snapshot.step}` : "⚫️ State Flow";
@@ -176,17 +153,12 @@ async function importTelegramModule<TModule>(
176
153
 
177
154
  /** Default loader; injectable so tests and embedded hosts can control transport presence. */
178
155
  export async function loadStateFlowTelegramModules(): Promise<StateFlowTelegramModules> {
179
- const status = await importTelegramModule<StateFlowTelegramStatusModule>(
180
- STATUS_IMPORT_SPECIFIERS,
181
- (module): module is StateFlowTelegramStatusModule =>
182
- typeof (module as StateFlowTelegramStatusModule | undefined)?.registerTelegramStatusLineProvider === "function",
183
- );
184
156
  const sections = await importTelegramModule<StateFlowTelegramSectionModule>(
185
157
  SECTIONS_IMPORT_SPECIFIERS,
186
158
  (module): module is StateFlowTelegramSectionModule =>
187
159
  typeof (module as StateFlowTelegramSectionModule | undefined)?.registerTelegramSection === "function",
188
160
  );
189
- return { ...(status === undefined ? {} : { status }), ...(sections === undefined ? {} : { sections }) };
161
+ return { ...(sections === undefined ? {} : { sections }) };
190
162
  }
191
163
 
192
164
  export function createStateFlowTelegramAdapter(options: {
@@ -195,7 +167,6 @@ export function createStateFlowTelegramAdapter(options: {
195
167
  }): StateFlowTelegramAdapter {
196
168
  const load = options.load ?? loadStateFlowTelegramModules;
197
169
  let generation = 0;
198
- let statusRegistered = false;
199
170
  let sectionRegistered = false;
200
171
  let registration: Promise<boolean> | undefined;
201
172
  const disposers: Array<() => void> = [];
@@ -210,22 +181,6 @@ export function createStateFlowTelegramAdapter(options: {
210
181
  }
211
182
  // A shutdown during loading must not leave a registration behind.
212
183
  if (epoch !== generation) return false;
213
- if (!statusRegistered && modules.status) {
214
- try {
215
- const dispose = modules.status.registerTelegramStatusLineProvider(
216
- () => formatStateFlowStatusLine(options.port.snapshot()),
217
- { id: STATE_FLOW_TELEGRAM_ID },
218
- );
219
- if (epoch === generation) {
220
- disposers.push(dispose);
221
- statusRegistered = true;
222
- } else {
223
- dispose();
224
- }
225
- } catch {
226
- // Registry not initialized yet; the next ensure retries.
227
- }
228
- }
229
184
  if (!sectionRegistered && modules.sections) {
230
185
  try {
231
186
  const dispose = modules.sections.registerTelegramSection(buildStateFlowTelegramSection(options.port));
@@ -239,12 +194,12 @@ export function createStateFlowTelegramAdapter(options: {
239
194
  // Registry not initialized yet; the next ensure retries.
240
195
  }
241
196
  }
242
- return statusRegistered || sectionRegistered;
197
+ return sectionRegistered;
243
198
  };
244
199
 
245
200
  return {
246
201
  async ensure(): Promise<boolean> {
247
- if (statusRegistered && sectionRegistered) return true;
202
+ if (sectionRegistered) return true;
248
203
  registration ??= register().finally(() => {
249
204
  registration = undefined;
250
205
  });
@@ -259,7 +214,6 @@ export function createStateFlowTelegramAdapter(options: {
259
214
  // Disposal is best-effort; pi-telegram owns its registry lifetime.
260
215
  }
261
216
  }
262
- statusRegistered = false;
263
217
  sectionRegistered = false;
264
218
  },
265
219
  };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@llblab/pi-state-flow",
3
- "version": "0.9.1",
3
+ "version": "0.9.3",
4
4
  "private": false,
5
5
  "description": "Incremental scoped state/context compiler for Pi, inspired by SKILL.state",
6
6
  "keywords": [