@neruok/pi-advisor 0.1.0 → 0.1.1

package/README.md

@@ -164,7 +164,8 @@ Continue through `advisor`:
 
 `advisor_sessions({})` lists identifiers and metadata, not transcripts. Finish with `advisor_close({"session":"adv_<returned-id>"})`.
 
-Each entry includes known cumulative usage, `totalUsageComplete`, `turnsRemaining`, informational `historyBytes`, and `contextUsage`.
+Each entry includes committed exchange count, known cumulative usage, `totalUsageComplete`, informational `historyBytes`, and `contextUsage`.
+Both discovery views show every listed consultation and its committed exchange count.
 `contextUsage` contains `tokens`, `contextWindow`, and `percent`, based on committed history only.
 A pending request marks cumulative usage incomplete until its outcome is known. Estimates do not guarantee another exchange will fit.
 
@@ -216,17 +217,22 @@ Consultations are ephemeral. The extension stores no separate consultation files
 
 Session replacement, fork, tree navigation, shutdown, or reload clears consultations. Parent compaction retains them. Pi can still persist tool arguments and results in its parent transcript. Closing a consultation does not erase that transcript. The provider receives the supplied messages and applies its own retention policy. Do not include secrets.
 
-Hard local limits:
+Advisor has no fixed consultation count, exchange count, message-byte, or reply-byte caps.
+There is no fixed history-byte cap. More consultations and longer exchanges can use more process memory and increase provider cost.
+Close consultations when you no longer need them.
 
-- 8 active consultations, including pending creation.
-- 24 successful user/reply exchange pairs per consultation.
-- 16384 UTF-8 bytes per user message or raw advisor reply.
-- The pinned advisor model's `contextWindow`, from Pi's model registry. There is no fixed history-byte cap.
+The remaining consultation limits are:
+
+- The pinned advisor model's `contextWindow`, from Pi's model registry.
 - A configured deadline per call, with a 300000 ms default.
 
-Each request asks for at most 4096 output tokens.
-Before dispatch, advisor reserves those 4096 output tokens within the model window. Equality passes; overflow returns `context-tokens`.
-After validation, the full pair must also fit before commit. No automatic compaction, trimming, or summarization occurs.
+Advisor omits `maxTokens` and lets Pi control the model output allowance.
+Pi applies model defaults and provider-specific context handling. Removing the extension cap does not remove provider output limits.
+Before dispatch, estimated pending context must fit within the model window, with no fixed output reserve.
+After validation, the full pair must also fit before commit. Equality passes both checks. Overflow returns `context-tokens`.
+No automatic compaction, trimming, or summarization occurs.
+
+The settings-file limit remains 16384 bytes. Label lengths, model-picker rows, and eight-row advice previews remain unchanged.
 
 Context measurement follows Pi: use the latest positive assistant usage plus Pi's estimates for later messages.
 With no positive usage, estimate the fixed system prompt and messages with Pi's public `estimateTokens` helper.
@@ -238,14 +244,8 @@ Requests declare no tools and omit `toolChoice` for every provider. Pi controls
 
 Limits fail closed. The extension never evicts or silently summarizes history.
 Limit failures retain `error.code = "limit-exceeded"` and add `error.limit = {resource, maximum, actual}`.
-Measurements use UTF-8 bytes, estimated context tokens, or attempted exchange/session counts. Bounds are inclusive.
-
-| Resource | Recovery |
-| --- | --- |
-| `input-bytes` | Send a shorter message. |
-| `reply-bytes` | Request a shorter answer. |
-| `context-tokens` or `turns` | Start a new consultation with your own explicit summary. |
-| `sessions` | Close idle consultations. |
+`context-tokens` is the only limit resource. Measurements use estimated context tokens. Bounds are inclusive.
+To recover from context overflow, start a new consultation with your own explicit summary.
 
 One request may run per consultation. Overlapping requests and busy close return `busy`. Cancellation and provider failure leave previous exchanges intact. The extension makes no automatic retries. A provider that ignores cancellation can complete later, but its reply cannot change consultation state. Late usage may be unavailable. If a completion attempt produces no observed response, `usageComplete` is false.
 A zero usage value with that flag does not mean zero cost. Remote work can continue after local cancellation.
@@ -295,7 +295,7 @@ Verified against Pi 1.0.4 on Node 24, on Linux. Offline tests verify determinist
 
 ## Release checklist
 
-The initial release is `@neruok/pi-advisor@0.1.0`, licensed under MIT. The manifest selects public access on the npm registry.
+The release version is `@neruok/pi-advisor@0.1.1`, licensed under MIT. The manifest selects public access on the npm registry.
 
 1. Confirm the release version and regenerate `package-lock.json` after manifest changes with `npm install --package-lock-only --ignore-scripts`.
 2. Run `npm ci --ignore-scripts`, `npm run verify`, `npm run packcheck`, and `npm publish --dry-run`. The `prepublishOnly` hook runs verification and the archive check again.

package/docs/pi-advisor.md

@@ -1,4 +1,4 @@
-<!-- generated by workspace-docs. source: pi-advisor revision 38. do not edit; author with workspace-docs checkout. -->
+<!-- generated by workspace-docs. source: pi-advisor revision 41. do not edit; author with workspace-docs checkout. -->
 
 # Pi advisor: isolated consultation contract and design
 
@@ -26,6 +26,7 @@
 - [Short provider caching verification](#cache-verification)
 - [Private continuation-state verification](#opaque-replay-verification)
 - [Model context and display verification](#context-display-verification)
+- [Fixed consultation cap removal](#fixed-cap-removal-verification)
 
 
 ## Purpose and scope {#scope}
@@ -46,7 +47,10 @@ Consultations remain available across parent turns and compaction. Clear them on
 
 The extension writes no consultation files. Pi can still persist tool arguments and results in its parent transcript. The configured provider receives explicit consultation messages. Ephemeral means no separate extension persistence, not guaranteed erasure by Pi or the provider.
 
-Initial resource defaults are implementation choices: 8 simultaneous consultations, 24 successful exchange pairs, 16384 UTF-8 bytes per input or reply, and 49152 transcript bytes. Each request uses the configured deadline in REQ-26, with a 300000 ms default, and requests at most 4096 output tokens. These bounds are not token-context or monetary guarantees.
+REQ-31 removes the fixed consultation, exchange, message-byte, reply-byte, and output-token caps at the user's request.
+REQ-29 retains the pinned model context window. REQ-26 retains the configurable deadline, with a 300000 ms default.
+Pi controls the model output allowance. Settings-file and presentation bounds remain separate from consultation capacity.
+These controls do not provide a monetary guarantee.
 
 Settings use the host agent directory, not a hard-coded home path. Project settings require current Pi project trust. No default model is selected. No live provider calls are part of build verification.
 
@@ -82,7 +86,7 @@ Each advisor call MUST make at most one model request. Provider retries MUST be
 Only a validated reply MUST commit its user/reply pair. Failed creation MUST leave no consultation. Failed continuation MUST preserve previous exchanges.
 The extension MUST combine caller cancellation with the deadline defined by REQ-26, measured from call entry. Cancellation MUST prevent a later commit.
 Timeout and cancellation MUST return without waiting indefinitely for a provider that ignores abort. Late completions MUST NOT change state.
-Concurrent calls on one consultation MUST reject the second with busy. Different consultations MAY run concurrently within the session limit.
+Concurrent calls on one consultation MUST reject the second with busy. Different consultations MAY run concurrently. REQ-31 removes the active consultation cap.
 Failures MUST use fixed safe error codes and messages. Raw provider exceptions MUST NOT appear in output.
 Results MUST report usage available at return, including rejected completed replies. Usage from a late unobserved completion MAY be unavailable.
 
@@ -537,8 +541,85 @@ Existing eight-row advice previews, expanded full advice, safe failures, current
 README MUST explain visible questions, model-sized estimated context, remaining limits, cumulative totals, per-call CH, and reported cost.
 
 
+<a id="REQ-31"></a>
+
+**REQ-31** Remove fixed consultation caps
+
+Advisor MUST NOT cap active consultations, committed exchanges, message bytes, or reply bytes with fixed extension limits.
+Advisor MUST omit maxTokens from every completion options object. Pi MUST control the model output allowance.
+Before dispatch, advisor MUST compare estimated pending context tokens with the pinned model contextWindow, without a fixed output reserve.
+After reply validation, advisor MUST compare estimated committed context tokens with that same window.
+Equality MUST pass both checks. Overflow MUST return limit-exceeded with resource context-tokens and commit no exchange.
+The fixed safe context error MUST report maximum contextWindow and actual estimated tokens.
+Completed rejected replies MUST retain their known usage. A failed continuation MUST retain its previous context and replay.
+
+Success and discovery schemas MUST permit exchange counts above 24. Discovery MUST permit more than eight entries.
+Discovery MUST omit turnsRemaining. Session renderers MUST show committed exchange counts and all listed consultations, without a fixed eight-entry cutoff.
+Public limit schemas MUST accept only context-tokens as a resource. Removed resource names MUST fail schema validation.
+The README MUST describe the removed caps, Pi output defaults, retained context checks, and unchanged deadline.
+
+The configurable timeout, caller cancellation, busy protection, no retries, strict inputs, reply validation, and isolation MUST remain unchanged.
+Usage snapshots, opaque replay privacy, close, lifecycle reset, and ephemeral retention MUST remain unchanged.
+The 16384-byte settings-file bound, 80-code-point labels, picker row bounds, and eight-row advice previews MUST remain unchanged.
+
+This requirement supersedes REQ-4's fixed consultation, exchange, input-byte, reply-byte, and output-token bounds.
+It supersedes REQ-11's removed limit resources and REQ-13's turnsRemaining field.
+It supersedes REQ-29's fixed output reserve and preservation of the removed caps.
+Earlier requirements and acceptance criteria MUST NOT restore these caps through a preservation clause.
+
+
+- #REQ-31 supersedes: [#REQ-4](#REQ-4)
+
+
+- #REQ-31 supersedes: [#REQ-11](#REQ-11)
+
+
+- #REQ-31 supersedes: [#REQ-13](#REQ-13)
+
+
+- #REQ-31 supersedes: [#REQ-29](#REQ-29)
+
+
 ## Acceptance criteria {#acceptance}
 
+<a id="AC-31"></a>
+
+**AC-31** Calls beyond former caps
+
+Changed checks MUST fail against the capped baseline before implementation.
+Send multibyte messages and valid replies above 16384 UTF-8 bytes within the model window.
+PASS when the exact message reaches completion, the exact reply commits, and continuation retains both without truncation.
+Create at least nine consultations, including pending creation. Continue one consultation through at least 25 successful exchanges.
+PASS when all calls succeed, identifiers remain distinct, and prior consultations remain available without eviction.
+Inspect options across provider selections. PASS when maxTokens is absent while reasoning, short caching, and zero retries remain.
+Use the installed Responses adapter with synthetic authentication and mock fetch.
+PASS when a model allowance above 4096 reaches the payload instead of the former extension cap.
+Test pending context at the exact model window and one token above it.
+PASS when equality dispatches without a fixed output reserve and overflow returns exact context diagnostics without dispatch.
+Validate successful results and discovery above the former count caps.
+PASS when turnsRemaining is absent, strict unknown fields remain rejected, and removed limit resource names fail validation.
+Render at least nine entries in both views. PASS when every identifier appears, committed counts replace remaining counts, and lines fit.
+Inspect the README. PASS when it describes the removed caps and retained context, timeout, and provider-cost caveats.
+
+
+<a id="AC-32"></a>
+
+**AC-32** Preserved safeguards after cap removal
+
+Preserved checks MUST pass before and after implementation.
+Inject committed-context overflow and a malformed completion during continuation.
+PASS when previous context and private replay remain unchanged, completed rejected usage remains counted, and no retry occurs.
+Cancel pending creation and settle its reply afterward. PASS when no late exchange commits or discarded consultation reappears.
+Retain existing deadline, busy, close, lifecycle, settings-file bounds, strict validation, privacy, and eight-row advice-preview checks.
+Use mock catalogs, temporary settings, synthetic replay, and mock fetch only. No paid provider call is part of verification.
+
+
+- #REQ-31 verified-by: [#AC-31](#AC-31)
+
+
+- #REQ-31 verified-by: [#AC-32](#AC-32)
+
+
 <a id="AC-23"></a>
 
 **AC-23** SDK timeout and terminal error regression coverage
@@ -1421,3 +1502,54 @@ The nine new-coder profile checks and both profile core TypeScript commands pass
 Verification used temporary settings, mock catalogs, synthetic replay, and mock provider responses only.
 No new paid request, live settings change, commit, push, deployment, or live terminal check occurred.
 These results do not prove exact provider tokenization, universal compatibility, or live UI appearance. Reload is required to load the changed extension.
+
+## Fixed consultation cap removal {#fixed-cap-removal-verification}
+
+
+The user authorized removal of the active consultation, exchange, message-byte, reply-byte, and output-token caps.
+The user retained the model context limit and configurable timeout. REQ-31, AC-31, and AC-32 define this change.
+The inspected baseline was commit 69c64a3 and stored document revision 38. TypeScript and all 137 baseline tests passed.
+
+Changed behavior: eleven AC-31 checks failed before implementation for the removed limits, schemas, renderer cutoff, or README.
+Ten failures came from the first focused run. The separate reply-byte check also failed before implementation.
+Preserved behavior: the AC-32 rollback, private replay, rejected usage, and cancelled late-work check passed before and after.
+All twelve focused checks passed after implementation.
+
+| Criterion | Checks in tests/removed-limits.test.mjs | Before | After |
+| --- | --- | --- | --- |
+| AC-31 | Multibyte messages and replies above 16 KiB, including a short-input reply case | fail | pass |
+| AC-31 | Nine active consultations and nine pending creations, without eviction | fail | pass |
+| AC-31 | Twenty-five exchanges with the complete consultation prefix | fail | pass |
+| AC-31 | Provider matrix without maxTokens and installed Responses model output allowance | fail | pass |
+| AC-31 | Exact pending-context equality and one-token overflow without dispatch | fail | pass |
+| AC-31 | Strict schemas above count caps, no turnsRemaining, and only context-tokens | fail | pass |
+| AC-31 | Every discovery entry in both views at widths 1, 8, 30, 80, and 160 | fail | pass |
+| AC-31 | README removed caps and retained controls | fail | pass |
+| AC-32 | Context overflow, malformed replies, private replay, accounting, and cancelled late work | pass | pass |
+
+Advisor now omits maxTokens. Installed Pi AI 1.0.4 uses model defaults and its own context clamp.
+A synthetic-authentication, mock-fetch Responses test used the installed gpt-4.1 output allowance of 32768 tokens.
+This is payload evidence, not proof of live provider acceptance or reasoning quality.
+Advisor compares pending context directly with the pinned model window. It also checks committed context before each commit.
+No fixed output reserve remains in advisor. Pi can still apply its own reserve or provider output limits.
+
+The first full run identified 21 obsolete expectations for removed caps, reserve tokens, or turnsRemaining.
+Those expectations now trace to AC-31. Context overflow, deadlines, privacy, accounting, replay, and cancellation assertions remain.
+A renderer recovery-text check required whitespace-aware matching because the longer context error wraps onto two lines.
+The change did not suppress that diagnostic or relax the required recovery text.
+
+npm run verify passed TypeScript and all 149 tests. npm run packcheck passed package loading and archive checks.
+The nine new-coder profile scripts and both profile core TypeScript checks passed. Project git diff --check passed.
+Verification used mock catalogs, synthetic replies, mock fetch, controlled clocks, and temporary settings only.
+No paid provider call, live settings change, live terminal check, commit, push, or deployment ran.
+Reload is required before the running extension uses this change.
+
+
+
+After reload, the user separately authorized one live consultation and one continuation with the configured advisor model.
+Both calls succeeded on xai/grok-4.7. The same consultation reached two exchanges with the same model selection.
+Both usage-completeness flags were true on each call. The reported total was 3595 tokens and 0.00471 dollars.
+Reported reasoning totaled 251 tokens. The pinned context window was 500000 tokens.
+The idle consultation closed successfully. Discovery then returned no active consultations. No retry occurred.
+This confirms one live two-call flow, not live behavior beyond the removed caps or independently verified provider billing.
+The user then authorized a version bump, commit, push, and npm publication.

package/lib/protocol.ts

@@ -1,7 +1,7 @@
 import type { AssistantMessage, Usage } from '@earendil-works/pi-ai';
 import type { ContextUsage } from './context.ts';
 
-export const LIMITS = Object.freeze({ sessions: 8, turns: 24, messageBytes: 16384, replyBytes: 16384, timeoutMs: 300000, maxTokens: 4096 });
+export const LIMITS = Object.freeze({ timeoutMs: 300000 });
 export const MAX_TIMEOUT_MS = 2147483647;
 export const REASONING_LEVELS = ['default', 'off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
 export type Reasoning = typeof REASONING_LEVELS[number];
@@ -11,7 +11,7 @@ const ERRORS: Record<ErrorCode, string> = {
   'invalid-argument': 'Use a nonblank message and an existing session identifier, if supplied.',
   'not-found': 'Consultation not found. It may have closed or its parent session may have changed.',
   busy: 'Consultation has a pending request. Wait for it before sending or closing.',
-  'limit-exceeded': 'Consultation limit exceeded. Close unused sessions or start a new consultation with an explicit summary.',
+  'limit-exceeded': 'Advisor context limit exceeded. Start a new consultation with an explicit summary.',
   'not-configured': 'No advisor model configured. Use /advisor model <provider> <model>.',
   'invalid-config': 'Advisor settings must be strict JSON with an optional model selection and integer timeoutMs.',
   'settings-unavailable': 'Cannot safely read or save advisor settings. Inspect settings and locks before retrying.',
@@ -22,14 +22,10 @@ const ERRORS: Record<ErrorCode, string> = {
   cancelled: 'Advisor request cancelled. No exchange was committed.',
   timeout: 'Advisor request deadline exceeded. No exchange was committed.'
 };
-export type LimitResource = 'input-bytes' | 'reply-bytes' | 'context-tokens' | 'turns' | 'sessions';
+export type LimitResource = 'context-tokens';
 export type LimitDetails = { resource: LimitResource; maximum: number; actual: number };
 const LIMIT_MESSAGES: Record<LimitResource, string> = {
-  'input-bytes': 'Input byte limit exceeded. Send a shorter message.',
-  'reply-bytes': 'Reply byte limit exceeded. Request a shorter answer.',
-  'context-tokens': 'Advisor context limit exceeded. Start a new consultation with an explicit summary.',
-  turns: 'Exchange limit exceeded. Start a new consultation with an explicit summary.',
-  sessions: 'Active consultation limit exceeded. Close idle consultations before starting another.'
+  'context-tokens': 'Advisor context limit exceeded. Start a new consultation with an explicit summary.'
 };
 const REPLY_MESSAGES = {
   completion: 'Advisor completion did not stop normally.',
@@ -120,7 +116,6 @@ export function parseInput(value: unknown): { message: string; session?: string;
   const input = object(value, ['message', 'session', 'diagnostics'], 'invalid-argument');
   if (input.diagnostics !== undefined && typeof input.diagnostics !== 'boolean') throw new AdvisorError('invalid-argument');
   if (typeof input.message !== 'string' || !input.message.trim() || (input.session !== undefined && (typeof input.session !== 'string' || !input.session.trim()))) throw new AdvisorError('invalid-argument');
-  checkLimit('input-bytes', LIMITS.messageBytes, Buffer.byteLength(input.message));
   return { message: input.message, ...(input.session === undefined ? {} : { session: input.session as string }), ...(input.diagnostics === undefined ? {} : { diagnostics: input.diagnostics as boolean }) };
 }
 export function replyText(message: AssistantMessage): string {
@@ -131,7 +126,6 @@ export function replyText(message: AssistantMessage): string {
     throw new AdvisorError('invalid-response', undefined, 'content');
   }
   const text = message.content.filter(block => block.type === 'text').map(block => block.text).join('\n');
-  checkLimit('reply-bytes', LIMITS.replyBytes, Buffer.byteLength(text));
   if (!text.trim()) throw new AdvisorError('invalid-response', undefined, 'text');
   return text;
 }

package/lib/render.ts

@@ -45,7 +45,7 @@ function header(data: Advice): string {
 }
 function sessionLines(entry: Metadata, expanded: boolean): string[] {
   return [
-    `${label(entry.session)}${entry.busy ? ' • busy' : ''} • ${entry.turnsRemaining} turns remaining`,
+    `${label(entry.session)}${entry.busy ? ' • busy' : ''} • ${entry.turns} exchanges`,
     ...(expanded ? [label(entry.label), `${label(entry.model?.provider)}/${label(entry.model?.model)} • ${contextLine(entry.contextUsage)} advisor context`, usageLine(entry.totalUsage, entry.totalUsageComplete)] : [])
   ];
 }
@@ -92,7 +92,7 @@ function resultLines(kind: Kind, data: Data | undefined, options: ToolRenderResu
     return lines;
   }
   if (kind === 'advisor_sessions' && 'sessions' in data) {
-    return [...styled('muted', `${data.sessions.length} active advisor consultations`), ...data.sessions.slice(0, 8).flatMap(entry => sessionLines(entry, options.expanded).flatMap(line => styled('toolOutput', line)))];
+    return [...styled('muted', `${data.sessions.length} active advisor consultations`), ...data.sessions.flatMap(entry => sessionLines(entry, options.expanded).flatMap(line => styled('toolOutput', line)))];
   }
   if (kind === 'advisor_close' && 'session' in data) return styled('muted', `Advisor consultation closed: ${label(data.session)}. Parent transcript remains.`);
   return styled('muted', 'Advisor result details unavailable.');

package/lib/schemas.ts

@@ -7,7 +7,7 @@ export const UsageSchema = Type.Object({ input: Type.Number(), output: Type.Numb
 const totals = { totalUsage: UsageSchema, totalUsageComplete: Type.Boolean() };
 export const ContextUsageSchema = Type.Object({ tokens: Type.Number({ minimum: 0 }), contextWindow: Type.Integer({ minimum: 1 }), percent: Type.Number({ minimum: 0 }) }, object);
 const LimitSchema = Type.Object({
-  resource: Type.Union(['input-bytes', 'reply-bytes', 'context-tokens', 'turns', 'sessions'].map(s => Type.Literal(s))),
+  resource: Type.Literal('context-tokens'),
   maximum: Type.Integer({ minimum: 0 }), actual: Type.Integer({ minimum: 0 })
 }, object);
 export const DiagnosticsSchema = Type.Object({
@@ -27,10 +27,10 @@ export const FailureSchema = Type.Union([Type.Object(failure, object), Type.Obje
 export const InputSchema = Type.Object({ message: text, session: Type.Optional(text), diagnostics: Type.Optional(Type.Boolean({ description: 'Opt in for safe failure phase, category and selected model metadata. No raw provider errors. Does not retry.' })) }, object);
 export const CloseInputSchema = Type.Object({ session: text }, object);
 export const EmptyInputSchema = Type.Object({}, object);
-export const AdviceSchema = Type.Union([Type.Object({ ok: Type.Literal(true), advisory: Type.Literal(true), session: text, response: text, turns: Type.Integer({ minimum: 1, maximum: 24 }), model: ModelSchema, usage: UsageSchema, usageComplete: Type.Boolean(), contextUsage: ContextUsageSchema, ...totals }, object), FailureSchema]);
+export const AdviceSchema = Type.Union([Type.Object({ ok: Type.Literal(true), advisory: Type.Literal(true), session: text, response: text, turns: Type.Integer({ minimum: 1 }), model: ModelSchema, usage: UsageSchema, usageComplete: Type.Boolean(), contextUsage: ContextUsageSchema, ...totals }, object), FailureSchema]);
 export const ListSchema = Type.Union([Type.Object({ ok: Type.Literal(true), sessions: Type.Array(Type.Object({
-  session: text, label: text, turns: Type.Integer({ minimum: 0, maximum: 24 }), model: ModelSchema, busy: Type.Boolean(),
-  ...totals, turnsRemaining: Type.Integer({ minimum: 0, maximum: 24 }),
+  session: text, label: text, turns: Type.Integer({ minimum: 0 }), model: ModelSchema, busy: Type.Boolean(),
+  ...totals,
   historyBytes: Type.Integer({ minimum: 0 }), contextUsage: ContextUsageSchema
-}, object), { maxItems: 8 }) }, object), FailureSchema]);
+}, object)) }, object), FailureSchema]);
 export const CloseSchema = Type.Union([Type.Object({ ok: Type.Literal(true), session: text }, object), FailureSchema]);

package/lib/session.ts

@@ -15,7 +15,7 @@ export type Dependencies = {
   progress?: (phase: Phase) => void;
 };
 export type Advice = { ok: true; advisory: true; session: string; response: string; turns: number; model: Selection; usage: Usage; usageComplete: boolean; contextUsage: ContextUsage } & UsageTotals;
-export type Metadata = { session: string; label: string; turns: number; model: Selection; busy: boolean; turnsRemaining: number; historyBytes: number; contextUsage: ContextUsage } & UsageTotals;
+export type Metadata = { session: string; label: string; turns: number; model: Selection; busy: boolean; historyBytes: number; contextUsage: ContextUsage } & UsageTotals;
 const size = (history: Exchange[]): number => Buffer.byteLength(JSON.stringify(history.map(({ role, text, replay }) => ({ role, text, ...(replay ? { replay } : {}) }))));
 const retainedContext = (session: Session): ContextUsage => contextUsage(context(session.history, session.model!).messages, session.contextWindow!);
 const totals = (session: Session, pending = Boolean(session.pending)): UsageTotals => ({ totalUsage: structuredClone(session.usage), totalUsageComplete: session.totalUsageComplete && !pending });
@@ -53,7 +53,7 @@ export class Consultations {
   list(): Metadata[] {
     return [...this.sessions.values()].filter((s): s is Session & { model: Selection } => Boolean(s.model)).map(s => ({
       session: s.id, label: s.label, turns: s.history.length / 2, model: { ...s.model }, busy: Boolean(s.pending),
-      ...totals(s), turnsRemaining: this.limits.turns - s.history.length / 2,
+      ...totals(s),
       historyBytes: size(s.history), contextUsage: retainedContext(s)
     }));
   }
@@ -103,7 +103,6 @@ export class Consultations {
       timeoutMs = session.timeoutMs ?? this.limits.timeoutMs;
       armDeadline();
       const pending: Exchange[] = [...session.history, { role: 'user', text: input.message }];
-      checkLimit('turns', this.limits.turns, session.history.length / 2 + 1);
       phase = 'preparation';
       const selected = session.model ?? await interruptible(() => {
         progress(deps, 'preparing');
@@ -122,13 +121,13 @@ export class Consultations {
       const model = { ...selected };
       const window = session.contextWindow ?? deps.getContextWindow?.(model);
       if (!Number.isSafeInteger(window) || window < 1) throw new AdvisorError('model-unavailable');
-      // Pin before awaiting model work. Reserving the map slot bounds concurrent creation.
+      // Pin before awaiting model work. The map identity guards against lifecycle invalidation.
       session.model = model;
       session.contextWindow = window;
       session.selectionSource = selectionSource;
       session.timeoutMs = timeoutMs;
       diagnosticModel = { ...model };
-      checkLimit('context-tokens', window, contextUsage(context(pending, model).messages, window).tokens + this.limits.maxTokens);
+      checkLimit('context-tokens', window, contextUsage(context(pending, model).messages, window).tokens);
       phase = 'completion';
       const reply = await interruptible(() => {
         progress(deps, 'waiting');
@@ -137,7 +136,7 @@ export class Consultations {
         usageComplete = false;
         return deps.complete(model, context(pending, model), {
           signal: controller!.signal, timeoutMs: Math.max(1, Math.floor(timeoutMs - (performance.now() - started))), maxRetries: 0,
-          maxTokens: this.limits.maxTokens, cacheRetention: 'short', sessionId: session!.id,
+          cacheRetention: 'short', sessionId: session!.id,
           ...(model.reasoning && model.reasoning !== 'default' && model.reasoning !== 'off' ? { reasoning: model.reasoning } : {})
         });
       }, controller.signal);
@@ -187,7 +186,6 @@ export class Consultations {
       if (existing.pending) throw new AdvisorError('busy');
       return existing;
     }
-    checkLimit('sessions', this.limits.sessions, this.sessions.size + 1);
     const session: Session = { id: 'adv_' + randomUUID(), label: Array.from(input.message.trim().replace(/\s+/gu, ' ')).slice(0, 80).join(''), history: [], usage: zeroUsage(), totalUsageComplete: true };
     this.sessions.set(session.id, session);
     return session;

package/lib/settings.ts

@@ -3,7 +3,9 @@ import { lstat, open, mkdir, rename, link, unlink, type FileHandle } from 'node:
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { withFileMutationQueue } from '@earendil-works/pi-coding-agent';
-import { AdvisorError, LIMITS, object, parseSelection, parseTimeoutMs, type Selection } from './protocol.ts';
+import { AdvisorError, object, parseSelection, parseTimeoutMs, type Selection } from './protocol.ts';
+
+const MAX_SETTINGS_BYTES = 16384;
 
 export type Settings = { model?: Selection; timeoutMs?: number };
 export type Scope = 'global' | 'project';
@@ -32,15 +34,15 @@ async function readLayer(path: string): Promise<{ settings: Settings; raw?: Buff
     handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
     const opened = await handle.stat();
     if (!opened.isFile()) throw new AdvisorError('settings-unavailable');
-    if (opened.size > LIMITS.messageBytes) throw new AdvisorError('invalid-config');
-    const buffer = Buffer.alloc(LIMITS.messageBytes + 1);
+    if (opened.size > MAX_SETTINGS_BYTES) throw new AdvisorError('invalid-config');
+    const buffer = Buffer.alloc(MAX_SETTINGS_BYTES + 1);
     let length = 0;
     while (length < buffer.length) {
       const { bytesRead } = await handle.read(buffer, length, buffer.length - length, length);
       if (!bytesRead) break;
       length += bytesRead;
     }
-    if (length > LIMITS.messageBytes) throw new AdvisorError('invalid-config');
+    if (length > MAX_SETTINGS_BYTES) throw new AdvisorError('invalid-config');
     const raw = buffer.subarray(0, length);
     try { return { settings: parseSettings(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(raw))), raw }; }
     catch { throw new AdvisorError('invalid-config'); }
@@ -73,7 +75,7 @@ export async function saveSettings(paths: SettingsPaths, scope: Scope, value: un
         // Preserve the independent field from the locked checkpoint, not a prior command read.
         const next = { ...(preserve ? { [preserve]: before.settings[preserve] } : {}), ...settings };
         const text = JSON.stringify(next, null, 2) + '\n';
-        if (Buffer.byteLength(text) > LIMITS.messageBytes) throw new AdvisorError('invalid-config');
+        if (Buffer.byteLength(text) > MAX_SETTINGS_BYTES) throw new AdvisorError('invalid-config');
         const output = await open(temp, 'wx', 0o600); ownedTemp = true;
         try { await output.writeFile(text, 'utf8'); await output.sync(); } finally { await output.close(); }
         const current = await readLayer(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neruok/pi-advisor",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "MIT",
   "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },
   "type": "module",