@b00dea/cockpit 0.1.0 → 0.1.1

package/dist/environment/generated-application/shared.js

@@ -288,9 +288,14 @@ export function complete(action, prepared, dryRun = false, changes = [], staleRe
             })),
             ...prepared.unapprovedMcpServers.map(server => ({
                 severity: 'warning', code: 'MCP_NOT_APPROVED', target: server.name,
-                message: `MCP server ${server.name}, declared in ${server.sources.join(', ')}, has no approval in [mcp.approved] for its current command, arguments, working directory and environment names (sha256 ${server.sha256}), so every harness keeps it disabled`,
+                message: `MCP server ${server.name}, declared in ${server.sources.join(', ')}, has no approval in [mcp.approved] for its current declaration (command, arguments, working directory and environment names for a local server; URL, header references and headers helper for a remote one) (sha256 ${server.sha256}), so every harness keeps it disabled`,
                 fix: 'a person reviews its declaration, sets its name to the sha256 in this message under [mcp.approved] in cockpit.toml and runs npx --no cockpit sync --config <your cockpit.toml>; while [autonomy] mcp_approve is person, the default, the guard refuses an agent\'s edit of [mcp]. To keep it off, nothing is needed',
             })),
+            ...prepared.mcpTransportGaps.map(gap => ({
+                severity: 'warning', code: 'MCP_TRANSPORT_UNAVAILABLE', target: gap.name,
+                message: `${gap.reason}, so sync writes nothing for it there and the server is unavailable in those tools`,
+                fix: 'nothing is needed if the server is not wanted in those tools; otherwise declare it with credentials the tool can carry (an environment reference in headers rather than a headersHelper for OpenCode), or remove those tools from [surfaces] tools, then run npx --no cockpit sync --config <your cockpit.toml>',
+            })),
             // Real sync and check refuse a changed original; a preview reports it so it can be reviewed.
             ...prepared.changedOverrideOriginals.map(finding => overrideChanged(finding, 'warning')),
         ],

package/dist/environment/generated-application/surface-outputs.js

@@ -228,13 +228,14 @@ function openCodeExternalDirectories(grants) {
 // denied even `test-run` from its own skill. A rule only lets Claude run the command without asking:
 // the guard hook still runs first, and its ask or deny wins over the rule, so a command whose
 // decider the [work.gates] or [autonomy] policy makes a person still asks. Commands that are always
-// a person's (`init`, `sibling add`) and the destructive `down` are left out so they keep asking. Measured with Claude Code 2.1.316 on 2026-11-02 beside an unruled control: `Bash(<prefix> *)`
+// a person's (`init`, `sibling add`) are left out so they keep asking; `down` keeps the data volumes. Measured with Claude Code 2.1.316 on 2026-11-02 beside an unruled control: `Bash(<prefix> *)`
 // ran a matching command headless, the control and a chain with an unmatched part were denied, a hook
 // `ask` denied a matching command, and Claude ignores these rules until a person trusts the workspace.
 const AGENT_COCKPIT_COMMANDS = [
-    'check *', 'doctor *', 'preflight *', 'logs *', 'sync *', 'reset * --apply', 'up *', 'sleep *', 'runtime measure *', 'test-run *',
-    'work status *', 'work accept *', 'work check *', 'work note *', 'work answer *', 'work grade *', 'work signoff *', 'work recover *',
-    'work verify *', 'grade *', 'upgrade *',
+    'check *', 'confirm *', 'doctor *', 'preflight *', 'logs *', 'ps *', 'restart *', 'rebuild *', 'exec *', 'sync *', 'reset * --apply', 'up *', 'sleep *', 'down *',
+    'runtime measure *', 'test-run *',
+    'work status *', 'work accept *', 'work check *', 'work note *', 'work decide *', 'work answer *', 'work acknowledge *', 'work grade *', 'work signoff *', 'work recover *',
+    'work verify *', 'grade *', 'upgrade *', 'docs check *', 'use *', 'pull *', 'stacks *',
     'browser drive *', 'browser screenshot *',
 ];
 function claudeCommandAllowances() {
@@ -251,15 +252,25 @@ export const GUIDE_LOAD_CHARACTERIZATIONS = Object.freeze(Object.fromEntries(shi
     }])));
 export function nativeSources(mcp, grants, siblings, instances) {
     const sources = [];
-    if (mcp.result.servers.length > 0) {
-        const transports = mcp.result.harnesses.flatMap(row => row.servers);
-        const servers = Object.fromEntries(mcp.result.servers.map(model => transports.find(server => server.name === model.name)).map(server => [server.name, {
-                type: 'stdio', command: server.command, args: server.args, disabled: !server.enabled,
-            }]));
+    const transports = mcp.result.harnesses.flatMap(row => row.servers);
+    // A remote server no listed tool can carry is left out of the source entirely.
+    const written = mcp.result.servers.flatMap(model => transports.filter(server => server.name === model.name).slice(0, 1));
+    if (written.length > 0) {
+        const native = (server, helperKey) => 'url' in server
+            ? { type: 'http', url: server.url, ...(Object.keys(server.headers).length > 0 ? { headers: server.headers } : {}),
+                ...(server.headersHelper === null ? {} : { [helperKey]: server.headersHelper }), disabled: !server.enabled }
+            : { type: 'stdio', command: server.command, args: server.args, disabled: !server.enabled };
+        const servers = Object.fromEntries(written.map(server => [server.name, native(server, 'headersHelper')]));
         const targets = Object.fromEntries(mcp.result.harnesses.flatMap(row => {
-            const removed = mcp.result.servers.filter(server => !row.servers.some(transport => transport.name === server.name));
-            return removed.length ? [[harnessFact(row.target).rulesyncTarget, {
-                        mcpServers: Object.fromEntries(removed.map(server => [server.name, null])),
+            const removed = written.filter(server => !row.servers.some(transport => transport.name === server.name))
+                .map(server => [server.name, null]);
+            // Codex spells Claude Code's headersHelper http_headers_helper; Rulesync passes an unknown
+            // key through to config.toml unchanged.
+            const respelled = row.target === 'codexcli'
+                ? row.servers.filter(server => 'url' in server && server.headersHelper !== null).map(server => [server.name, native(server, 'http_headers_helper')])
+                : [];
+            return removed.length + respelled.length > 0 ? [[harnessFact(row.target).rulesyncTarget, {
+                        mcpServers: Object.fromEntries([...removed, ...respelled]),
                     }]] : [];
         }));
         sources.push({ path: 'mcp.jsonc', bytes: `${JSON.stringify({ mcpServers: servers, ...targets }, null, 2)}\n` });

package/dist/environment/generated-application/surfaces.js

@@ -1,4 +1,5 @@
 import { lstat, realpath } from 'node:fs/promises';
+import { openCodePatternUnsafe } from '../served-checkout-grants.js';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { renderBrowserSurfaces } from '../../browser/surfaces.js';
@@ -22,7 +23,7 @@ import { fileFingerprint, verifiedDigest } from '../../environment-exec/verified
 import { SHIPPED_SETUP_SKILL, extendInspectedSkillStandingCosts, inspectRenderedSkillSet } from '../../surfaces/skill-contract.js';
 import { readAnchoredFile, readAnchoredEntry, readAnchoredBatches } from '../../generated-environment/transaction.js';
 import { ENVIRONMENT_CODES, errorCause, snapshotGeneratedJson, RefusalError } from '../contract.js';
-import { SIBLING_DEFAULT_GUIDES } from '../../schema.js';
+import { mounted, SIBLING_DEFAULT_GUIDES } from '../../schema.js';
 import { checkoutId, cockpitId, stackId } from '../identity.js';
 import { resolveLifecycleStage } from '../lifecycle-stage.js';
 import { observeConfiguration, selectStateRoot } from '../state.js';
@@ -37,7 +38,9 @@ export async function prepareSurfaces(prepared, priorOwned, adapters, manifest)
     // Only the listed tools are rendered and drift-checked; an unlisted tool's files become stale.
     const tools = listedSurfaceTargets(config.surfaces.tools);
     const guardedTools = GUARD_SURFACE_TARGETS.filter(target => tools.includes(target));
-    const selected = config.sibling.filter(row => row.mount === 'always');
+    // Generated files are one per checkout, so they follow the declared default profile set; a
+    // profile one run adds with `up --profile` reaches the stack, not the agents' instructions.
+    const selected = mounted(config, config.environment.profiles);
     const requiredSlugs = new Set([...selected.map(row => row.slug), ...prepared.registry.mcpSources.map(row => row.slug)]);
     const siblingRoots = new Map();
     const sourceRoots = [];
@@ -70,7 +73,8 @@ export async function prepareSurfaces(prepared, priorOwned, adapters, manifest)
     }))).sort((left, right) => compareCodeUnits(left.sourcePath, right.sourcePath));
     const observedGuides = guideRequests.length === 0
         ? { kind: 'complete', observations: [], missing: [] }
-        : await observeSiblingGuides({ allowedRoots: selected.map(row => siblingRoots.get(row.slug)), requests: guideRequests });
+        : await observeSiblingGuides({ allowedRoots: selected.map(row => siblingRoots.get(row.slug)), requests: guideRequests,
+            instances: prepared.registry.secretPaths.flatMap(row => siblingRoots.has(row.slug) ? [resolve(siblingRoots.get(row.slug), row.path)] : []) });
     if (observedGuides.kind !== 'complete')
         return refuse(observedGuides.diagnostic.code, observedGuides.diagnostic.message, observedGuides.diagnostic.target);
     for (const sibling of selected)
@@ -82,7 +86,7 @@ export async function prepareSurfaces(prepared, priorOwned, adapters, manifest)
     const projectionInput = {
         canonicalMainCheckout: prepared.root,
         siblingsRoot: config.cockpit.siblings_root,
-        activeProfiles: [],
+        activeProfiles: [...config.environment.profiles],
         guideCapLines: config.cockpit.guide_cap,
         siblings: config.sibling.map(row => ({ slug: row.slug, mount: row.mount, directoryAuthority: row.dir, guides: [...projectionGuides(row)] })),
         mountedPaths: selected.map(row => ({ slug: row.slug, path: siblingRoots.get(row.slug) })),
@@ -131,6 +135,8 @@ export async function prepareSurfaces(prepared, priorOwned, adapters, manifest)
         return refuse(mcp.diagnostic.code, mcp.diagnostic.message, mcp.diagnostic.server);
     const unapprovedMcpServers = mcp.diagnostics.filter(row => row.code === 'MCP_NOT_APPROVED' && row.server !== undefined)
         .map(row => ({ name: row.server, sha256: row.sha256, sources: (row.sources ?? []).map(source => source.kind === 'sibling' ? `${source.slug}:${source.path}` : source.path) }));
+    const mcpTransportGaps = mcp.diagnostics.filter(row => row.code === 'MCP_TRANSPORT_UNAVAILABLE' && row.server !== undefined)
+        .map(row => ({ name: row.server, targets: row.targets ?? [], reason: row.message }));
     if (mcp.diagnostics.some(row => row.code === 'MCP_APPROVAL_UNKNOWN')) {
         const row = mcp.diagnostics.find(candidate => candidate.code === 'MCP_APPROVAL_UNKNOWN');
         return refuse(row.code, row.message, row.server);
@@ -154,9 +160,10 @@ export async function prepareSurfaces(prepared, priorOwned, adapters, manifest)
         if (!checkout)
             return refuse('SURFACE_INPUT_INVALID', 'browser checkout identity is unavailable', prepared.configPath);
         const browserConfiguration = prepared.workEnvironment.browser;
-        const playwright = declarations.filter(row => row.name === 'playwright');
-        if (playwright.length !== 1) {
-            return refuse('MCP_DECLARATION_INVALID', `[browser] requires exactly one MCP server named playwright, and the declared MCP sources hold ${playwright.length}`, 'playwright', 'declare one playwright server in a JSON file with an mcpServers object, listed in a sibling\'s derives.mcp_sources, then run npx --no cockpit sync --config <your cockpit.toml>');
+        const playwright = declarations.filter(row => row.name === 'playwright')
+            .flatMap(row => 'command' in row ? [row] : []);
+        if (playwright.length !== 1 || declarations.filter(row => row.name === 'playwright').length !== 1) {
+            return refuse('MCP_DECLARATION_INVALID', `[browser] requires exactly one local-command MCP server named playwright, and the declared MCP sources hold ${declarations.filter(row => row.name === 'playwright').length} servers by that name, ${playwright.length} of them local`, 'playwright', 'declare one playwright server with a command (not a url) in a JSON file with an mcpServers object, listed in a sibling\'s derives.mcp_sources, then run npx --no cockpit sync --config <your cockpit.toml>');
         }
         const playwrightDigest = mcpApprovalDigest(playwright[0], prepared.root);
         if (config.mcp.approved.playwright !== playwrightDigest) {
@@ -627,12 +634,10 @@ export async function prepareSurfaces(prepared, priorOwned, adapters, manifest)
     };
     const openCodeGrantRoots = projection.grants.filter(grant => grant.target === 'opencode')
         .map(grant => ({ slug: grant.slug, root: siblingRoots.get(grant.slug) }));
-    // The file's bytes become part of an OpenCode pattern: a wildcard would widen the grant and a
-    // quote or backslash would change the JSON around it.
-    const unsafeGrant = openCodeGrantRoots.find(row => row.root === undefined || /[*?"\\\x00-\x1f\x7f]/.test(row.root));
+    const unsafeGrant = openCodeGrantRoots.find(row => row.root === undefined || openCodePatternUnsafe(row.root) !== undefined);
     if (unsafeGrant)
         return refuse('SURFACE_INPUT_INVALID', `the directory of sibling ${unsafeGrant.slug} contains *, ?, a quote, a backslash or a control character, which OpenCode would read as part of its access pattern; move the checkout to a plain path`, unsafeGrant.slug);
-    return { ...prepared, guardHandler, openCodeGrantRoots, unapprovedMcpServers,
+    return { ...prepared, guardHandler, openCodeGrantRoots, unapprovedMcpServers, mcpTransportGaps, mcpServers: mcp.result.servers,
         surfaces: surfaceEntries, compactSurfacePaths, configuredHarnesses,
         activeSurfaceOverrides: merge.overrides, changedOverrideOriginals: merge.findings,
         surfaceSelftest,

package/dist/environment/generated-application/sync.js

@@ -3,11 +3,14 @@ import { basename } from 'node:path';
 import { GUARD_LOCAL_PATHS, writeCockpitLocalFiles, writeGuardLocalIdentity } from '../../guards/local-identity.js';
 import { portablePublicationPaths, authorizePublicationPlan, runPublicationPlan } from '../../generated-environment/transaction.js';
 import { refusalOutcome as refuse } from '../../refusal.js';
+import { readBoundedInput } from '../../config/load.js';
 import { complete, mergedAdapters, overrideChangedRefusal, ownRecord, sha256, } from './shared.js';
 import { syncCommandInput } from './prepare.js';
 import { inputSourcesCurrent, ownedInputOverlap, preparePublication } from './publication.js';
 import { checkCanonicalGeneratedEnvironment, issueRepairAuthority, issuedRepairs } from './check.js';
 import { openCodeGrantFile } from './surface-outputs.js';
+import { readSiblingCheckouts } from '../sibling-checkouts.js';
+import { openCodeGrantDirectory, openCodePatternUnsafe } from '../served-checkout-grants.js';
 async function prepareGeneratedEnvironmentSync(input, adapterOverrides, metadataChanges = []) {
     const request = syncCommandInput(input);
     if (!request)
@@ -94,14 +97,26 @@ export async function applyGeneratedEnvironmentRepair(authority, options = {}) {
     if (outcome.kind === 'refusal')
         return outcome;
     if (prepared.guardHandler && settings.dryRun !== true) {
-        const local = await writeGuardLocalIdentity(prepared.root, prepared.guardHandler);
+        // The guard compares a later edit with exactly the text this identity names, so it is read
+        // again and must still be that text.
+        const configRead = await readBoundedInput(prepared.configPath);
+        if (configRead.kind !== 'complete' || sha256(configRead.bytes) !== prepared.guardHandler.configSha256)
+            return refuse('GENERATED_SOURCE_CHANGED', 'the configuration changed after generated files were published, so the guard identity was not recorded; the guard refuses every agent tool call until it is', prepared.configSource.path, 'run `npx --no cockpit sync --config <your cockpit.toml>` again');
+        const local = await writeGuardLocalIdentity(prepared.root, prepared.guardHandler, configRead.bytes.toString('utf8'));
         if (local.kind === 'refusal')
             return refuse('GENERATED_PUBLICATION_FAILED', `the committed guard files were published, but ${local.message}; the guard refuses every agent tool call until it exists`, GUARD_LOCAL_PATHS.identity, 'fix the path, then run `npx --no cockpit sync --config <your cockpit.toml>` again in a terminal');
     }
     if (prepared.openCodeGrantRoots.length > 0 && settings.dryRun !== true) {
-        const local = await writeCockpitLocalFiles(prepared.root, prepared.openCodeGrantRoots.map(row => ({
-            name: basename(openCodeGrantFile(row.slug)), bytes: row.root
-        })));
+        // A checkout `use` serves from outside the declared one is what OpenCode is granted, as `use` wrote it.
+        const recorded = await readSiblingCheckouts(prepared.root);
+        if (recorded.kind !== 'complete')
+            return refuse(recorded.diagnostic.code, `the committed OpenCode settings were published, but its grants were not written: ${recorded.diagnostic.message}`, recorded.diagnostic.target, recorded.diagnostic.fix);
+        const grants = prepared.openCodeGrantRoots.map(row => ({ name: basename(openCodeGrantFile(row.slug)),
+            bytes: openCodeGrantDirectory(row.root, Object.hasOwn(recorded.checkouts, row.slug) ? recorded.checkouts[row.slug] : undefined) }));
+        const unsafe = grants.map(row => openCodePatternUnsafe(row.bytes)).find(reason => reason !== undefined);
+        if (unsafe)
+            return refuse('GENERATED_PUBLICATION_FAILED', `the committed OpenCode settings were published, but its grants were not written: ${unsafe}`, GUARD_LOCAL_PATHS.directory, 'serve the sibling from a checkout at a plain path with `npx --no cockpit use`, then run sync again');
+        const local = await writeCockpitLocalFiles(prepared.root, grants);
         if (local.kind === 'refusal')
             return refuse('GENERATED_PUBLICATION_FAILED', `the committed OpenCode settings were published, but ${local.message}; OpenCode refuses to start until it exists`, GUARD_LOCAL_PATHS.directory, 'fix the path, then run `npx --no cockpit sync --config <your cockpit.toml>` again in a terminal');
     }

package/dist/environment/git-observation.d.ts

@@ -49,7 +49,7 @@ export declare const observationDeclarations: readonly [{
 }];
 declare function isGitObservation(value: unknown): value is EnvironmentObservation;
 declare function observationIssuedAt(value: unknown): number | undefined;
-export interface GitObservationEvidence {
+interface GitObservationEvidence {
     readonly revision: string | null;
     readonly branch: string;
     readonly upstream: string | null;
@@ -60,7 +60,7 @@ export interface GitObservationEvidence {
     readonly workingTree: 'clean' | 'dirty' | 'untracked' | 'dirty-and-untracked';
     readonly adjacency: 'aligned' | 'ahead' | 'behind' | 'diverged' | 'untracked-upstream' | 'upstream-gone';
 }
-export type GitObservationResult = {
+type GitObservationResult = {
     readonly kind: 'complete';
     readonly evidence: GitObservationEvidence;
     readonly observations: readonly EnvironmentObservation[];
@@ -77,6 +77,25 @@ export declare function createGitObservationStep(input: {
     readonly source: string;
     readonly checkoutId: CheckoutId;
 }): ExecutionStep | undefined;
+export type GitBranchStatus = Readonly<{
+    kind: 'complete';
+    /** An object name, or `(initial)` while HEAD is unborn. */
+    revision: string;
+    /** The branch name, or `(detached)` on a detached HEAD. */
+    branch: string;
+    upstream: string | null;
+    ahead: number;
+    behind: number;
+    /** False when Git names an upstream it cannot count against, because the upstream ref is gone. */
+    adjacencyReported: boolean;
+    trackedDirtyCount: number;
+    untrackedCount: number;
+}>;
+/** `git status --porcelain=v2 --branch` output as numbers and names, or why it cannot be read as such. */
+export declare function parseGitBranchStatus(source: string): GitBranchStatus | Readonly<{
+    kind: 'unavailable';
+    reason: string;
+}>;
 export declare function decodeGitObservation(bytes: Buffer, context: {
     readonly stackId: StackId;
     readonly observedAt: string;
@@ -111,20 +130,20 @@ export type ComparisonRemoteResult = Readonly<{
     reason: string;
     remoteName?: string;
 }>;
-export type ComparisonRemoteRefStage = Readonly<{
+type ComparisonRemoteRefStage = Readonly<{
     kind: 'probe';
     step: ExecutionStep;
 }> | Extract<ComparisonRemoteResult, {
     kind: 'not-applicable' | 'unavailable';
 }>;
-export type ComparisonRemoteUrlStage = Readonly<{
+type ComparisonRemoteUrlStage = Readonly<{
     kind: 'probe';
     step: ExecutionStep;
     remoteName: string;
 }> | Extract<ComparisonRemoteResult, {
     kind: 'unavailable';
 }>;
-export type ComparisonRemoteRevalidationStage = Readonly<{
+type ComparisonRemoteRevalidationStage = Readonly<{
     kind: 'probe';
     step: ExecutionStep;
     remoteName: string;
@@ -147,7 +166,7 @@ export declare function createComparisonRemoteRefStep(input: {
 export declare function observeComparisonRemoteRef(stage: ComparisonRemoteRefStage, outcome: ExecuteProbeOutcome): ComparisonRemoteUrlStage;
 export declare function observeComparisonRemoteUrl(stage: ComparisonRemoteUrlStage, outcome: ExecuteProbeOutcome): ComparisonRemoteRevalidationStage;
 export declare function observeComparisonRemoteRevalidation(stage: ComparisonRemoteRevalidationStage, outcome: ExecuteProbeOutcome): ComparisonRemoteResult;
-export type RunningCheckoutObservationResult = {
+type RunningCheckoutObservationResult = {
     readonly kind: 'complete';
     readonly observation: EnvironmentObservation;
 } | {

package/dist/environment/git-observation.js

@@ -70,22 +70,8 @@ export function createGitObservationStep(input) {
 function unavailable(reason) {
     return { kind: 'unavailable', reason };
 }
-export function decodeGitObservation(bytes, context) {
-    if (bytes.byteLength > OUTPUT_LIMIT || !/^stack:[a-f0-9]{64}$/.test(context.stackId)
-        || !isCanonicalTimestamp(context.observedAt) || typeof context.source !== 'string'
-        || context.source.length === 0 || Buffer.byteLength(`${context.source}:working-tree`) > 1_024
-        || Buffer.byteLength(`${context.source}:adjacency`) > 1_024 || /[\x00-\x1f\x7f]/.test(context.source)
-        || typeof context.checkoutRoot !== 'string' || context.checkoutRoot.length === 0 || /[\x00-\x1f\x7f]/.test(context.checkoutRoot)) {
-        return unavailable('Git evidence exceeds its declared boundary');
-    }
-    let source;
-    try {
-        source = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
-    }
-    catch {
-        // Invalid UTF-8 is the only throw and is what the message names.
-        return unavailable('Git evidence is not valid UTF-8');
-    }
+/** `git status --porcelain=v2 --branch` output as numbers and names, or why it cannot be read as such. */
+export function parseGitBranchStatus(source) {
     let revision;
     let branch;
     let upstream = null;
@@ -94,61 +80,84 @@ export function decodeGitObservation(bytes, context) {
     let trackedDirtyCount = 0;
     let untrackedCount = 0;
     const headers = new Set();
+    const fail = (reason) => ({ kind: 'unavailable', reason });
     for (const line of source.split(/\r?\n/)) {
         if (line === '')
             continue;
         if (line.startsWith('# branch.oid ')) {
             if (headers.has('oid'))
-                return unavailable('Git evidence contains a duplicate branch header');
+                return fail('Git evidence contains a duplicate branch header');
             headers.add('oid');
             revision = line.slice(13);
         }
         else if (line.startsWith('# branch.head ')) {
             if (headers.has('head'))
-                return unavailable('Git evidence contains a duplicate branch header');
+                return fail('Git evidence contains a duplicate branch header');
             headers.add('head');
             branch = line.slice(14);
         }
         else if (line.startsWith('# branch.upstream ')) {
             if (headers.has('upstream'))
-                return unavailable('Git evidence contains a duplicate branch header');
+                return fail('Git evidence contains a duplicate branch header');
             headers.add('upstream');
             upstream = line.slice(18);
         }
         else if (line.startsWith('# branch.ab ')) {
             if (headers.has('adjacency'))
-                return unavailable('Git evidence contains a duplicate branch header');
+                return fail('Git evidence contains a duplicate branch header');
             headers.add('adjacency');
             const match = /^# branch\.ab \+(\d+) -(\d+)$/.exec(line);
             if (!match)
-                return unavailable('Git adjacency evidence is malformed');
+                return fail('Git adjacency evidence is malformed');
             ahead = Number(match[1]);
             behind = Number(match[2]);
             if (!Number.isSafeInteger(ahead) || !Number.isSafeInteger(behind))
-                return unavailable('Git adjacency evidence exceeds exact integer bounds');
+                return fail('Git adjacency evidence exceeds exact integer bounds');
         }
         else if (line.startsWith('? '))
             untrackedCount += 1;
         else if (/^[12u] /.test(line))
             trackedDirtyCount += 1;
         else if (!line.startsWith('! '))
-            return unavailable('Git status evidence contains an unknown record');
+            return fail('Git status evidence contains an unknown record');
     }
     const validIdentity = (value) => Buffer.byteLength(value) <= 1_024 && !/[\x00-\x1f\x7f]/.test(value);
-    // `git init` leaves HEAD unborn, and Git reports that as `(initial)` rather than an object name.
-    const unborn = revision === '(initial)';
-    if (!revision || !branch || !unborn && !/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/.test(revision) || !validIdentity(branch)
+    if (!revision || !branch || revision !== '(initial)' && !/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/.test(revision) || !validIdentity(branch)
         || upstream !== null && !validIdentity(upstream)
         || upstream === null && headers.has('adjacency')) {
-        return unavailable('Git evidence omitted or malformed repository identity');
+        return fail('Git evidence omitted or malformed repository identity');
     }
+    return { kind: 'complete', revision, branch, upstream, ahead, behind, adjacencyReported: headers.has('adjacency'),
+        trackedDirtyCount, untrackedCount };
+}
+export function decodeGitObservation(bytes, context) {
+    if (bytes.byteLength > OUTPUT_LIMIT || !/^stack:[a-f0-9]{64}$/.test(context.stackId)
+        || !isCanonicalTimestamp(context.observedAt) || typeof context.source !== 'string'
+        || context.source.length === 0 || Buffer.byteLength(`${context.source}:working-tree`) > 1_024
+        || Buffer.byteLength(`${context.source}:adjacency`) > 1_024 || /[\x00-\x1f\x7f]/.test(context.source)
+        || typeof context.checkoutRoot !== 'string' || context.checkoutRoot.length === 0 || /[\x00-\x1f\x7f]/.test(context.checkoutRoot)) {
+        return unavailable('Git evidence exceeds its declared boundary');
+    }
+    let source;
+    try {
+        source = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch {
+        // Invalid UTF-8 is the only throw and is what the message names.
+        return unavailable('Git evidence is not valid UTF-8');
+    }
+    const parsed = parseGitBranchStatus(source);
+    if (parsed.kind !== 'complete')
+        return unavailable(parsed.reason);
+    const { revision, branch, upstream, ahead, behind, trackedDirtyCount, untrackedCount, adjacencyReported } = parsed;
+    const unborn = revision === '(initial)';
     const committed = unborn ? null : revision;
     const workingTree = trackedDirtyCount > 0 && untrackedCount > 0 ? 'dirty-and-untracked'
         : trackedDirtyCount > 0 ? 'dirty' : untrackedCount > 0 ? 'untracked' : 'clean';
     // Git names an upstream without counting against it when the upstream ref no longer exists,
     // which is what a merged and deleted remote branch leaves behind.
     const adjacency = upstream === null ? 'untracked-upstream'
-        : !headers.has('adjacency') ? 'upstream-gone'
+        : !adjacencyReported ? 'upstream-gone'
             : ahead > 0 && behind > 0 ? 'diverged'
                 : ahead > 0 ? 'ahead' : behind > 0 ? 'behind' : 'aligned';
     const evidence = { revision: committed, branch, upstream, ahead, behind, trackedDirtyCount, untrackedCount, workingTree, adjacency };

package/dist/environment/health-composition.d.ts

@@ -2,10 +2,11 @@ import type { ExecuteProbeOutcome } from '../environment-exec/execute.js';
 import { type DoctorCommandAdapters } from './application/doctor.js';
 import { type PreflightCommandAdapters } from './application/health.js';
 import { type ExecutionStep } from './contract.js';
-export interface HealthCommandCompositionInput {
+interface HealthCommandCompositionInput {
     readonly configPath: string;
     readonly env: Readonly<Record<string, string | undefined>>;
     readonly timeoutMs: number;
 }
-export type HealthCommandAdapterComposition = PreflightCommandAdapters & DoctorCommandAdapters;
+type HealthCommandAdapterComposition = PreflightCommandAdapters & DoctorCommandAdapters;
 export declare function createHealthCommandAdapters(rawInput: HealthCommandCompositionInput, execute: (step: ExecutionStep) => Promise<ExecuteProbeOutcome>): HealthCommandAdapterComposition;
+export {};

package/dist/environment/health-composition.js

@@ -14,6 +14,7 @@ import { observeEnvSchemas } from './env-schema-observation.js';
 import { hasErrorCode, RefusalError, ENVIRONMENT_CODES, errorCause, } from './contract.js';
 import { declaresNothingToRun, runtimeNotDeclared } from './declaration.js';
 import { resolveDockerExecutable, resolveGitExecutable } from './executable.js';
+import { inspectMachineStacksForDoctor } from './stack-inventory.js';
 import { createGitObservationStep, observeGit, observeRunningCheckout } from './git-observation.js';
 import { inspectProjectReadiness } from './readiness-composition.js';
 import { stackId } from './identity.js';
@@ -30,6 +31,8 @@ import { readLocalRuntimeMeasurements } from './runtime-measurement-record.js';
 import { consumeSetupCheckoutProjection, observeSetupCheckout, withSetupCheckoutProjection, } from './setup-observation.js';
 import { observeConfiguration, readState, selectStateRoot } from './state.js';
 import { observeTemplateHealth } from './templates.js';
+import { inspectServedSiblings } from './application/siblings.js';
+import { observeServedCheckouts } from './sibling-observation.js';
 function captureInput(value) {
     try {
         if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -347,6 +350,10 @@ function producers(input) {
         state: async () => observeConfiguration({
             path: input.config.result.source.path, stackId: input.stack, observedAt: observedAt(),
         }),
+        siblings: async () => observeServedCheckouts({
+            stackId: input.stack, observedAt: observedAt(), configPath: input.config.result.source.path,
+            config: input.config.result.config,
+        }),
         templates: async () => observeTemplateHealth({
             stackId: input.stack, observedAt: observedAt(), siblingRoot,
             siblings: input.config.result.config.sibling,
@@ -414,6 +421,8 @@ async function inspectWorkEvaluator(root, env, evaluators) {
 export function createHealthCommandAdapters(rawInput, execute) {
     const input = captureInput(rawInput);
     let selectedNamespace;
+    let loadedConfig;
+    let selectedOwn;
     const load = async (command, issue, refuse, purpose) => {
         const requestedPath = commandConfigPath(command);
         if (!input || typeof execute !== 'function' || typeof issue !== 'function'
@@ -425,6 +434,7 @@ export function createHealthCommandAdapters(rawInput, execute) {
             return refuse?.(loaded.diagnostics);
         if (loaded.kind !== 'complete')
             return undefined;
+        loadedConfig = loaded;
         // Health is about a running stack or a machine floor; with neither declared it is not declared,
         // never healthy, and preflight refuses. Doctor still checks what such a cockpit does depend on:
         // its Git working tree, its siblings and its surfaces.
@@ -460,6 +470,8 @@ export function createHealthCommandAdapters(rawInput, execute) {
             checkoutId: checkout.checkoutId,
             variant: { kind: 'shared' },
         });
+        selectedOwn = { cockpitId: checkout.cockpitId, stackId: currentStack, mainCheckoutPath: checkout.mainCheckoutPath,
+            configPath: loaded.result.source.path };
         let stopped = notDeclared ?? null;
         const refreshPreflight = async (previous) => {
             const observedAt = new Date().toISOString();
@@ -622,7 +634,12 @@ export function createHealthCommandAdapters(rawInput, execute) {
         const inventory = await readRootPortInventory(selectedNamespace);
         return inventory.kind === 'complete' ? { kind: 'complete', skipped: inventory.skipped } : inventory;
     };
-    return { load, inspectSurfaceOverrides, ...(inspectHookTrust ? { inspectHookTrust } : {}),
-        ...(inspectEvaluator ? { inspectEvaluator } : {}), ...(inspectReadiness ? { inspectReadiness } : {}), readUnreadableState,
+    const inspectStacks = async () => selectedNamespace && selectedOwn ? inspectMachineStacksForDoctor({ namespace: selectedNamespace, own: selectedOwn, configPath: selectedOwn.configPath }) : [];
+    const inspectServed = input ? (loaded) => {
+        const reuse = loaded ?? loadedConfig;
+        return inspectServedSiblings({ configPath: input.configPath, env: input.env, ...(reuse ? { loaded: reuse } : {}) }, { execute });
+    } : undefined;
+    return { load, inspectSurfaceOverrides, ...(inspectHookTrust ? { inspectHookTrust } : {}), ...(inspectServed ? { inspectServedSiblings: inspectServed } : {}),
+        ...(inspectEvaluator ? { inspectEvaluator } : {}), ...(inspectReadiness ? { inspectReadiness } : {}), readUnreadableState, inspectStacks,
         execute: (step) => execute(step) };
 }

package/dist/environment/init-application.d.ts

@@ -1,6 +1,6 @@
 import type { Diagnostic } from '../diagnostics.js';
 import { type ReadinessReport } from '../readiness.js';
-import { type AnswerProvenance, type DocumentCommandInput, type DocumentOutcome, type EstateClassificationOutcome, type EstateClassificationResult, type UnconfirmedAnswer, type EstateObservationInput } from '../init/draft.js';
+import { type AnswerProvenance, type DocumentCommandInput, type DocumentOutcome, type EstateClassificationOutcome, type EstateClassificationResult, type DerivedAnswer, type UnconfirmedAnswer, type EstateObservationInput } from '../init/draft.js';
 import { type SurfaceTarget } from '../surfaces/contract.js';
 import { type BootstrapStateAddress, type BootstrapStateRecord, type SelectBootstrapStateRootInput, type StateResult } from './state.js';
 export interface InitApplicationInput {
@@ -37,8 +37,8 @@ export interface InitApplicationInput {
         firstSibling: string;
     }>;
 }
-export type CockpitRootAnswer = 'dedicated' | 'in-repo';
-export interface CockpitRootOption {
+type CockpitRootAnswer = 'dedicated' | 'in-repo';
+interface CockpitRootOption {
     readonly answer: CockpitRootAnswer;
     readonly root: string;
     /** Directories init creates before it writes anything else; each is outside the directory init ran in. */
@@ -125,7 +125,7 @@ type ResumedBootstrapOutcome = Readonly<{
     diagnostics: readonly Diagnostic[];
     result: null;
 }>;
-export type DestinationObservation = Readonly<{
+type DestinationObservation = Readonly<{
     kind: 'absent';
 }> | Readonly<{
     kind: 'available';
@@ -174,7 +174,7 @@ export interface InitApplicationAdapters {
     readonly observeRoot?: (input: Readonly<{
         root: string;
     }>) => Promise<'product-repository' | 'cockpit-root'>;
-    /** Proposes answers from files the repositories already carry; every value comes back as inferred. */
+    /** Proposes answers from files the repositories already carry, each derived (exact and complete) or inferred. */
     readonly infer?: (input: Readonly<{
         root: string;
         configurationRoot?: string;
@@ -188,7 +188,7 @@ export interface InitApplicationAdapters {
             target: string;
             value: unknown;
             provenance: Readonly<{
-                kind: 'inferred';
+                kind: 'derived' | 'inferred';
                 source: string;
                 reason: string;
             }>;
@@ -198,6 +198,10 @@ export interface InitApplicationAdapters {
             reason: string;
         }>[];
     }>>;
+    /** What the container runtime on this machine offers, read when the interview will ask for the machine floor. */
+    readonly measureMachine?: (input: Readonly<{
+        root: string;
+    }>) => Promise<MachineMeasurement>;
     /** What check would report about the Compose files a drafted cockpit.toml declares; init never edits them, so it shows the edit. */
     readonly composeFindings?: (input: Readonly<{
         root: string;
@@ -222,7 +226,7 @@ export interface InitApplicationAdapters {
         findings: readonly Diagnostic[];
     }>>;
 }
-export interface GreenfieldQuestion {
+interface GreenfieldQuestion {
     readonly id: string;
     readonly field: string;
     readonly source: string;
@@ -231,7 +235,7 @@ export interface GreenfieldQuestion {
     /** Lines preserve the owner draft exactly when joined with a newline, within bounded human rendering. */
     readonly document?: readonly string[];
 }
-export interface GreenfieldResult extends EstateClassificationResult {
+interface GreenfieldResult extends EstateClassificationResult {
     readonly sourceObservationSha256: string;
     readonly answers: readonly Readonly<{
         questionId: string;
@@ -240,23 +244,42 @@ export interface GreenfieldResult extends EstateClassificationResult {
         provenance: AnswerProvenance;
     }>[];
 }
-/** One proposed value for an unanswered field. It stays a proposal until the operator confirms it in an answer. */
-export interface InferredItem {
+type MachineMeasurement = Readonly<{
+    kind: 'complete';
+    memoryMb: number;
+    cpus: number;
+    observedAt: string;
+}> | Readonly<{
+    kind: 'unavailable';
+    reason: string;
+}>;
+/**
+ * One proposed value for an unanswered field, and how it was established: "derived" is the complete
+ * answer read exactly from the named file and line, "measured" was observed on this machine, and
+ * "inferred" is a hint or partial value that needs judgement.
+ */
+interface Proposal {
     readonly target: string;
     readonly value: unknown;
     readonly provenance: Readonly<{
-        kind: 'inferred';
+        kind: 'derived' | 'measured' | 'inferred';
         source: string;
         reason: string;
     }>;
 }
-export interface OutstandingField {
+interface OutstandingField {
     readonly field: string;
     readonly why: string;
-    readonly inferred: readonly InferredItem[];
+    /**
+     * "agent" when a derived proposal answers the whole field: the setup agent may accept it with
+     * provenance "derived", and bring-up proves it. Everything else needs a person: security
+     * boundaries, and values that are inferred, measured or chosen.
+     */
+    readonly confirmedBy: 'agent' | 'person';
+    readonly proposals: readonly Proposal[];
 }
 /** Every field the interview will still ask, in order, so an unattended caller can answer them in one pass. */
-export interface InterviewPlan {
+interface InterviewPlan {
     /** Fields an earlier run already answered; their answers are kept. */
     readonly answered: readonly string[];
     readonly outstanding: readonly OutstandingField[];
@@ -286,6 +309,8 @@ export interface InitResult {
     }>;
     /** Answers in cockpit.toml no person stated; each stays listed there, and doctor warns, until someone confirms it. */
     readonly unconfirmed?: readonly UnconfirmedAnswer[];
+    /** Answers the setup agent accepted as read from exact sources, each with the file and line it came from. */
+    readonly derived?: readonly DerivedAnswer[];
     /** This run's findings grouped under the prerequisites cockpit depends on: what to do next. */
     readonly readiness?: ReadinessReport;
 }