@litfamily/litopencode 1.0.0

package/dist/hooks.d.ts

@@ -0,0 +1,17 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { SessionLookup } from "./session-lineage.ts";
+import { type DeliverableHedgeSessionState } from "./deliverable-hedge-guard.ts";
+type ToolExecuteBeforeHook = NonNullable<Hooks["tool.execute.before"]>;
+type ToolExecuteAfterHook = NonNullable<Hooks["tool.execute.after"]>;
+export type ToolExecuteHookOptions = {
+    readonly getSession?: SessionLookup;
+};
+export declare function createToolExecuteBeforeHook(options?: ToolExecuteHookOptions): ToolExecuteBeforeHook;
+export type ToolExecuteAfterHookOptions = {
+    readonly projectRoot?: string;
+    readonly knowledgeCaptureEnabled?: boolean;
+    readonly deliverableHedgeState?: DeliverableHedgeSessionState;
+    readonly onSkillActivation?: (sessionID: string, skillId: string) => void | Promise<void>;
+};
+export declare function createToolExecuteAfterHook(options?: ToolExecuteAfterHookOptions): ToolExecuteAfterHook;
+export {};

package/dist/hooks.js

@@ -0,0 +1,83 @@
+import { activationProbe } from "./activation-probe.js";
+import { applyDeliverableHedgeAfterHook } from "./deliverable-hedge-guard.js";
+import { dynamicRulesForPaths } from "./rules/hooks.js";
+import { applyLitOpenCodePostEditHook, applyLitOpenCodeToolAfterHook, applyLitOpenCodeToolBeforeHook, applyTaskRecursionGuard, mutatedFilePaths } from "./tool-guards.js";
+import { captureKnowledgeEvent } from "./knowledge.js";
+import { observeToolIteration } from "./skill-loop/config.js";
+export function createToolExecuteBeforeHook(options = {}) {
+    return async (input, output) => {
+        await applyTaskRecursionGuard(input, options.getSession);
+        applyLitOpenCodeToolBeforeHook(input, output);
+    };
+}
+export function createToolExecuteAfterHook(options = {}) {
+    return async (input, output) => {
+        applyLitOpenCodeToolAfterHook(input, output);
+        applyLitOpenCodePostEditHook(input, output);
+        const activationAction = input.tool === "lit" ? "activate"
+            : input.tool === "litwork" || input.tool === "start-work" ? "start"
+                : input.tool === "review-work" ? "review" : undefined;
+        if (activationAction !== undefined && output.metadata?.command === input.tool &&
+            output.metadata.action === activationAction && output.metadata.blocked !== true &&
+            output.output.startsWith(`${activationProbe(input.tool)}\n`)) {
+            await options.onSkillActivation?.(input.sessionID, input.tool);
+        }
+        if (options.deliverableHedgeState !== undefined) {
+            await applyDeliverableHedgeAfterHook(options.deliverableHedgeState, input, output);
+        }
+        if (options.projectRoot !== undefined && output.metadata?.litopencodeKnowledgeCapture !== undefined) {
+            const request = output.metadata.litopencodeKnowledgeCapture;
+            const metadata = { ...output.metadata };
+            delete metadata.litopencodeKnowledgeCapture;
+            try {
+                const event = typeof request === "object" && request !== null
+                    ? { ...request, source: input.tool }
+                    : request;
+                const receipt = await captureKnowledgeEvent(options.projectRoot, event, {
+                    surface: "tool.execute.after",
+                    captureEnabled: options.knowledgeCaptureEnabled
+                });
+                const knowledgeReceipt = receipt.status === "rejected"
+                    ? { status: receipt.status, reason: receipt.reason }
+                    : receipt.status === "disabled"
+                        ? { status: receipt.status }
+                        : { status: receipt.status, id: receipt.record.id, state: receipt.record.state };
+                output.metadata = { ...metadata, litopencodeKnowledgeReceipt: knowledgeReceipt };
+            }
+            catch {
+                output.metadata = { ...metadata, litopencodeKnowledgeReceipt: { status: "rejected", reason: "STORE_ERROR" } };
+            }
+        }
+        if (options.projectRoot !== undefined) {
+            try {
+                const observation = await observeToolIteration(options.projectRoot, input.sessionID);
+                if (observation.surfaceNotice) {
+                    output.output = `${output.output}\n\nLitOpenCode: skill learning pending review — run \`litopencode skill-loop review\`.`;
+                    output.metadata = { ...output.metadata, litopencodeSkillLoop: { pending: true } };
+                }
+            }
+            catch { // no-excuse-ok: catch -- learning state must never break the host tool result.
+                output.metadata = { ...output.metadata, litopencodeSkillLoop: { pending: false, reason: "STORE_ERROR" } };
+            }
+        }
+        // The dynamic rules lane rides the same post-edit surface: rules scoped by globs are delivered
+        // only when a path the session actually mutated matches one.
+        if (options.projectRoot === undefined)
+            return;
+        if (input.tool !== "edit" && input.tool !== "write")
+            return;
+        const mutated = mutatedFilePaths(input.args);
+        if (mutated.length === 0)
+            return;
+        try {
+            const rules = await dynamicRulesForPaths({ projectRoot: options.projectRoot }, input.sessionID, mutated);
+            if (rules.text === "")
+                return;
+            output.output = `${output.output}\n\n${rules.text}`;
+            output.metadata = { ...output.metadata, litopencodeRules: { lane: "dynamic", ruleCount: rules.ruleCount } };
+        }
+        catch { // no-excuse-ok: catch -- a rules read must never break the tool result the user is waiting on.
+            // Rule discovery touches the filesystem; an unreadable repository must not fail the edit.
+        }
+    };
+}

package/dist/ignition.d.ts

@@ -0,0 +1,14 @@
+export declare function ignitionMark(first: boolean, discipline: string, env?: NodeJS.ProcessEnv): string;
+export declare function createIgnitionState(): {
+    activate(sessionID: string, skillId: string): void;
+    resetDiscipline(sessionID: string): void;
+    clear(sessionID: string): void;
+    complete: (input: {
+        sessionID: string;
+        messageID: string;
+        partID: string;
+    }, output: {
+        text: string;
+    }) => Promise<void>;
+    dispose(): void;
+};

package/dist/ignition.js

@@ -0,0 +1,33 @@
+import { activationDiscipline } from "./activation-probe.js";
+import { micro, standard, supportsMarkGlyphs } from "./lit-mark.js";
+import { stripUserFacingBlankHtmlCommentLines } from "./user-facing-markdown.js";
+// OpenCode renders completion text as Markdown, so never send terminal escape codes here.
+export function ignitionMark(first, discipline, env = process.env) {
+    const label = `litopencode · ${activationDiscipline(discipline)}`;
+    const rows = !supportsMarkGlyphs(env) ? ["LIT", label]
+        : first ? [...standard, label]
+            : micro.map((row, index) => row + (index === 2 ? `  ${label}` : ""));
+    return ["```text", ...rows, "```"].join("\n");
+}
+export function createIgnitionState() {
+    const seen = new Set();
+    const disciplines = new Map();
+    let disposed = false;
+    const complete = async (input, output) => {
+        const text = stripUserFacingBlankHtmlCommentLines(output.text);
+        if (disposed) {
+            output.text = text;
+            return;
+        }
+        const mark = ignitionMark(!seen.has(input.sessionID), disciplines.get(input.sessionID) ?? "lit-loop");
+        seen.add(input.sessionID);
+        output.text = `${mark}${text === "" ? "" : `\n\n${text}`}`;
+    };
+    return {
+        activate(sessionID, skillId) { disciplines.set(sessionID, skillId); },
+        resetDiscipline(sessionID) { disciplines.delete(sessionID); },
+        clear(sessionID) { seen.delete(sessionID); disciplines.delete(sessionID); },
+        complete,
+        dispose() { seen.clear(); disciplines.clear(); disposed = true; }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import litOpenCodePlugin from "./server.ts";
+export { LifecycleConflictError, LifecycleSafetyError, boundedAuthoritySchemaVersion, createBoundedAuthorityLifecycle, lifecyclePaths, parseFencedProgress, readBoundedContextFile, type AuthorityBoundary, type AuthorityGrant, type BoundedAuthorityLifecycle, type BoundedAuthorityOptions, type BoundedAuthorityState, type BoundedContextFile, type BoundedWorkStatus, type ConsumedAuthorityGrant, type FencedProgress, type LifecycleBoundaryRequest, type LifecycleInitRequest, type LifecycleMutationResult, type LifecycleResumeRequest, type LifecycleTerminalRequest, type ProgressRecordRequest, type ProgressRecordResult, type SemanticAuthorityAction } from "./bounded-authority.ts";
+export { applyTrustedStartWorkDirective, createBoundedAuthorityEventHook, parseStartWorkLifecycleDirective, type StartWorkLifecycleDirective } from "./bounded-authority-hooks.ts";
+export { appendLedgerEvent, createLitGoalOperations, initializeLitGoal, readLedgerEvents, readLedgerEventsLenient, recoverLedgerTemps, LedgerIoError, LedgerParseError, type JsonValue, type LedgerAppendResult, type LedgerEvent, type LedgerReadDiagnostic, type LedgerRecoveryReport, type LenientLedgerReadResult, type LitGoalInitialization, type LitGoalOperations } from "./ledger.ts";
+export { containsStandaloneLitTrigger, createChatMessageActivationHook, detectChatActivationMode, litLoopPromptInjection, litPlanPromptInjection } from "./activation.ts";
+export { defaultGlobalConfigFile, defaultGlobalConfigJson, effectiveAgentConfig, litOpenCodeConfigSchema, loadConfig, mergeAgentModelConfig, mergeConfigs, readLitOpenCodeConfigFile, type LitOpenCodeAgentModelConfig, type BoundedAuthorityConfig, type KnowledgeConfig, type LitOpenCodeCategoryConfig, type LitOpenCodeConfig, type LitOpenCodeConfigSource, type LitOpenCodePermissionMode, type LoadedConfig, type ReasoningEffort, type TextVerbosity } from "./config.ts";
+export { captureKnowledgeEvent, inspectKnowledge, knowledgeKinds, knowledgePaths, knowledgeStates, queryKnowledge, readKnowledgeClaims, recoverKnowledge, reviewKnowledgeRecord, KnowledgeStoreError, type KnowledgeCaptureResult, type KnowledgeEvent, type KnowledgeKind, type KnowledgePaths, type KnowledgeQueryResult, type KnowledgeRecord, type KnowledgeReviewResult, type KnowledgeState } from "./knowledge.ts";
+export { litActivationBanner, litOpenCodeCommands } from "./commands.ts";
+export { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "./hooks.ts";
+export { applyProposal, rejectProposal, rollbackLedgerEntry, litOpenCodeAgentGeneratedMarker } from "./skill-loop/apply.ts";
+export { curatorStatus, runCurator } from "./skill-loop/curator.ts";
+export { defaultSkillLoopConfig, observeToolIteration, readSkillLoopConfig, skillLoopPaths } from "./skill-loop/config.ts";
+export { listProposals, parseSkillProposal, proposeFromFile, readProposal } from "./skill-loop/proposals.ts";
+export { bumpSkillUsage, readUsageSidecar, writeUsageSidecar } from "./skill-loop/usage.ts";
+export { applyDeliverableHedgeAfterHook, artifactGenres, createDeliverableHedgeSessionState, inspectDeliverableHedges, readOutputChannelContract, type ArtifactGenre, type DeliverableHedgeFinding, type DeliverableHedgeSessionState, type HedgeClass, type LimitationsChannel, type OutputChannelContract } from "./deliverable-hedge-guard.ts";
+export { activationRegexMetric, createProviderUsageReceiptEventHook, emptyProviderCacheMeasurement, providerUsageReceiptFromEvent, recordProviderUsageReceipt, ruleDedupMetric, updateCacheMetric, type ProviderCacheMeasurement, type ProviderUsageReceipt, type ProviderUsageReceiptEventOptions, type RuleDedupMetric, type ActivationRegexMetric, type UpdateCacheMetric } from "./cache-metrics.ts";
+export { benchmarkGateAllowsStrongClaim, classifyReferenceSuperiorityClaim, certifyDeclaredBenchmarkUniverse, litOpenCodeClaimPolicy, litOpenCodeReferenceBenchmark, renderDeclaredBenchmarkUniverseClaim, type LitOpenCodeBenchmarkGateInput, type LitOpenCodeBenchmarkScoringDimension, type LitOpenCodeBenchmarkTaskCategory, type LitOpenCodeBenchmarkTaskResult, type LitOpenCodeBenchmarkTaskWinner, type LitOpenCodeBenchmarkUniverseCertification, type LitOpenCodeBenchmarkUniverseCertificationInput, type LitOpenCodeClaimClassification, type LitOpenCodeClaimPolicy, type LitOpenCodeClaimVerdict, type LitOpenCodeReferenceBenchmark } from "./benchmark.ts";
+export { completeGoals, countRecordedEvidence, createGoals, criterionStatuses, evaluateGoalGate, evidenceKinds, EvidenceLedgerError, evidenceLedgerVersion, goalStatuses, readEvidenceLedger, readEvidenceLedgerStatus, recordCheckpoint, recordEvidence, recordReviewBlocker, recordSteering, renderEvidenceBrief, steeringKinds, steeringWeakeningReason, type Checkpoint, type Criterion, type CriterionStatus, type EvidenceEntry, type EvidenceKind, type EvidenceLedgerState, type GateVerdict, type Goal, type GoalStatus, type ReviewBlocker, type SteeringEntry, type SteeringKind } from "./ledger.ts";
+export { applyLitOpenCodePostEditHook, applyLitOpenCodeToolAfterHook, applyLitOpenCodeToolBeforeHook, applyTaskRecursionGuard, mutatedFilePaths, postEditSkillRoutes, type LitOpenCodeToolAction, type LitOpenCodeToolId, type PostEditSkillRoute, type ToolGuardAfterOutput, type ToolGuardBeforeOutput, type ToolGuardDecision, type ToolGuardMarker, type ToolGuardRequest } from "./tool-guards.ts";
+export { litOpenCodeTools, litTool, litworkTool, reviewWorkTool, startWorkTool, wikifyTool } from "./tools.ts";
+export { findLitOpenCodeFeature, litOpenCodeFeatures, type LitOpenCodeBindingKind, type LitOpenCodeFeature, type LitOpenCodeFeatureBinding, type LitOpenCodeFeatureId } from "./features.ts";
+export { findLitOpenCodeStaticOnlySkill, findLitOpenCodeRuntimeSkill, litOpenCodeStaticOnlySkills, litOpenCodeRuntimeSkills, type LitOpenCodeRuntimeSkill, type LitOpenCodeRuntimeSkillId, type LitOpenCodeStaticOnlySkill, type LitOpenCodeStaticOnlySkillId } from "./skills.ts";
+export { findLitOpenCodeSearchWorkflowIdea, litOpenCodeSearchWorkflowIdeas, type LitOpenCodeSearchWorkflowIdea, type LitOpenCodeSearchWorkflowIdeaId } from "./search-workflow-ideas.ts";
+export { fetchPublicSource, type FetchAttempt, type FetchVerdict, type PublicSourceContentSafety, type PublicSourceFetchAttempt, type PublicSourceFetchOptions, type PublicSourceFetchPolicyReceipt, type PublicSourceFetchResult, type PublicSourceFetchVerdict, type PublicSourceTraceEntry, type PublicSourceVerdict } from "./lit-fetch.ts";
+export declare const pluginId = "litopencode";
+export declare const pluginModule: {
+    id: string;
+    server: (input?: import("@opencode-ai/plugin").PluginInput) => Promise<import("@opencode-ai/plugin").Hooks>;
+};
+export default litOpenCodePlugin;

package/dist/index.js

@@ -0,0 +1,30 @@
+import litOpenCodePlugin from "./server.js";
+export { LifecycleConflictError, LifecycleSafetyError, boundedAuthoritySchemaVersion, createBoundedAuthorityLifecycle, lifecyclePaths, parseFencedProgress, readBoundedContextFile } from "./bounded-authority.js";
+export { applyTrustedStartWorkDirective, createBoundedAuthorityEventHook, parseStartWorkLifecycleDirective } from "./bounded-authority-hooks.js";
+export { appendLedgerEvent, createLitGoalOperations, initializeLitGoal, readLedgerEvents, readLedgerEventsLenient, recoverLedgerTemps, LedgerIoError, LedgerParseError } from "./ledger.js";
+export { containsStandaloneLitTrigger, createChatMessageActivationHook, detectChatActivationMode, litLoopPromptInjection, litPlanPromptInjection } from "./activation.js";
+export { defaultGlobalConfigFile, defaultGlobalConfigJson, effectiveAgentConfig, litOpenCodeConfigSchema, loadConfig, mergeAgentModelConfig, mergeConfigs, readLitOpenCodeConfigFile } from "./config.js";
+export { captureKnowledgeEvent, inspectKnowledge, knowledgeKinds, knowledgePaths, knowledgeStates, queryKnowledge, readKnowledgeClaims, recoverKnowledge, reviewKnowledgeRecord, KnowledgeStoreError } from "./knowledge.js";
+export { litActivationBanner, litOpenCodeCommands } from "./commands.js";
+export { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "./hooks.js";
+export { applyProposal, rejectProposal, rollbackLedgerEntry, litOpenCodeAgentGeneratedMarker } from "./skill-loop/apply.js";
+export { curatorStatus, runCurator } from "./skill-loop/curator.js";
+export { defaultSkillLoopConfig, observeToolIteration, readSkillLoopConfig, skillLoopPaths } from "./skill-loop/config.js";
+export { listProposals, parseSkillProposal, proposeFromFile, readProposal } from "./skill-loop/proposals.js";
+export { bumpSkillUsage, readUsageSidecar, writeUsageSidecar } from "./skill-loop/usage.js";
+export { applyDeliverableHedgeAfterHook, artifactGenres, createDeliverableHedgeSessionState, inspectDeliverableHedges, readOutputChannelContract } from "./deliverable-hedge-guard.js";
+export { activationRegexMetric, createProviderUsageReceiptEventHook, emptyProviderCacheMeasurement, providerUsageReceiptFromEvent, recordProviderUsageReceipt, ruleDedupMetric, updateCacheMetric } from "./cache-metrics.js";
+export { benchmarkGateAllowsStrongClaim, classifyReferenceSuperiorityClaim, certifyDeclaredBenchmarkUniverse, litOpenCodeClaimPolicy, litOpenCodeReferenceBenchmark, renderDeclaredBenchmarkUniverseClaim } from "./benchmark.js";
+export { completeGoals, countRecordedEvidence, createGoals, criterionStatuses, evaluateGoalGate, evidenceKinds, EvidenceLedgerError, evidenceLedgerVersion, goalStatuses, readEvidenceLedger, readEvidenceLedgerStatus, recordCheckpoint, recordEvidence, recordReviewBlocker, recordSteering, renderEvidenceBrief, steeringKinds, steeringWeakeningReason } from "./ledger.js";
+export { applyLitOpenCodePostEditHook, applyLitOpenCodeToolAfterHook, applyLitOpenCodeToolBeforeHook, applyTaskRecursionGuard, mutatedFilePaths, postEditSkillRoutes } from "./tool-guards.js";
+export { litOpenCodeTools, litTool, litworkTool, reviewWorkTool, startWorkTool, wikifyTool } from "./tools.js";
+export { findLitOpenCodeFeature, litOpenCodeFeatures } from "./features.js";
+export { findLitOpenCodeStaticOnlySkill, findLitOpenCodeRuntimeSkill, litOpenCodeStaticOnlySkills, litOpenCodeRuntimeSkills } from "./skills.js";
+export { findLitOpenCodeSearchWorkflowIdea, litOpenCodeSearchWorkflowIdeas } from "./search-workflow-ideas.js";
+export { fetchPublicSource } from "./lit-fetch.js";
+export const pluginId = "litopencode";
+export const pluginModule = {
+    id: pluginId,
+    server: litOpenCodePlugin
+};
+export default litOpenCodePlugin;

package/dist/inert-data.d.ts

@@ -0,0 +1,2 @@
+export declare function serializeInertData(value: string): string;
+export declare function encodeXmlInvalidCharacters(value: string): string;

package/dist/inert-data.js

@@ -0,0 +1,13 @@
+const modelShapingCharacters = /[`~\u007f-\u009f\u2028\u2029\ufffe\uffff]|\p{Cf}/gu;
+const xmlInvalidCharacters = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\ufffe\uffff]/gu;
+function visibleUtf16(character) {
+    return Array.from({ length: character.length }, (_, index) => `\\u${character.charCodeAt(index).toString(16).padStart(4, "0")}`).join("");
+}
+// JSON handles C0, quotes, and backslashes. The post-pass makes every remaining model-shaping
+// character visible while preserving supplementary code points as complete UTF-16 surrogate pairs.
+export function serializeInertData(value) {
+    return JSON.stringify(value).replace(modelShapingCharacters, visibleUtf16);
+}
+export function encodeXmlInvalidCharacters(value) {
+    return value.replace(xmlInvalidCharacters, visibleUtf16);
+}

package/dist/knowledge.d.ts

@@ -0,0 +1,98 @@
+export declare const knowledgeKinds: readonly ["fact", "decision", "failure", "risk", "rule", "checkpoint"];
+export type KnowledgeKind = (typeof knowledgeKinds)[number];
+export declare const knowledgeStates: readonly ["review-needed", "accepted", "rejected", "stale"];
+export type KnowledgeState = (typeof knowledgeStates)[number];
+export type KnowledgeEvent = {
+    readonly kind: KnowledgeKind;
+    readonly text: string;
+    readonly evidenceRef: string;
+    readonly source: string;
+};
+export type KnowledgeRecord = {
+    readonly id: string;
+    readonly text: string;
+    readonly kind: KnowledgeKind;
+    readonly state: KnowledgeState;
+    readonly timestamp: string;
+    readonly provenance: {
+        readonly product: "litopencode";
+        readonly surface: string;
+        readonly source: string;
+    };
+    readonly evidence: {
+        readonly ref: string;
+    };
+};
+export type KnowledgePaths = {
+    readonly projectRoot: string;
+    readonly runtimeDirectory: string;
+    readonly directory: string;
+    readonly claimsFile: string;
+    readonly lockDirectory: string;
+    readonly projectRootIdentity?: DirectoryIdentity;
+    readonly runtimeDirectoryIdentity?: DirectoryIdentity;
+    readonly directoryIdentity?: DirectoryIdentity;
+};
+export type KnowledgeCaptureResult = {
+    readonly status: "captured" | "duplicate";
+    readonly record: KnowledgeRecord;
+} | {
+    readonly status: "disabled";
+} | {
+    readonly status: "rejected";
+    readonly reason: string;
+};
+export type KnowledgeReviewResult = {
+    readonly status: "updated" | "duplicate";
+    readonly record: KnowledgeRecord;
+} | {
+    readonly status: "blocked";
+    readonly reason: string;
+};
+export type KnowledgeQueryResult = {
+    readonly text: string;
+    readonly records: readonly KnowledgeRecord[];
+    readonly budgetBytes: number;
+    readonly byteLength: number;
+};
+export declare class KnowledgeStoreError extends Error {
+    constructor(message: string);
+}
+type DirectoryIdentity = {
+    readonly dev: number | bigint;
+    readonly ino: number | bigint;
+    readonly ctimeMs: number | bigint;
+    readonly birthtimeMs: number | bigint;
+};
+type RecoveryStatus = "clean" | "recovered" | "recovery-required";
+type RecoveryResult = {
+    readonly status: RecoveryStatus;
+    readonly recovered: boolean;
+    readonly recoveryRequired: boolean;
+    readonly removed: readonly string[];
+    readonly preserved: readonly string[];
+};
+export declare function knowledgePaths(projectRoot: string): KnowledgePaths;
+export declare function readKnowledgeClaims(projectRoot: string): Promise<readonly KnowledgeRecord[]>;
+export declare function recoverKnowledge(projectRoot: string): Promise<RecoveryResult>;
+export declare function captureKnowledgeEvent(projectRoot: string, value: unknown, options: {
+    readonly surface: string;
+    readonly captureEnabled?: boolean;
+    readonly now?: () => Date;
+}): Promise<KnowledgeCaptureResult>;
+export declare function reviewKnowledgeRecord(projectRoot: string, input: {
+    readonly id: string;
+    readonly state: Exclude<KnowledgeState, "review-needed">;
+    readonly surface: string;
+    readonly now?: () => Date;
+}): Promise<KnowledgeReviewResult>;
+export declare function queryKnowledge(projectRoot: string, query: string, options?: {
+    readonly budgetBytes?: number;
+}): Promise<KnowledgeQueryResult>;
+export declare function inspectKnowledge(projectRoot: string): Promise<{
+    readonly authority: "claims.jsonl";
+    readonly path: string;
+    readonly counts: Record<KnowledgeState, number>;
+    readonly derivedTruthFiles: 0;
+}>;
+export {};