dsh-doublecheck 0.9.24 → 0.9.27

package/lib/domain/projection.d.ts

@@ -8,6 +8,12 @@
  * bump the edit count, and a `doublecheck-review` source record marks the
  * delivery reviewed. Resumed and forked sessions fold to the same view.
  *
+ * The WIRE value is not this state: it is one bounded single-line string this
+ * module renders (`renderDoublecheckLine`), because a JSON object of these
+ * eight fields is at best 126 characters and every generic one-line renderer
+ * truncates it — the old object view lost `gateVerdict`/`gateRedCount`
+ * outright. See {@link DOUBLECHECK_LINE_MAX}.
+ *
  * @module dsh-doublecheck/domain/projection
  */
 import type { SessionEvent } from '@deepseek-ai/dsh-session';
@@ -15,6 +21,28 @@ import { type TestRunDetection } from './evidence.js';
 import { type DisciplineStage, type TestColor } from './stages.js';
 import { type GateVerdict } from './gate.js';
 import type { DoublecheckView } from '../types.js';
+/**
+ * The hard budget of the wire line, in UTF-16 code units — the same unit
+ * `String#length` and every one-line renderer measure.
+ *
+ * 120 is not arbitrary: the WeChat bridge's generic projection renderer
+ * (`dsh-wechat` `renderProjectionValue`) keeps a value only while
+ * `value.length <= 120` and otherwise cuts it to 117 units plus `…`. The
+ * object-shaped view this projection used to emit was 131 units when EMPTY
+ * and 139 with a short goal, so it was truncated for every possible value and
+ * the two fields a user reads on a phone (`gateVerdict`, `gateRedCount`) were
+ * exactly the ones cut off. A single bounded line keeps the whole payload
+ * inside every renderer's first line.
+ */
+export declare const DOUBLECHECK_LINE_MAX = 120;
+/**
+ * Longest `goal:` excerpt kept on the line, in UTF-16 code units. A goal is
+ * free text and is the one lossy field: it is sanitized to one line and
+ * clipped (never dropped silently — a clipped excerpt ends with `…`). The
+ * three fields a user reads first (`gate:`, `stage:`, `r<red>`) are never
+ * clipped.
+ */
+export declare const DOUBLECHECK_GOAL_MAX = 40;
 /** The projection unit's plain-JSON fold state. */
 export interface DoublecheckProjectionState {
     /** The last discipline stage a successful call or test run reached. */
@@ -58,8 +86,33 @@ export declare function applyDoublecheckEvent(state: DoublecheckProjectionState,
  */
 export declare function foldDoublecheckState(events: readonly SessionEvent[], detection: TestRunDetection): DoublecheckProjectionState;
 /**
- * Project the folded state to the wire payload.
+ * Project the folded state to the wire payload: one status line.
+ *
+ * The line is built in priority order and every part is bounded, so the total
+ * can never exceed {@link DOUBLECHECK_LINE_MAX}:
+ *
+ * 1. `gate:<verdict> r<red>` — the latest gate verdict and its red-light count.
+ * 2. `stage:<stage>` — the discipline stage reached on durable evidence.
+ * 3. `test:<color> edits:<n> spec:<yes|no> review:<yes|no>` — the supporting facts.
+ * 4. `goal:<excerpt>` — only when a spec exists and the excerpt is non-empty;
+ *    clipped to whatever budget parts 1–3 left, at most
+ *    {@link DOUBLECHECK_GOAL_MAX} units.
+ *
+ * The worst case of parts 1–3 is 84 units (`gate:deliverable r9999+`,
+ * `stage:design`, `test:green edits:99999+ spec:yes review:yes`), leaving at
+ * least 28 units for the goal excerpt — so no part is ever dropped to make
+ * room, and a final hard clamp backstops the invariant.
  * @param state - the folded state.
  * @returns the whole current value for the `doublecheck` projection key.
  */
 export declare function viewDoublecheck(state: DoublecheckProjectionState): DoublecheckView;
+/**
+ * Render the fold state as the bounded single-line wire value.
+ *
+ * Pure and total: any state (including a hand-built or version-mismatched one
+ * with absurd counts) yields a one-line string of at most
+ * {@link DOUBLECHECK_LINE_MAX} code units, never a throw.
+ * @param state - the folded state.
+ * @returns one line, `<= DOUBLECHECK_LINE_MAX` code units, with no newline.
+ */
+export declare function renderDoublecheckLine(state: DoublecheckProjectionState): string;

package/lib/domain/projection.js

@@ -8,11 +8,46 @@
  * bump the edit count, and a `doublecheck-review` source record marks the
  * delivery reviewed. Resumed and forked sessions fold to the same view.
  *
+ * The WIRE value is not this state: it is one bounded single-line string this
+ * module renders (`renderDoublecheckLine`), because a JSON object of these
+ * eight fields is at best 126 characters and every generic one-line renderer
+ * truncates it — the old object view lost `gateVerdict`/`gateRedCount`
+ * outright. See {@link DOUBLECHECK_LINE_MAX}.
+ *
  * @module dsh-doublecheck/domain/projection
  */
 import { isTestCommand, isTestFilePath, joinTextBlocks, mutationTargetPath, parseRawArguments, ptcSettle, shellCommand, testOutcome, } from "./evidence.js";
 import { SPEC_TOOL_NAME } from "./stages.js";
 import { countRedChecks } from "./gate.js";
+/**
+ * The hard budget of the wire line, in UTF-16 code units — the same unit
+ * `String#length` and every one-line renderer measure.
+ *
+ * 120 is not arbitrary: the WeChat bridge's generic projection renderer
+ * (`dsh-wechat` `renderProjectionValue`) keeps a value only while
+ * `value.length <= 120` and otherwise cuts it to 117 units plus `…`. The
+ * object-shaped view this projection used to emit was 131 units when EMPTY
+ * and 139 with a short goal, so it was truncated for every possible value and
+ * the two fields a user reads on a phone (`gateVerdict`, `gateRedCount`) were
+ * exactly the ones cut off. A single bounded line keeps the whole payload
+ * inside every renderer's first line.
+ */
+export const DOUBLECHECK_LINE_MAX = 120;
+/**
+ * Longest `goal:` excerpt kept on the line, in UTF-16 code units. A goal is
+ * free text and is the one lossy field: it is sanitized to one line and
+ * clipped (never dropped silently — a clipped excerpt ends with `…`). The
+ * three fields a user reads first (`gate:`, `stage:`, `r<red>`) are never
+ * clipped.
+ */
+export const DOUBLECHECK_GOAL_MAX = 40;
+/** Segment separator: visually distinct on a phone and outside the goal word charset. */
+const SEGMENT = ' | ';
+/** Marks a value this line deliberately shortened. */
+const ELLIPSIS = '…';
+/** Above these counts the line prints `<max>+` instead of the exact number. */
+const RED_COUNT_MAX = 9999;
+const EDIT_COUNT_MAX = 99999;
 /** State for the empty log. */
 export function emptyDoublecheckState() {
     return {
@@ -130,19 +165,122 @@ export function foldDoublecheckState(events, detection) {
     return state;
 }
 /**
- * Project the folded state to the wire payload.
+ * Project the folded state to the wire payload: one status line.
+ *
+ * The line is built in priority order and every part is bounded, so the total
+ * can never exceed {@link DOUBLECHECK_LINE_MAX}:
+ *
+ * 1. `gate:<verdict> r<red>` — the latest gate verdict and its red-light count.
+ * 2. `stage:<stage>` — the discipline stage reached on durable evidence.
+ * 3. `test:<color> edits:<n> spec:<yes|no> review:<yes|no>` — the supporting facts.
+ * 4. `goal:<excerpt>` — only when a spec exists and the excerpt is non-empty;
+ *    clipped to whatever budget parts 1–3 left, at most
+ *    {@link DOUBLECHECK_GOAL_MAX} units.
+ *
+ * The worst case of parts 1–3 is 84 units (`gate:deliverable r9999+`,
+ * `stage:design`, `test:green edits:99999+ spec:yes review:yes`), leaving at
+ * least 28 units for the goal excerpt — so no part is ever dropped to make
+ * room, and a final hard clamp backstops the invariant.
  * @param state - the folded state.
  * @returns the whole current value for the `doublecheck` projection key.
  */
 export function viewDoublecheck(state) {
-    return {
-        stage: state.stage,
-        color: state.color,
-        hasSpec: state.hasSpec,
-        specGoal: state.specGoal,
-        reviewed: state.reviewed,
-        editCount: state.editCount,
-        gateVerdict: state.gateVerdict,
-        gateRedCount: state.gateRedCount,
-    };
+    return renderDoublecheckLine(state);
+}
+/**
+ * Render the fold state as the bounded single-line wire value.
+ *
+ * Pure and total: any state (including a hand-built or version-mismatched one
+ * with absurd counts) yields a one-line string of at most
+ * {@link DOUBLECHECK_LINE_MAX} code units, never a throw.
+ * @param state - the folded state.
+ * @returns one line, `<= DOUBLECHECK_LINE_MAX` code units, with no newline.
+ */
+export function renderDoublecheckLine(state) {
+    const head = [
+        `gate:${state.gateVerdict} r${boundedCount(state.gateRedCount, RED_COUNT_MAX)}`,
+        `stage:${state.stage}`,
+        `test:${state.color} edits:${boundedCount(state.editCount, EDIT_COUNT_MAX)}`
+            + ` spec:${state.hasSpec ? 'yes' : 'no'} review:${state.reviewed ? 'yes' : 'no'}`,
+    ].join(SEGMENT);
+    // A goal without a committed spec would contradict `spec:no`.
+    const goal = state.hasSpec ? sanitizeGoal(state.specGoal) : '';
+    if (goal === '')
+        return clampLine(head);
+    const budget = DOUBLECHECK_LINE_MAX - head.length - SEGMENT.length - 'goal:'.length;
+    if (budget <= 0)
+        return clampLine(head);
+    const excerpt = capText(goal, Math.min(budget, DOUBLECHECK_GOAL_MAX));
+    if (excerpt === '')
+        return clampLine(head);
+    return clampLine(`${head}${SEGMENT}goal:${excerpt}`);
+}
+/**
+ * Render a count for the line: non-finite and negative inputs fold to `0`, and
+ * a count above `maximum` prints `<maximum>+` so the field stays bounded.
+ * @param value - the folded count.
+ * @param maximum - the largest exact count the line prints.
+ * @returns a bounded decimal string.
+ */
+function boundedCount(value, maximum) {
+    if (!Number.isFinite(value))
+        return '0';
+    const count = Math.max(0, Math.trunc(value));
+    return count > maximum ? `${maximum}+` : String(count);
+}
+/**
+ * Flatten a free-text goal to one safe line: control characters (including
+ * newlines and the C1 range) become spaces, the segment separator becomes `/`,
+ * whitespace runs collapse, and the result is trimmed. The wire value must be
+ * ONE line — the WeChat renderer keeps only the first line of a multi-line
+ * value. `\p{Cc}` is the Unicode control category (U+0000–U+001F and
+ * U+007F–U+009F), so no literal control character appears in this pattern.
+ * @param goal - the raw committed spec goal.
+ * @returns the sanitized single-line goal, possibly empty.
+ */
+function sanitizeGoal(goal) {
+    return goal
+        .replace(/\p{Cc}/gu, ' ')
+        .replace(/\|/gu, '/')
+        .replace(/\s+/gu, ' ')
+        .trim();
+}
+/**
+ * Cut `text` to at most `budget` code units, marking a real cut with `…` and
+ * never splitting a surrogate pair.
+ * @param text - the text to bound.
+ * @param budget - the maximum length of the result.
+ * @returns the text, or a `…`-terminated prefix of it.
+ */
+function capText(text, budget) {
+    if (budget <= 0)
+        return '';
+    if (text.length <= budget)
+        return text;
+    if (budget <= ELLIPSIS.length)
+        return ELLIPSIS;
+    return `${text.slice(0, safeEnd(text, budget - ELLIPSIS.length))}${ELLIPSIS}`;
+}
+/**
+ * Backstop for {@link DOUBLECHECK_LINE_MAX}: the line is bounded by
+ * construction, so this is unreachable today and exists so a future field
+ * cannot escape the budget silently.
+ * @param line - the assembled line.
+ * @returns the line, or a `…`-terminated prefix within budget.
+ */
+function clampLine(line) {
+    return capText(line, DOUBLECHECK_LINE_MAX);
+}
+/**
+ * The largest cut index that does not split a UTF-16 surrogate pair: a lone
+ * surrogate is rejected by the WeChat transport (`ret=-1 invalid request`).
+ * @param text - the text being cut.
+ * @param end - the proposed cut index.
+ * @returns `end`, or `end - 1` when it would split a pair.
+ */
+function safeEnd(text, end) {
+    if (end <= 0)
+        return 0;
+    const previous = text.charCodeAt(end - 1);
+    return previous >= 0xD800 && previous <= 0xDBFF ? end - 1 : end;
 }

package/lib/guard/activation.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Minimal shape of the 0.2.1+ `subagents.startActivation` surface. The alpha
+ * host line only exposes `start(provider, request)`; keeping this structural
+ * lets the same guard code compile against both.
+ */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+export interface GuardActivationService {
+    startActivation?: (spec: {
+        provider: string;
+        label: string;
+        request: {
+            prompt: ContentBlock[];
+            parent: Agent;
+            outputSchema: unknown;
+            maxDepth?: number;
+            agentOptions?: Record<string, unknown>;
+            agentPreset: string;
+        };
+        signal: AbortSignal;
+        delivery: 'caller';
+    }) => Promise<{
+        childId: SessionId;
+        result: Promise<{
+            stopReason: string;
+            structured?: unknown;
+        }>;
+        dispose(): Promise<void>;
+    }>;
+}

package/lib/guard/activation.js

@@ -0,0 +1 @@
+export {};

package/lib/guard/gate.d.ts

@@ -38,6 +38,8 @@ export interface GateReviewerConfig {
     provider: string;
     /** Model route for the local reviewer; null means the main model reviews. */
     model: string | null;
+    /** Read-only Agent Preset for the startActivation path. */
+    preset?: string;
     /** Tools the local reviewer may call (read-only by default). */
     tools: string[];
     /** Hard time budget for one local reviewer run. */

package/lib/guard/gate.js

@@ -114,6 +114,7 @@ export const GateConfigSchema = z.object({
     consistency: z.object({
         enabled: z.boolean().default(true),
         provider: z.string().min(1).default('fork'),
+        preset: z.string(),
         model: z.union([z.string(), z.const(null)]).default(null),
         tools: z.array(z.string()).default(['read', 'glob', 'grep']),
         timeoutMs: z.number().default(120000),
@@ -123,6 +124,7 @@ export const GateConfigSchema = z.object({
         enabled: z.boolean().default(true),
         engine: z.union(['auto', 'local']).default('auto'),
         provider: z.string().min(1).default('fork'),
+        preset: z.string(),
         model: z.union([z.string(), z.const(null)]).default(null),
         tools: z.array(z.string()).default(['read', 'glob', 'grep']),
         timeoutMs: z.number().default(120000),
@@ -248,15 +250,37 @@ async function runLocalReviewer(ctx, reviewer, agent, task, label, signal) {
     const runSignal = AbortSignal.any([signal, timeout]);
     let run;
     try {
-        run = await subagents.start(reviewer.provider, {
-            label,
-            prompt: [{ type: 'text', text: task }],
-            parent: agent,
-            signal: runSignal,
-            ...reviewer.model !== null ? { agentOptions: { model: reviewer.model } } : {},
-            outputSchema: GATE_FINDINGS_SCHEMA,
-            toolFilter: { allow: reviewer.tools },
-        });
+        const activation = subagents;
+        if (typeof activation.startActivation === 'function') {
+            if (reviewer.preset === undefined) {
+                return { findings: null, unavailable: 'this host uses subagents.startActivation; set the reviewer preset to a read-only Agent Preset' };
+            }
+            const started = await activation.startActivation({
+                provider: reviewer.provider,
+                label,
+                request: {
+                    prompt: [{ type: 'text', text: task }],
+                    parent: agent,
+                    outputSchema: GATE_FINDINGS_SCHEMA,
+                    agentPreset: reviewer.preset,
+                    ...reviewer.model !== null ? { agentOptions: { model: reviewer.model } } : {},
+                },
+                signal: runSignal,
+                delivery: 'caller',
+            });
+            run = started;
+        }
+        else {
+            run = await subagents.start(reviewer.provider, {
+                label,
+                prompt: [{ type: 'text', text: task }],
+                parent: agent,
+                signal: runSignal,
+                ...reviewer.model !== null ? { agentOptions: { model: reviewer.model } } : {},
+                outputSchema: GATE_FINDINGS_SCHEMA,
+                toolFilter: { allow: reviewer.tools },
+            });
+        }
     }
     catch (error) {
         return { findings: null, unavailable: String(error) };

package/lib/guard/index.d.ts

@@ -58,6 +58,8 @@ export interface Config {
     adversaryModel: string | null;
     /** Subagent provider name the critic runs on (default `fork`). */
     adversaryProvider: string;
+    /** Read-only Agent Preset for hosts that use startActivation. */
+    adversaryPreset?: string;
     /** Maximum structured findings injected into the session. */
     adversaryMaxFindings: number;
     /** Tools the critic may call (read-only by default; never mutation tools). */
@@ -125,6 +127,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     }>>, "defined">;
     adversaryModel: z<string | null, string | null, "defined">;
     adversaryProvider: z<string, string, "defined">;
+    adversaryPreset: z<string, string, "plain">;
     adversaryMaxFindings: z<number, number, "defined">;
     adversaryTools: z<string[], string[], "defined">;
     adversaryTimeoutMs: z<number, number, "defined">;
@@ -150,6 +153,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     }>>, "defined">;
     adversaryModel: z<string | null, string | null, "defined">;
     adversaryProvider: z<string, string, "defined">;
+    adversaryPreset: z<string, string, "plain">;
     adversaryMaxFindings: z<number, number, "defined">;
     adversaryTools: z<string[], string[], "defined">;
     adversaryTimeoutMs: z<number, number, "defined">;

package/lib/guard/index.js

@@ -94,6 +94,7 @@ export const Config = z.object({
     }).default({ grill: true, tdd: true, adversary: false }),
     adversaryModel: z.union([z.string(), z.const(null)]).default(null),
     adversaryProvider: z.string().min(1).default('fork'),
+    adversaryPreset: z.string(),
     adversaryMaxFindings: z.number().default(5),
     adversaryTools: z.array(z.string()).default(['read', 'glob', 'grep']),
     adversaryTimeoutMs: z.number().default(120000),
@@ -577,7 +578,8 @@ export function apply(ctx, config) {
         }
     });
     // The `doublecheck` session projection: folds the same durable discipline
-    // facts the guard reads into a plain-JSON wire value a client renders.
+    // facts the guard reads into the wire value a client renders — one bounded
+    // status line (`renderDoublecheckLine`), not a JSON object.
     // Activates only when a projection registry is composed.
     ctx.inject(['sessionProjections'], (projectionCtx) => {
         const registry = projectionCtx.get('sessionProjections');
@@ -597,7 +599,16 @@ export function apply(ctx, config) {
                 viewSchema: doublecheckViewSchema,
                 view: viewDoublecheck,
             },
-            stateVersion: 2,
+            // v3: the wire value changed type (object -> one bounded line). The
+            // bump is the persisted-cache invalidation the registry documents, and
+            // it IS the backward-compatibility story: the state fields themselves
+            // are unchanged and still pass `doublecheckStateSchema`, but a row
+            // written at `ver: 2` is discarded on a `ver: 3` unit and the key
+            // refolds from `init` over the full log (the host's `restoreFloor`
+            // drops to seq 0 on any version mismatch). No migration code, and a
+            // pre-upgrade session degrades to a recomputed line instead of a
+            // stale one or a crash.
+            stateVersion: 3,
         }), 'dsh-doublecheck: projection');
     });
     // The invariant companion, registered from the main plugin so its checks
@@ -616,6 +627,7 @@ export function apply(ctx, config) {
 function adversaryConfig(config) {
     return {
         adversaryProvider: config.adversaryProvider,
+        adversaryPreset: config.adversaryPreset,
         adversaryModel: config.adversaryModel ?? null,
         adversaryMaxFindings: config.adversaryMaxFindings,
         adversaryTools: config.adversaryTools,

package/lib/guard/review.d.ts

@@ -21,6 +21,8 @@ import { type GuardProse, type ProseLanguage } from './prose.js';
 /** The adversary knobs the review runner reads. */
 export interface AdversaryConfig {
     adversaryProvider: string;
+    /** Read-only Agent Preset for the startActivation path. */
+    adversaryPreset?: string;
     adversaryModel: string | null;
     adversaryMaxFindings: number;
     adversaryTools: string[];

package/lib/guard/review.js

@@ -99,15 +99,37 @@ export async function runAdversaryReview(ctx, config, agent, turnSignal) {
     const signal = turnSignal === undefined ? timeout : AbortSignal.any([turnSignal, timeout]);
     let run;
     try {
-        run = await subagents.start(config.adversaryProvider, {
-            label: 'doublecheck-adversary',
-            prompt: [{ type: 'text', text: prose.criticTask }],
-            parent: agent,
-            signal,
-            ...config.adversaryModel !== null ? { agentOptions: { model: config.adversaryModel } } : {},
-            outputSchema: REVIEW_OUTPUT_SCHEMA,
-            toolFilter: { allow: config.adversaryTools },
-        });
+        const activation = subagents;
+        if (typeof activation.startActivation === 'function') {
+            if (config.adversaryPreset === undefined) {
+                return { verdict: 'unavailable', findings: [], text: prose.reviewUnavailableFailed('this host uses subagents.startActivation; set adversaryPreset to a read-only Agent Preset') };
+            }
+            const started = await activation.startActivation({
+                provider: config.adversaryProvider,
+                label: 'doublecheck-adversary',
+                request: {
+                    prompt: [{ type: 'text', text: prose.criticTask }],
+                    parent: agent,
+                    outputSchema: REVIEW_OUTPUT_SCHEMA,
+                    agentPreset: config.adversaryPreset,
+                    ...config.adversaryModel !== null ? { agentOptions: { model: config.adversaryModel } } : {},
+                },
+                signal,
+                delivery: 'caller',
+            });
+            run = started;
+        }
+        else {
+            run = await subagents.start(config.adversaryProvider, {
+                label: 'doublecheck-adversary',
+                prompt: [{ type: 'text', text: prose.criticTask }],
+                parent: agent,
+                signal,
+                ...config.adversaryModel !== null ? { agentOptions: { model: config.adversaryModel } } : {},
+                outputSchema: REVIEW_OUTPUT_SCHEMA,
+                toolFilter: { allow: config.adversaryTools },
+            });
+        }
     }
     catch (error) {
         // Provider absence, capability rejection, or a child that could not be

package/lib/types.d.ts

@@ -7,39 +7,25 @@
  * @module dsh-doublecheck/types
  */
 import { z as zod } from 'zod';
-import type { DisciplineStage, TestColor } from './domain/stages.js';
-import type { GateVerdict } from './domain/gate.js';
 import type { DoublecheckProjectionState } from './domain/projection.js';
-/** The whole wire value of the `doublecheck` session projection. */
-export interface DoublecheckView {
-    /** The last discipline stage reached on durable evidence. */
-    stage: DisciplineStage;
-    /** The latest test-run evidence color. */
-    color: TestColor;
-    /** Whether a committed requirements spec exists in the log. */
-    hasSpec: boolean;
-    /** The goal of the latest committed spec, or '' before any spec. */
-    specGoal: string;
-    /** Whether an adversary review record exists in the log. */
-    reviewed: boolean;
-    /** Total implementation edits folded so far. */
-    editCount: number;
-    /** The latest delivery-gate verdict, or 'none' before any gate run. */
-    gateVerdict: 'none' | GateVerdict;
-    /** Red-light (failing) checks of the latest gate run. */
-    gateRedCount: number;
-}
+/**
+ * The whole wire value of the `doublecheck` session projection: ONE bounded
+ * status line, e.g.
+ *
+ * ```text
+ * gate:rework r2 | stage:green | test:green edits:12 spec:yes review:yes | goal:ship parser fix
+ * ```
+ *
+ * It is a string rather than an object on purpose. The eight state fields cost
+ * 126 characters as compact JSON even at their shortest possible values, so no
+ * object-shaped payload can survive a renderer that keeps one line under 121
+ * characters — which is exactly how `gateVerdict` and `gateRedCount` used to
+ * disappear. `renderDoublecheckLine` (`./domain/projection.ts`) owns the
+ * format and the {@link DOUBLECHECK_LINE_MAX} budget.
+ */
+export type DoublecheckView = string;
 /** Validates the `doublecheck` projection's wire payload before it leaves the host. */
-export declare const doublecheckViewSchema: zod.ZodObject<{
-    stage: zod.ZodUnion<readonly [zod.ZodLiteral<"grill">, zod.ZodLiteral<"design">, zod.ZodLiteral<"red">, zod.ZodLiteral<"green">, zod.ZodLiteral<"review">, zod.ZodLiteral<"verify">]>;
-    color: zod.ZodUnion<readonly [zod.ZodLiteral<"none">, zod.ZodLiteral<"red">, zod.ZodLiteral<"green">]>;
-    hasSpec: zod.ZodBoolean;
-    specGoal: zod.ZodString;
-    reviewed: zod.ZodBoolean;
-    editCount: zod.ZodNumber;
-    gateVerdict: zod.ZodUnion<readonly [zod.ZodLiteral<"none">, zod.ZodLiteral<"deliverable">, zod.ZodLiteral<"rework">]>;
-    gateRedCount: zod.ZodNumber;
-}, zod.core.$strip>;
+export declare const doublecheckViewSchema: zod.ZodString;
 /** Validates the persisted `doublecheck` projection state before it seeds a fold. */
 export declare const doublecheckStateSchema: zod.ZodObject<{
     stage: zod.ZodUnion<readonly [zod.ZodLiteral<"grill">, zod.ZodLiteral<"design">, zod.ZodLiteral<"red">, zod.ZodLiteral<"green">, zod.ZodLiteral<"review">, zod.ZodLiteral<"verify">]>;

package/lib/types.js

@@ -7,17 +7,11 @@
  * @module dsh-doublecheck/types
  */
 import { z as zod } from 'zod';
+// Value import (the one runtime edge in this type table): the wire line's
+// budget is declared once, next to the renderer that must honor it.
+import { DOUBLECHECK_LINE_MAX } from "./domain/projection.js";
 /** Validates the `doublecheck` projection's wire payload before it leaves the host. */
-export const doublecheckViewSchema = zod.object({
-    stage: zod.union([zod.literal('grill'), zod.literal('design'), zod.literal('red'), zod.literal('green'), zod.literal('review'), zod.literal('verify')]),
-    color: zod.union([zod.literal('none'), zod.literal('red'), zod.literal('green')]),
-    hasSpec: zod.boolean(),
-    specGoal: zod.string(),
-    reviewed: zod.boolean(),
-    editCount: zod.number(),
-    gateVerdict: zod.union([zod.literal('none'), zod.literal('deliverable'), zod.literal('rework')]),
-    gateRedCount: zod.number(),
-});
+export const doublecheckViewSchema = zod.string().max(DOUBLECHECK_LINE_MAX);
 /** Validates the persisted `doublecheck` projection state before it seeds a fold. */
 export const doublecheckStateSchema = zod.object({
     stage: zod.union([zod.literal('grill'), zod.literal('design'), zod.literal('red'), zod.literal('green'), zod.literal('review'), zod.literal('verify')]),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-doublecheck",
-  "version": "0.9.24",
+  "version": "0.9.27",
   "description": "Delivery quality gate for DeepSeek Harness: grill the requirements, test the implementation, prove the delivery, and gate the handoff with a deliverable/rework decision.",
   "packageManager": "pnpm@11.7.0",
   "repository": {