@deepwatch/dsh-wiki 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 oxbshw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# @deepwatch/dsh-wiki
+
+Deterministic workspace wiki projections over the memory ledger
+
+Part of **DeepWatch** — the agent workspace built on the official
+[DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)
+and powered by [Watch Skill](https://github.com/oxbshw/watch-skill) for perception, evidence, memory and
+independent verification.
+
+> **Host plugin — runs beside the agent in the DSH process.**
+> Composed by the bundle.
+
+## Exports
+
+- `@deepwatch/dsh-wiki`
+
+## Install
+
+> **Not on npm yet.** Nothing exists under the `@deepwatch` scope. This
+> package is published for the first time by the `deepwatch-v0.1.0`
+> release; until then the command below resolves nothing, and
+> [the workspace README](https://github.com/oxbshw/watch-skill/tree/main/workspace#readme) has the path
+> that works from a checkout.
+
+```sh
+npm install @deepwatch/dsh-wiki
+```
+
+Rarely on its own. [`@deepwatch/dsh-bundle`](https://github.com/oxbshw/watch-skill/tree/main/workspace/packages/watch/bundle#readme)
+composes this package with the rest of DeepWatch and is what a profile
+normally depends on; installing this one directly is for embedding a
+single piece in a composition you control.
+
+## Requirements
+
+- Node `^22.19.0 || >=24.0.0`
+
+`@deepwatch/dsh-memory` mounted, since the ledger is what it projects.
+
+## Stability
+
+`0.1.0` — a stable release.
+
+Stable means tested, documented and supported — not 1.0. This is a
+pre-1.0 line, and semantic versioning gives `0.x` no compatibility
+guarantee across minor versions: **a `0.MINOR` bump may change or remove
+surface, and a patch will not.** Depend on it with a tilde range
+(`~0.1.0`) if you want that difference enforced by your lockfile
+rather than by a changelog. The usual major-version promise starts at 1.0.
+
+## Side effects
+
+Importing a module from this package evaluates no side effects, so a
+bundler may drop what a build does not use. Mounting it in a host is a
+separate matter: what it then reads or writes is governed by the
+workspace boundary and the host's permissions, not by this flag.
+
+## Where this fits
+
+Deterministic projections over the memory ledger: the same ledger produces the same pages, so a wiki page is a view and never a second copy of the truth.
+
+The twenty packages and how they compose:
+[the package map](https://github.com/oxbshw/watch-skill/blob/main/workspace/docs/packages.md).
+Running DeepWatch, and the gates a change has to pass:
+[the workspace README](https://github.com/oxbshw/watch-skill/tree/main/workspace#readme).
+
+## Attribution
+
+Built on DeepSeek Harness · Powered by Watch Skill
+
+DeepWatch and Watch Skill are independent projects and are not affiliated
+with or endorsed by DeepSeek. MIT licensed; third-party notices are in
+[THIRD_PARTY_NOTICES.md](https://github.com/oxbshw/watch-skill/blob/main/workspace/THIRD_PARTY_NOTICES.md).

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Deterministic workspace wiki projections.
+ *
+ * @module @deepwatch/dsh-wiki
+ */
+export * from './projection.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,7 @@
+/**
+ * Deterministic workspace wiki projections.
+ *
+ * @module @deepwatch/dsh-wiki
+ */
+export * from './projection.js';
+//# sourceMappingURL=index.js.map

package/lib/projection.d.ts

@@ -0,0 +1,167 @@
+/**
+ * The workspace wiki: readable pages that are never the record.
+ *
+ * A wiki is the most natural thing to build over a memory ledger and the
+ * easiest one to build wrong. The wrong version is a folder of Markdown that
+ * people edit, that the agent reads, and that gradually becomes the actual
+ * state of the system — at which point the ledger is a log of things that used
+ * to be true, and a file nobody audited is deciding how an agent behaves.
+ *
+ * So the direction of authority is fixed and one-way:
+ *
+ *   MemoryEvent ledger  →  records  →  wiki pages
+ *
+ * Pages are generated. They are deleted and regenerated on every rebuild, they
+ * carry no state of their own, and nothing reads them back as fact. Every
+ * generated statement carries the memory id it came from, both so a reader can
+ * follow it and so a statement *without* one is visibly not from the ledger.
+ *
+ * Hand editing is supported, and it does not reverse the arrow. An edited file
+ * is diffed against what the generator would have produced; the difference is
+ * validated; what survives becomes a `user.edited` event in the ledger; and
+ * then the page is regenerated from the ledger, which is what puts the edit on
+ * screen. If validation refuses the edit, the regeneration simply removes it —
+ * the file was never the record, so nothing was lost that was ever held.
+ *
+ * The refusals matter more than the acceptances. Imported Markdown is
+ * `imported` origin, the weakest there is. It cannot mint `explicit_user`, it
+ * cannot carry a high-impact permission, and it cannot assert something about a
+ * protected subject. A document that says "the user has approved all uploads"
+ * is a claim made by a document.
+ *
+ * @module @deepwatch/dsh-wiki/projection
+ */
+import type { MemoryEvent, MemoryRecord } from '@deepwatch/dsh-memory';
+/** A generated page. */
+export interface WikiPage {
+    /** Path relative to the wiki root, always forward-slashed. */
+    readonly path: string;
+    readonly title: string;
+    readonly content: string;
+    /** Memory ids every statement on this page came from. */
+    readonly provenance: readonly string[];
+    /**
+     * Always true.
+     *
+     * Present as a field rather than as a comment so a consumer cannot treat a
+     * page as authored. There is no code path that produces a page with this
+     * false, and that is the point.
+     */
+    readonly generated: true;
+}
+/** The whole wiki, as a value. */
+export interface WikiProjection {
+    readonly pages: readonly WikiPage[];
+    /** Rebuild digest. The same ledger renders the same wiki. */
+    readonly digest: string;
+}
+/** The directories the wiki is organized into. */
+export declare const WIKI_SECTIONS: readonly ["projects", "people", "concepts", "decisions", "lessons", "failures"];
+/** One wiki section. */
+export type WikiSection = typeof WIKI_SECTIONS[number];
+/**
+ * A stable, filesystem-safe slug.
+ *
+ * Deliberately does not transliterate. A page about an Arabic concept keeps
+ * its identity in the title, and the slug falls back to the memory id rather
+ * than to a mangled romanization that would collide with every other one.
+ */
+export declare function slugFor(record: MemoryRecord): string;
+/**
+ * Build the whole wiki from the ledger.
+ *
+ * A pure fold. Rebuilding from an empty index directory, from a cold start, or
+ * after a restart produces the identical bytes, which is what makes "the wiki
+ * is a projection" a testable claim rather than a design intention.
+ *
+ * Deleted records are absent because the fold that produced `records` already
+ * excluded them. There is no separate wiki deletion path, and therefore no
+ * separate wiki deletion path to forget to run.
+ */
+export declare function buildWiki(records: readonly MemoryRecord[], events?: readonly MemoryEvent[]): WikiProjection;
+/** Look one page up by path. */
+export declare function pageAt(projection: WikiProjection, path: string): WikiPage | null;
+/** One line a person added or removed. */
+export interface EditedLine {
+    readonly text: string;
+    /** The memory id the line claimed, when it carried a marker. */
+    readonly memoryId: string | null;
+}
+/** What a hand edit proposes. */
+export interface EditProposal {
+    readonly path: string;
+    readonly added: readonly EditedLine[];
+    readonly removed: readonly EditedLine[];
+}
+/**
+ * Diff a hand-edited page against what the generator produced.
+ *
+ * Line-level and deliberately crude. A structural Markdown diff would be more
+ * precise and would also be a place for a clever edit to hide; comparing the
+ * statement lines catches everything that could carry a claim.
+ */
+export declare function diffUserEdit(generated: WikiPage, edited: string): EditProposal;
+/** Why one edited line was refused. */
+export interface EditRefusal {
+    readonly line: string;
+    readonly reason: string;
+    readonly fix: string;
+}
+/** What survived validation, and what did not. */
+export interface ValidatedEdit {
+    readonly path: string;
+    /** Lines that may become `user.edited` events. */
+    readonly accepted: readonly EditedLine[];
+    readonly refused: readonly EditRefusal[];
+    /** Memory ids the edit asks to remove. */
+    readonly removals: readonly string[];
+}
+/**
+ * Validate a hand edit.
+ *
+ * Four refusals, each closing a way a file could write itself into authority:
+ *
+ * - **A forged marker.** A line carrying `mem:` for an id the page does not
+ *   own is trying to attribute a new claim to an existing record.
+ * - **High impact.** A permission, a standing grant, a weakened safeguard.
+ *   Imported text is the weakest origin there is; it does not get to authorize
+ *   anything, at any confidence.
+ * - **A protected subject.** Health, beliefs, and the rest are things a person
+ *   states about themselves. A file stating them is a file making a claim.
+ * - **An empty claim.** A marker with no statement is a way to create a record
+ *   with no content and then fill it later.
+ *
+ * Everything accepted becomes `imported` origin and `proposed` status. Nothing
+ * a file says can make it `explicit_user`, because that origin means a person
+ * did something, and reading a file is not a person doing something.
+ */
+export declare function validateUserEdit(proposal: EditProposal, generated: WikiPage): ValidatedEdit;
+/** A candidate the ledger may admit, produced from an accepted edit line. */
+export interface ImportedCandidate {
+    readonly kind: MemoryRecord['kind'];
+    readonly content: string;
+    readonly origin: 'imported';
+    readonly subjectScope: MemoryRecord['subjectScope'];
+    readonly scopeId: string;
+    readonly confidence: number;
+    readonly sourceRefs: readonly string[];
+}
+/**
+ * Turn accepted edit lines into ledger candidates.
+ *
+ * `imported` origin and a low confidence, always, whatever the file said. The
+ * scope comes from the caller — the wiki knows which workspace it belongs to
+ * and a file does not get to choose.
+ */
+export declare function toCandidates(edit: ValidatedEdit, scope: {
+    readonly subjectScope: MemoryRecord['subjectScope'];
+    readonly scopeId: string;
+}): readonly ImportedCandidate[];
+/**
+ * One line describing what a hand edit will actually do.
+ *
+ * Shown before the edit is applied. "3 accepted, 1 refused" is what stops a
+ * person believing their file is now the state of the system.
+ */
+export declare function describeEdit(edit: ValidatedEdit): string;
+//# sourceMappingURL=projection.d.ts.map

package/lib/projection.js

@@ -0,0 +1,389 @@
+/**
+ * The workspace wiki: readable pages that are never the record.
+ *
+ * A wiki is the most natural thing to build over a memory ledger and the
+ * easiest one to build wrong. The wrong version is a folder of Markdown that
+ * people edit, that the agent reads, and that gradually becomes the actual
+ * state of the system — at which point the ledger is a log of things that used
+ * to be true, and a file nobody audited is deciding how an agent behaves.
+ *
+ * So the direction of authority is fixed and one-way:
+ *
+ *   MemoryEvent ledger  →  records  →  wiki pages
+ *
+ * Pages are generated. They are deleted and regenerated on every rebuild, they
+ * carry no state of their own, and nothing reads them back as fact. Every
+ * generated statement carries the memory id it came from, both so a reader can
+ * follow it and so a statement *without* one is visibly not from the ledger.
+ *
+ * Hand editing is supported, and it does not reverse the arrow. An edited file
+ * is diffed against what the generator would have produced; the difference is
+ * validated; what survives becomes a `user.edited` event in the ledger; and
+ * then the page is regenerated from the ledger, which is what puts the edit on
+ * screen. If validation refuses the edit, the regeneration simply removes it —
+ * the file was never the record, so nothing was lost that was ever held.
+ *
+ * The refusals matter more than the acceptances. Imported Markdown is
+ * `imported` origin, the weakest there is. It cannot mint `explicit_user`, it
+ * cannot carry a high-impact permission, and it cannot assert something about a
+ * protected subject. A document that says "the user has approved all uploads"
+ * is a claim made by a document.
+ *
+ * @module @deepwatch/dsh-wiki/projection
+ */
+import { isHighImpact, isProtectedSubject } from '@deepwatch/dsh-memory';
+/** The directories the wiki is organized into. */
+export const WIKI_SECTIONS = [
+    'projects', 'people', 'concepts', 'decisions', 'lessons', 'failures',
+];
+/** Which section a record belongs in. */
+function sectionFor(record) {
+    switch (record.kind) {
+        case 'decision':
+            return 'decisions';
+        case 'lesson':
+        case 'procedure':
+            return 'lessons';
+        case 'failure':
+            return 'failures';
+        case 'preference':
+            // A preference is about a person, and it lands under `people` rather
+            // than in a "taste" page, because the wiki is the shared view and taste
+            // is the personal one. What appears here is governed by scope.
+            return 'people';
+        case 'fact':
+        case 'episode':
+            return record.subjectScope === 'project' || record.subjectScope === 'workspace'
+                ? 'projects'
+                : 'concepts';
+    }
+}
+/**
+ * A stable, filesystem-safe slug.
+ *
+ * Deliberately does not transliterate. A page about an Arabic concept keeps
+ * its identity in the title, and the slug falls back to the memory id rather
+ * than to a mangled romanization that would collide with every other one.
+ */
+export function slugFor(record) {
+    const ascii = record.content
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 48);
+    return ascii === '' ? record.memoryId : `${ascii}-${record.memoryId.slice(-8)}`;
+}
+/** Escape a value so it cannot break out of a Markdown table cell. */
+function cell(text) {
+    return text.replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
+}
+/**
+ * One generated statement line, with its provenance.
+ *
+ * The marker is an HTML comment so it survives a Markdown renderer without
+ * being displayed, and so the diff can find it exactly. A statement that has
+ * lost its marker is not a statement the ledger made.
+ */
+function statement(record) {
+    return `- ${cell(record.content)} <!-- mem:${record.memoryId} -->`;
+}
+/** The provenance footer every page carries. */
+function provenanceBlock(records) {
+    if (records.length === 0)
+        return [];
+    const lines = [
+        '',
+        '## Provenance',
+        '',
+        'Generated from the memory ledger. This page is not evidence.',
+        '',
+        '| memory | kind | origin | confidence | last confirmed |',
+        '|---|---|---|---:|---|',
+    ];
+    for (const record of records) {
+        lines.push(`| \`${record.memoryId}\` | ${record.kind} | ${record.origin} `
+            + `| ${record.confidence.toFixed(2)} | ${record.lastConfirmedAt ?? 'never'} |`);
+    }
+    return lines;
+}
+/** Sort records into a stable order, so a rebuild is byte-identical. */
+function ordered(records) {
+    return [...records].sort((left, right) => left.memoryId.localeCompare(right.memoryId));
+}
+/** Render one page for one record. */
+function pageFor(record) {
+    const section = sectionFor(record);
+    const title = record.content.split(/\r?\n/)[0]?.slice(0, 80) ?? record.memoryId;
+    const lines = [
+        `# ${cell(title)}`,
+        '',
+        statement(record),
+        '',
+        `Status: ${record.status}. Scope: ${record.subjectScope}`
+            + `${record.scopeId === '' ? '' : `:${record.scopeId}`}.`,
+        ...record.evidenceRefs.length === 0
+            ? []
+            : ['', 'Evidence:', ...record.evidenceRefs.map(ref => `- \`${ref}\``)],
+        ...provenanceBlock([record]),
+        '',
+    ];
+    return {
+        path: `${section}/${slugFor(record)}.md`,
+        title,
+        content: lines.join('\n'),
+        provenance: [record.memoryId],
+        generated: true,
+    };
+}
+/** Render the section index. */
+function sectionIndex(section, records) {
+    const lines = [
+        `# ${section}`,
+        '',
+        ...records.length === 0
+            ? ['Nothing recorded.']
+            : records.map(record => `- [${cell(record.content.slice(0, 60))}](${slugFor(record)}.md) <!-- mem:${record.memoryId} -->`),
+        '',
+    ];
+    return {
+        path: `${section}/index.md`,
+        title: section,
+        content: lines.join('\n'),
+        provenance: records.map(record => record.memoryId),
+        generated: true,
+    };
+}
+/** Render the root index. */
+function rootIndex(bySection) {
+    const lines = [
+        '# Workspace wiki',
+        '',
+        'Generated from the memory ledger. Every page here is a projection, not a',
+        'record. Editing a page proposes a change to the ledger; it does not change',
+        'anything on its own.',
+        '',
+        '| section | pages |',
+        '|---|---:|',
+        ...WIKI_SECTIONS.map(section => `| [${section}](${section}/index.md) | ${String((bySection.get(section) ?? []).length)} |`),
+        '',
+    ];
+    return {
+        path: 'index.md',
+        title: 'Workspace wiki',
+        content: lines.join('\n'),
+        provenance: [],
+        generated: true,
+    };
+}
+/**
+ * Render the event log.
+ *
+ * Ids, kinds, actors and timestamps. Never content — a log that reproduced
+ * what was forgotten, in the entry recording that it was forgotten, would not
+ * be a deletion.
+ */
+function logPage(events) {
+    const lines = [
+        '# Log',
+        '',
+        'Every change to the ledger, in order. Content is deliberately absent.',
+        '',
+        ...events.map(event => `- \`${event.at}\` **${event.kind}** by ${event.actor} — \`${event.memoryId}\``),
+        '',
+    ];
+    return {
+        path: 'log.md',
+        title: 'Log',
+        content: lines.join('\n'),
+        provenance: [],
+        generated: true,
+    };
+}
+/** FNV-1a over the rendered wiki, so a rebuild is checkable. */
+function digestOf(pages) {
+    let hash = 0x811c9dc5;
+    const feed = (text) => {
+        for (let index = 0; index < text.length; index += 1) {
+            hash ^= text.charCodeAt(index);
+            hash = Math.imul(hash, 0x01000193) >>> 0;
+        }
+    };
+    for (const page of pages)
+        feed(`|${page.path}|${page.content}`);
+    return hash.toString(16).padStart(8, '0');
+}
+/**
+ * Build the whole wiki from the ledger.
+ *
+ * A pure fold. Rebuilding from an empty index directory, from a cold start, or
+ * after a restart produces the identical bytes, which is what makes "the wiki
+ * is a projection" a testable claim rather than a design intention.
+ *
+ * Deleted records are absent because the fold that produced `records` already
+ * excluded them. There is no separate wiki deletion path, and therefore no
+ * separate wiki deletion path to forget to run.
+ */
+export function buildWiki(records, events = []) {
+    const bySection = new Map();
+    for (const section of WIKI_SECTIONS)
+        bySection.set(section, []);
+    for (const record of ordered(records)) {
+        // Forgotten records never reach here — the ledger's fold drops them — but
+        // a superseded one is real history and belongs on its page, marked.
+        bySection.get(sectionFor(record))?.push(record);
+    }
+    const pages = [rootIndex(bySection)];
+    for (const section of WIKI_SECTIONS) {
+        const inSection = bySection.get(section) ?? [];
+        pages.push(sectionIndex(section, inSection));
+        for (const record of inSection)
+            pages.push(pageFor(record));
+    }
+    pages.push(logPage(events));
+    const sorted = [...pages].sort((left, right) => left.path.localeCompare(right.path));
+    return { pages: sorted, digest: digestOf(sorted) };
+}
+/** Look one page up by path. */
+export function pageAt(projection, path) {
+    return projection.pages.find(page => page.path === path) ?? null;
+}
+/** Read a provenance marker off a line. */
+function markerOf(line) {
+    return /<!--\s*mem:([A-Za-z0-9_-]+)\s*-->/.exec(line)?.[1] ?? null;
+}
+/** Statement lines only — headings, tables and blank lines are chrome. */
+function statementLines(content) {
+    return content.split(/\r?\n/).filter(line => line.trimStart().startsWith('- '));
+}
+/**
+ * Diff a hand-edited page against what the generator produced.
+ *
+ * Line-level and deliberately crude. A structural Markdown diff would be more
+ * precise and would also be a place for a clever edit to hide; comparing the
+ * statement lines catches everything that could carry a claim.
+ */
+export function diffUserEdit(generated, edited) {
+    const before = new Set(statementLines(generated.content));
+    const after = new Set(statementLines(edited));
+    const added = [...after].filter(line => !before.has(line))
+        .map(line => ({ text: line, memoryId: markerOf(line) }));
+    const removed = [...before].filter(line => !after.has(line))
+        .map(line => ({ text: line, memoryId: markerOf(line) }));
+    return { path: generated.path, added, removed };
+}
+/** Strip the provenance marker to get the claim itself. */
+function claimOf(line) {
+    return line.replace(/<!--[\s\S]*?-->/g, '').replace(/^\s*-\s*/, '').trim();
+}
+/**
+ * Validate a hand edit.
+ *
+ * Four refusals, each closing a way a file could write itself into authority:
+ *
+ * - **A forged marker.** A line carrying `mem:` for an id the page does not
+ *   own is trying to attribute a new claim to an existing record.
+ * - **High impact.** A permission, a standing grant, a weakened safeguard.
+ *   Imported text is the weakest origin there is; it does not get to authorize
+ *   anything, at any confidence.
+ * - **A protected subject.** Health, beliefs, and the rest are things a person
+ *   states about themselves. A file stating them is a file making a claim.
+ * - **An empty claim.** A marker with no statement is a way to create a record
+ *   with no content and then fill it later.
+ *
+ * Everything accepted becomes `imported` origin and `proposed` status. Nothing
+ * a file says can make it `explicit_user`, because that origin means a person
+ * did something, and reading a file is not a person doing something.
+ */
+export function validateUserEdit(proposal, generated) {
+    const owned = new Set(generated.provenance);
+    const accepted = [];
+    const refused = [];
+    for (const line of proposal.added) {
+        const claim = claimOf(line.text);
+        if (line.memoryId !== null && !owned.has(line.memoryId)) {
+            refused.push({
+                line: line.text,
+                reason: `The line claims memory ${line.memoryId}, which this page does not own.`,
+                fix: 'Remove the provenance comment. A new statement is a new memory.',
+            });
+            continue;
+        }
+        if (claim === '') {
+            refused.push({
+                line: line.text,
+                reason: 'The line carries a provenance marker but states nothing.',
+                fix: 'Write the statement, or delete the line.',
+            });
+            continue;
+        }
+        if (isHighImpact(claim)) {
+            refused.push({
+                line: line.text,
+                reason: 'Imported text cannot grant a permission or weaken a safeguard.',
+                fix: 'If this is intended, state it yourself in the conversation.',
+            });
+            continue;
+        }
+        if (isProtectedSubject(claim)) {
+            refused.push({
+                line: line.text,
+                reason: 'Imported text cannot assert something about a protected subject.',
+                fix: 'If this is about you, state it yourself in the conversation.',
+            });
+            continue;
+        }
+        accepted.push({ text: claim, memoryId: line.memoryId });
+    }
+    return {
+        path: proposal.path,
+        accepted,
+        refused,
+        removals: proposal.removed
+            .map(line => line.memoryId)
+            .filter((id) => id !== null),
+    };
+}
+/**
+ * Turn accepted edit lines into ledger candidates.
+ *
+ * `imported` origin and a low confidence, always, whatever the file said. The
+ * scope comes from the caller — the wiki knows which workspace it belongs to
+ * and a file does not get to choose.
+ */
+export function toCandidates(edit, scope) {
+    const kind = edit.path.startsWith('decisions/')
+        ? 'decision'
+        : edit.path.startsWith('lessons/')
+            ? 'lesson'
+            : edit.path.startsWith('failures/')
+                ? 'failure'
+                : 'fact';
+    return edit.accepted.map(line => ({
+        kind,
+        content: line.text,
+        origin: 'imported',
+        subjectScope: scope.subjectScope,
+        scopeId: scope.scopeId,
+        // Not a number the file chose. An imported claim starts weak and earns its
+        // way up by a person confirming it.
+        confidence: 0.3,
+        sourceRefs: [`wiki:${edit.path}`],
+    }));
+}
+/**
+ * One line describing what a hand edit will actually do.
+ *
+ * Shown before the edit is applied. "3 accepted, 1 refused" is what stops a
+ * person believing their file is now the state of the system.
+ */
+export function describeEdit(edit) {
+    const parts = [
+        `${String(edit.accepted.length)} statement(s) proposed`,
+        `${String(edit.removals.length)} removal(s)`,
+    ];
+    if (edit.refused.length > 0)
+        parts.push(`${String(edit.refused.length)} refused`);
+    parts.push('the page will be regenerated from the ledger');
+    return parts.join(' · ');
+}
+//# sourceMappingURL=projection.js.map

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@deepwatch/dsh-wiki",
+  "version": "0.1.0",
+  "description": "Deterministic workspace wiki projections over the memory ledger",
+  "type": "module",
+  "license": "MIT",
+  "author": "Sayed Allam",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oxbshw/watch-skill.git",
+    "directory": "workspace/packages/watch/wiki"
+  },
+  "homepage": "https://github.com/oxbshw/watch-skill/tree/main/workspace#readme",
+  "bugs": {
+    "url": "https://github.com/oxbshw/watch-skill/issues"
+  },
+  "keywords": [
+    "deepwatch",
+    "deepseek-harness",
+    "watch-skill",
+    "wiki",
+    "documentation"
+  ],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@deepwatch/dsh-memory": "^0.1.0"
+  }
+}