polydeukes 0.6.0 → 0.7.1

package/dist/docs-query.js

@@ -1,138 +1,44 @@
-/**
- * `queryDocs` — the offline documentation query.
- *
- * The bundled English guides, answered from the installed version. An AI partner that
- * searches the web gets whatever release the internet indexed; this returns the document
- * that shipped with the code doing the judging, with no network at all.
- *
- * The domain is the five topics below and nothing else. An unknown topic throws instead of
- * resolving to something near it: an answer to a question we never mapped is
- * indistinguishable from a real one by the time it reaches a reader.
- *
- * Every failure throws so the bin can leave stdout at zero bytes and exit 2. Text written
- * halfway is read as the document and quoted as the document — the same direction the
- * judging surface fails in, for the same reason.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-/** The finite query domain — the topic list `pdks docs` prints with no argument. */
-export const TOPICS = ['install', 'config', 'discipline', 'covenant', 'witness'];
-/** The mapping, as data: which document answers a topic, and what to read next. */
-const TOPIC_MAP = {
-    install: {
-        sections: [{ file: 'installation.md' }],
-        seeAlso: 'reference/polydeukes.md',
-    },
-    config: {
-        sections: [{ file: 'reference/configuration.md' }],
-        seeAlso: 'reference/core.md',
-    },
-    discipline: {
-        sections: [{ file: 'reference/configuration.md', heading: '## `disciplines`' }],
-        seeAlso: 'reference/covenant.md',
-    },
-    covenant: {
-        sections: [{ file: 'configuration.md', heading: '## What enforcement looks like' }],
-        seeAlso: 'reference/polydeukes.md',
-    },
-    witness: {
-        sections: [
-            { file: 'reference/configuration.md', heading: '## `witness`' },
-            { file: 'troubleshooting.md', heading: '## Opening a blocked call — the witness' },
-        ],
-        seeAlso: 'reference/covenant.md',
-    },
-};
-/** A fenced block opens and closes on a line whose trimmed form starts with the marker. */
-const FENCE = /^(?:`{3,}|~{3,})/;
-/** An ATX heading, and its level in the capture. */
-const HEADING = /^(#{1,6}) /;
-function isTopic(value) {
-    return TOPICS.includes(value);
-}
-function headingLevel(line) {
-    return HEADING.exec(line)?.[1].length ?? 0;
+import { runDocs } from './docs-library.js';
+export { DOCS_TOPICS as TOPICS } from './docs-types.js';
+/** Answer a legacy topic using the same catalog as search and show. */
+export function queryDocs(spec) {
+    return runDocs({
+        docsRoot: spec.docsRoot,
+        args: spec.topic === undefined ? [] : [spec.topic],
+        version: '',
+    });
 }
 /**
- * The body of one section of `markdown`: from the line equal to `heading` up to just before
- * the next heading of the same or a higher level, returned verbatim.
- *
- * `heading` is matched by exact string equality. A document that renames its heading kills
- * the query here rather than letting a normalizing matcher hand back a neighbouring section
- * with full confidence.
- *
- * Both scans — for the start and for the boundary — run outside code fences. `#` lines
- * inside a fence are content: the guides really carry them, and a fence-blind scanner cuts
- * the answer at one of those lines while still looking like a success.
+ * Extract a section by its exact heading, retaining the original internal helper's contract.
+ * Topic retrieval uses stable IDs instead; this helper remains for existing internal callers.
  */
 export function extractSection(markdown, heading) {
     const lines = markdown.split('\n');
-    const level = headingLevel(heading);
-    let openMarker;
+    const level = /^(#{1,6}) /.exec(heading)?.[1].length ?? 0;
+    let fence;
     let start = -1;
-    for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i];
-        const trimmed = line.trim();
-        if (FENCE.test(trimmed)) {
-            // Opener and closer are both compared trimmed. An indented fence closed by a strict
-            // bare-marker test would stay open to end of file, and every heading after it would
-            // silently stop being a heading — the guides carry a two-space-indented one.
-            if (openMarker === undefined) {
-                openMarker = trimmed[0];
-            }
-            else if (trimmed[0] === openMarker) {
-                openMarker = undefined;
-            }
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const marker = /^(`{3,}|~{3,})/.exec(line.trim())?.[1];
+        if (marker) {
+            if (fence === undefined)
+                fence = { marker: marker[0], length: marker.length };
+            else if (fence.marker === marker[0] && marker.length >= fence.length)
+                fence = undefined;
             continue;
         }
-        if (openMarker !== undefined) {
+        if (fence !== undefined)
             continue;
-        }
         if (start === -1) {
-            if (line === heading) {
-                start = i;
-            }
+            if (line === heading)
+                start = index;
             continue;
         }
-        if (headingLevel(line) > 0 && headingLevel(line) <= level) {
-            return lines.slice(start, i).join('\n');
-        }
+        const nextLevel = /^(#{1,6}) /.exec(line)?.[1].length ?? 0;
+        if (nextLevel > 0 && nextLevel <= level)
+            return lines.slice(start, index).join('\n');
     }
-    if (start === -1) {
+    if (start === -1)
         throw new Error(`heading not found: ${heading}`);
-    }
-    // A section that closes the document ends at end of file; the topic map points at one.
     return lines.slice(start).join('\n');
 }
-function readSection(docsRoot, section) {
-    const path = join(docsRoot, section.file);
-    if (!existsSync(path)) {
-        // Named, never swallowed into empty text: a silently incomplete bundle would otherwise
-        // reach a reader as the document itself.
-        throw new Error(`bundled document missing: ${section.file}`);
-    }
-    const markdown = readFileSync(path, 'utf-8');
-    return section.heading === undefined ? markdown : extractSection(markdown, section.heading);
-}
-/**
- * Answer one documentation query.
- *
- * With no topic the result is the listing — how an AI discovers what it may ask at all.
- * With one, it is the mapped section body followed by the bundled reference to read next.
- */
-export function queryDocs(spec) {
-    if (spec.topic === undefined) {
-        return { text: `Polydeukes docs:\n${TOPICS.map((t) => `  pdks docs ${t}`).join('\n')}\n` };
-    }
-    if (!isTopic(spec.topic)) {
-        throw new Error(`unknown docs topic '${spec.topic}' — known topics: ${TOPICS.join(', ')}`);
-    }
-    const entry = TOPIC_MAP[spec.topic];
-    const body = entry.sections.map((section) => readSection(spec.docsRoot, section)).join('\n');
-    // Resolved against the bundle, not printed as the bare relative name. A reader given
-    // `reference/core.md` has to guess where the bundle lives before it can open anything, and
-    // this line is the only way most of the reference layer is reached at all. A path a file-read
-    // tool can take is the difference between a pointer and a dead end, and a dead end sends the
-    // reader back to the web search this command replaces.
-    return { text: `${body}\nSee also: ${join(spec.docsRoot, entry.seeAlso)}\n` };
-}

package/dist/docs-types.d.ts

@@ -0,0 +1,105 @@
+/** Languages included in every bundled document. */
+export type DocsLanguage = 'en' | 'ko';
+/** Backward-compatible topic names; their targets belong to the catalog. */
+export declare const DOCS_TOPICS: readonly ['install', 'config', 'discipline', 'covenant', 'witness'];
+/** Source-root-relative Markdown path and localized metadata used for retrieval and ranking. */
+export type DocsTranslation = {
+    path: string;
+    title: string;
+    summary: string;
+    terms?: string[];
+};
+/** Catalog entry identifying a document across languages and selecting it for bundling. */
+export type DocsDocument = {
+    id: string;
+    category: string;
+    order: number;
+    bundled: boolean;
+    en: DocsTranslation;
+    ko?: DocsTranslation;
+};
+/** Source inventory shared by the documentation build and offline query commands. */
+export type DocsCatalog = {
+    schemaVersion: number;
+    documents: DocsDocument[];
+    topics: Record<string, DocsTopic>;
+    redirects?: DocsRedirect[];
+};
+/** Ordered content references for a legacy topic, plus a document ID for further reading. */
+export type DocsTopic = {
+    references: DocsReference[];
+    seeAlso: string;
+};
+/** Stable document ID, optionally narrowed to a section; omission selects the whole document. */
+export type DocsReference = {
+    documentId: string;
+    sectionId?: string;
+};
+/** Move-notice path and canonical destination, both relative to the documentation root. */
+export type DocsRedirect = {
+    path: string;
+    target: string;
+};
+/** Anchored Markdown slice with zero-based line bounds: inclusive start, exclusive end. */
+export type DocsSection = {
+    id: string;
+    title: string;
+    level: number;
+    startLine: number;
+    endLine: number;
+    text: string;
+};
+/** Bilingual metadata returned for a document included in a completed build. */
+export type DocsBundleDocument = {
+    id: string;
+    bundled: boolean;
+    category: string;
+    order: number;
+    translations: Record<DocsLanguage, DocsTranslation>;
+};
+/** Indexed section location; the hash covers its entire translated document, not the section. */
+export type DocsBundleSection = {
+    documentId: string;
+    language: DocsLanguage;
+    sectionId: string;
+    title: string;
+    level: number;
+    path: string;
+    hash: string;
+};
+/** Persisted bundle metadata and document hashes, reconstructed on load to detect inconsistency. */
+export type DocsIndex = {
+    schemaVersion: 1;
+    documents: Array<{
+        id: string;
+        bundled: boolean;
+        category: string;
+        order: number;
+        translations: Record<DocsLanguage, DocsTranslation>;
+        hashes: Record<DocsLanguage, string>;
+    }>;
+    sections: DocsBundleSection[];
+};
+/** In-memory catalog and index with loaded Markdown keyed by stable document ID. */
+export type LoadedDocsBundle = {
+    catalog: DocsCatalog;
+    index: DocsIndex;
+    documents: Map<string, LoadedDocsDocument>;
+    topics: Record<string, DocsTopic>;
+};
+/** Loaded bilingual Markdown with parsed sections and empty search-term lists where omitted. */
+export type LoadedDocsDocument = {
+    id: string;
+    bundled: boolean;
+    category: string;
+    order: number;
+    translations: Record<DocsLanguage, {
+        path: string;
+        title: string;
+        summary: string;
+        terms: string[];
+        markdown: string;
+        hash: string;
+        sections: DocsSection[];
+    }>;
+};

package/dist/docs-types.js

@@ -0,0 +1,2 @@
+/** Backward-compatible topic names; their targets belong to the catalog. */
+export const DOCS_TOPICS = ['install', 'config', 'discipline', 'covenant', 'witness'];

package/dist/explain.d.ts

@@ -17,7 +17,7 @@ export type ExplainSpec = {
  * Read the config at `repoRoot`, assemble both surfaces, and render them.
  *
  * The session assembly is given a transcript path, so its `transcript-mod` registration
- * exists here exactly as it does under a normal hook payload — the path is never read,
+ * exists here exactly as it does under a normal call payload — the path is never read,
  * because the injected transcript is the no-op one.
  */
 export declare function explain(spec: ExplainSpec): Promise<{

package/dist/explain.js

@@ -9,15 +9,18 @@
  * nothing and reads no disk. Every failure throws: an answer that cannot be given is never
  * given halfway.
  */
-import { join } from 'node:path';
-import { resolveGitAdapterSettings } from '@polydeukes/adapter-git';
 import { AXIS_NAMES, deriveShape, noopTranscript, RELATION_NAMES } from '@polydeukes/core';
-import { assembleSessionRegistrations } from './claude-code-hook.js';
-import { assembleCommitRegistrations } from './covenant-check.js';
-import { loadCovenantModule, resolveCovenantDist } from './covenant-module.js';
+import { covenantModule } from './covenant/module.js';
+import { assembleChangeSetRegistrations, assembleCheckRegistrations } from './covenant-check.js';
 import { loadConfig } from './load-config.js';
 /** The three meta-covenant labels: registrations that protect the judging chain itself. */
 const META_LABELS = new Set(['self-mod', 'shell-mod', 'transcript-mod']);
+/**
+ * What the session assembly here is given as its evidence path. The real one is loaded per
+ * call by an adapter, so this renderer names the IR key instead of a file: the assembly
+ * needs a present value to build the conditional registration, and nothing prints it.
+ */
+const SESSION_EVIDENCE_PATH_KEY = 'session.evidencePath';
 /**
  * The description of a declaration entry: its catalogue coordinate (the mechanism, the axes
  * its sources derive, and the relations its entries decide), then what it routes on, how
@@ -58,7 +61,7 @@ function row(kind, label, width, description) {
 /** The description of a meta-covenant registration — how much surface it covers. */
 function metaDescription(registration, surface) {
     if (registration.label === 'transcript-mod') {
-        return 'content predicate · conditional: transcript_path';
+        return 'content predicate · conditional: session.evidencePath';
     }
     return `paths ${registration.protectedPaths.length} (${surface})`;
 }
@@ -105,47 +108,59 @@ function renderSurface(spec) {
  * Read the config at `repoRoot`, assemble both surfaces, and render them.
  *
  * The session assembly is given a transcript path, so its `transcript-mod` registration
- * exists here exactly as it does under a normal hook payload — the path is never read,
+ * exists here exactly as it does under a normal call payload — the path is never read,
  * because the injected transcript is the no-op one.
  */
 export async function explain(spec) {
     const { config, configPath } = loadConfig({ rootDir: spec.repoRoot });
-    // Resolved and imported exactly as the two runners do, so what this renders is the table
-    // that would judge: a dist those runners would refuse cannot be rendered as if it worked.
-    // The load names the missing module and the recovery command.
-    const covenant = await loadCovenantModule(resolveCovenantDist());
-    const disciplines = config.disciplines ?? [];
+    // The judge module the two runners assemble against, so what this renders is the table
+    // that would judge.
+    const covenant = covenantModule;
+    const shared = config.disciplines ?? [];
+    const sessionOnly = config.sessionDisciplines ?? [];
+    const changeSetOnly = config.changeSetDisciplines ?? [];
     const drafts = config.drafts ?? [];
-    const session = assembleSessionRegistrations({
+    const session = assembleCheckRegistrations({
         config,
         rootDir: spec.repoRoot,
         covenant,
-        transcriptPath: join(spec.repoRoot, 'transcript.jsonl'),
+        surface: 'session',
+        // The session key alone, and no roster: a roster is what an adapter loads onto each
+        // call, so a reader of the config would be shown one agent's names chosen by this
+        // renderer. The evidence path is the same kind of per-call value and is named by the
+        // key rather than by a filename: what a config reader is being shown is that the
+        // session surface carries a transcript-mod registration, and the renderer prints the
+        // key, never the path. The empty lists are the session a run supplies.
+        session: { evidencePath: SESSION_EVIDENCE_PATH_KEY, userMessages: [], toolCalls: [] },
         transcript: noopTranscript,
     });
-    const commit = assembleCommitRegistrations({
+    const changeSet = assembleChangeSetRegistrations({
         config,
         rootDir: spec.repoRoot,
         covenant,
+        surface: 'changeSet',
     });
-    const gitSettings = resolveGitAdapterSettings({ namespace: config.adapters?.git });
     const text = [
         `pdks explain — ${configPath}`,
         '',
         renderSurface({
-            header: 'surface: session (claude-code hook) · disciplines: advise unless enforce: block · meta: block',
+            header: 'input: call IR (one call, stdin) · ' +
+                `disciplines ${shared.length} · sessionDisciplines ${sessionOnly.length} · ` +
+                'disciplines: advise unless enforce: block · meta: block',
             registrations: session,
             drafts,
-            disciplines,
+            disciplines: [...shared, ...sessionOnly],
             selfModScope: 'common; includes the config file itself',
         }),
         '',
         renderSurface({
-            header: `surface: commit (git pre-commit) · enforce: ${gitSettings.enforce} · disciplines: advise unless enforce: block`,
-            registrations: commit,
+            header: 'input: --diff (change set, stdin) · ' +
+                `disciplines ${shared.length} · changeSetDisciplines ${changeSetOnly.length} · ` +
+                'disciplines: advise unless enforce: block',
+            registrations: changeSet,
             drafts,
-            disciplines,
-            selfModScope: 'common ∪ adapters.git; deduped, includes the config file itself',
+            disciplines: [...shared, ...changeSetOnly],
+            selfModScope: 'common; includes the config file itself',
         }),
         '',
     ].join('\n');

package/dist/load-config.d.ts

@@ -4,7 +4,7 @@
  *
  * This lives in its own module rather than in the package barrel because ESM re-exports are
  * eager: importing `loadConfig` from the barrel would instantiate both composition roots,
- * putting the session adapter on the commit surface's load path where it is never used. A
+ * putting the session adapter on the change-set surface's load path where it is never used. A
  * workspace missing only that dist would then kill `pdks covenant check` before its
  * fail-closed handler could record a row. Both composition roots import this module directly
  * for the same reason.

package/dist/load-config.js

@@ -4,7 +4,7 @@
  *
  * This lives in its own module rather than in the package barrel because ESM re-exports are
  * eager: importing `loadConfig` from the barrel would instantiate both composition roots,
- * putting the session adapter on the commit surface's load path where it is never used. A
+ * putting the session adapter on the change-set surface's load path where it is never used. A
  * workspace missing only that dist would then kill `pdks covenant check` before its
  * fail-closed handler could record a row. Both composition roots import this module directly
  * for the same reason.

package/dist/pre-state-reader.d.ts

@@ -13,7 +13,7 @@
  */
 export declare function sessionPreStateReader(location: string): string | null | undefined;
 /**
- * The commit surface's reader: it observes a staged diff, whose payloads already carry the
+ * The change-set surface's reader: it observes a staged diff, whose payloads already carry the
  * pre their own observation saw, and it registers no shell axis — so no derivation ever asks
  * for a pre-state here. Should one arrive, the working tree is not what this surface judges,
  * and answering from it would compare the diff against the wrong baseline; `undefined` says

package/dist/pre-state-reader.js

@@ -21,7 +21,7 @@ export function sessionPreStateReader(location) {
     }
 }
 /**
- * The commit surface's reader: it observes a staged diff, whose payloads already carry the
+ * The change-set surface's reader: it observes a staged diff, whose payloads already carry the
  * pre their own observation saw, and it registers no shell axis — so no derivation ever asks
  * for a pre-state here. Should one arrive, the working tree is not what this surface judges,
  * and answering from it would compare the diff against the wrong baseline; `undefined` says

package/dist/scaffold-project.d.ts

@@ -3,8 +3,8 @@
  *
  * The half of an installation every distribution path shares: the data config the judges
  * read, and the telemetry ignore line. What differs between paths is REGISTRATION — how the
- * agent is told to spawn a judge at all — and that lives one layer up (`initClaudeCode` for
- * the `init` path). The split is what lets a second path reuse this function unchanged
+ * agent is told to spawn a judge at all — and that lives in each agent's own adapter
+ * installer. The split is what lets a second path reuse this function unchanged
  * instead of scaffolding a config a second time, so nothing that registers anything belongs
  * here.
  *

package/dist/scaffold-project.js

@@ -3,8 +3,8 @@
  *
  * The half of an installation every distribution path shares: the data config the judges
  * read, and the telemetry ignore line. What differs between paths is REGISTRATION — how the
- * agent is told to spawn a judge at all — and that lives one layer up (`initClaudeCode` for
- * the `init` path). The split is what lets a second path reuse this function unchanged
+ * agent is told to spawn a judge at all — and that lives in each agent's own adapter
+ * installer. The split is what lets a second path reuse this function unchanged
  * instead of scaffolding a config a second time, so nothing that registers anything belongs
  * here.
  *
@@ -32,7 +32,7 @@ const GITIGNORE_ENTRY = `# Polydeukes telemetry — local observation data, neve
  * {@link schemaDirective} prepends the `yaml-language-server` line when the schema is where
  * that line would name it.
  */
-const GENERATED_CONFIG = `# Polydeukes protection policy — generated by \`pdks init claude-code\`.
+const GENERATED_CONFIG = `# Polydeukes protection policy — generated by \`pdks init\`.
 #
 # This file is data, never code. The judges read it, every verdict traces back to an entry
 # below, and editing it is how you change what is judged.
@@ -79,6 +79,12 @@ witness:
 # The disciplines you judge by, and the three rungs one climbs — shown as three entries so
 # each rung is a line you can copy. Uncomment to start; ids must stay distinct.
 #
+# Three lists, chosen by what a declaration reads. \`disciplines:\` is judged on both
+# surfaces (the changed file's own pre/post and file sources). \`sessionDisciplines:\` is
+# judged only where a live call is observed before it runs (command line, transcript,
+# actor). \`changeSetDisciplines:\` is judged only over a finished change set
+# (\`--diff\`). The loader refuses an entry written in a list its channels do not fit.
+#
 # disciplines:
 #   # A draft: prose only, no predicate. Registered and read, never judged.
 #   - id: 'no-todo-in-shipped-code-draft'

package/dist/schema/polydeukes.schema.json

@@ -33,6 +33,18 @@
       "uniqueItems": true,
       "items": { "$ref": "#/$defs/discipline" }
     },
+    "sessionDisciplines": {
+      "description": "Disciplines only the session surface observes — every entry whose declaration binds a transcript, channel, command, or actor evidence channel. Fully identical entries are copy-paste duplicates (by-id uniqueness and the placement rule are enforced by the runtime validator).",
+      "type": "array",
+      "uniqueItems": true,
+      "items": { "$ref": "#/$defs/discipline" }
+    },
+    "changeSetDisciplines": {
+      "description": "Disciplines only the change-set surface observes — every entry whose declaration binds the changes source. Fully identical entries are copy-paste duplicates (by-id uniqueness and the placement rule are enforced by the runtime validator).",
+      "type": "array",
+      "uniqueItems": true,
+      "items": { "$ref": "#/$defs/discipline" }
+    },
     "witness": { "$ref": "#/$defs/witness" }
   },
   "$defs": {

package/dist/worktree-reader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The change-set surface's supply body for named file sources — one repo-relative path read from
+ * the working tree.
+ */
+import type { SourceReader } from '@polydeukes/core';
+/** {@link worktreeReader} input — the repository the paths are relative to. */
+export type WorktreeReaderSpec = {
+    repoRoot: string;
+};
+/**
+ * A reader over the working tree under `repoRoot`, with the same absence table the session
+ * surface's disk reader pins in its own package.
+ *
+ * Symlinks are followed: on disk the observable fact IS the target's text, and the session
+ * surface reads the same way. A path the tree holds but cannot give as judgeable text —
+ * a directory, or bytes carrying a NUL — answers `undefined`, which the declaration's
+ * `supply` policy disposes of.
+ */
+export declare function worktreeReader(spec: WorktreeReaderSpec): SourceReader;

package/dist/worktree-reader.js

@@ -0,0 +1,30 @@
+/**
+ * The change-set surface's supply body for named file sources — one repo-relative path read from
+ * the working tree.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * A reader over the working tree under `repoRoot`, with the same absence table the session
+ * surface's disk reader pins in its own package.
+ *
+ * Symlinks are followed: on disk the observable fact IS the target's text, and the session
+ * surface reads the same way. A path the tree holds but cannot give as judgeable text —
+ * a directory, or bytes carrying a NUL — answers `undefined`, which the declaration's
+ * `supply` policy disposes of.
+ */
+export function worktreeReader(spec) {
+    return (path) => {
+        let bytes;
+        try {
+            bytes = readFileSync(join(spec.repoRoot, path));
+        }
+        catch (error) {
+            const { code } = error;
+            if (code === 'ENOENT' || code === 'EISDIR' || code === 'ENOTDIR')
+                return undefined;
+            throw error;
+        }
+        return bytes.includes(0) ? undefined : bytes.toString('utf-8');
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydeukes",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "A development discipline framework for building alongside an AI coding partner — deterministic covenants, a verifiable work ledger, local memory, and adversarial verification. Alpha.",
   "keywords": [
     "harness",
@@ -28,18 +28,7 @@
     "pdks": "./dist/bin.js",
     "polydeukes": "./dist/bin.js"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./claude-code": {
-      "types": "./dist/claude-code.d.ts",
-      "import": "./dist/claude-code.js"
-    },
     "./schema.json": "./dist/schema/polydeukes.schema.json"
   },
   "files": [
@@ -54,15 +43,12 @@
   },
   "dependencies": {
     "yaml": "2.9.0",
-    "@polydeukes/adapter-git": "^0.6.0",
-    "@polydeukes/covenant": "^0.6.0",
-    "@polydeukes/core": "^0.6.0",
-    "@polydeukes/adapter-claude-code": "^0.6.0"
+    "@polydeukes/core": "^0.7.1"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
     "typescript": "7.0.2",
-    "vitest": "^4.1.0"
+    "vitest": "^5.0.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && node scripts/copy-docs.mjs && node scripts/copy-schema.mjs",