@dsh-cc/memory 0.5.0

package/lib/team.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Team memory: an opt-in shared per-project memory directory layered on the
+ * private memdir. Provides the team path resolution, the dual-directory
+ * (private + team) merged prompt, and a seam-native read/write path validation
+ * chain so a relative key cannot escape the team directory.
+ *
+ * Security model (three hard prerequisites, all enforced before any read or
+ * write):
+ * 1. **Key sanitization** — a pure string pass (`sanitizePathKey`) run before
+ *    any filesystem operation rejects null bytes, URL-encoded traversal, NFKC
+ *    normalization differences, backslashes, and absolute keys.
+ * 2. **Seam-native validation chain** — for the sanitized key: `fs.lstat`
+ *    rejects a final-segment symlink, then `fs.resolve` + `fs.contains`
+ *    enforce prefix containment against the resolved team root.
+ * 3. **Containment on every access** — reads and writes go through the chain,
+ *    so a symlinked intermediate component that points outside is caught by
+ *    the resolve + contains step.
+ *
+ * Residual gap (documented): this closes per-access traversal, but a
+ * mutate-between-check TOCTOU window on *intermediate* components is not fully
+ * closed — only the final segment is lstat-checked, and the resolve/contains
+ * check and the read are not atomic. Do not enable `teamEnabled` in multi-tenant
+ * or untrusted-writer deployments.
+ * @module @dsh-cc/memory/team
+ */
+import type { FileSystem, FsTarget } from '@deepseek-ai/dsh-fs';
+/** Error thrown when a team-memory key/path fails security validation. */
+export declare class TeamMemoryError extends Error {
+    constructor(message: string);
+}
+/** Default subdirectory of the memory home holding team memory. */
+export declare const TEAM_MEMORY_DIR = "team";
+/**
+ * The team memory entrypoint filename, matching the private entrypoint.
+ * Each directory (private and team) keeps its own MEMORY.md index.
+ */
+export declare const TEAM_ENTRYPOINT_NAME = "MEMORY.md";
+/**
+ * Sanitize a relative path key by rejecting dangerous patterns, mirroring the
+ * Claude Code `sanitizePathKey` semantics. Pure string — run this before any
+ * filesystem operation. Returns the sanitized key unchanged or throws
+ * {@link TeamMemoryError}. Rejects:
+ * - null bytes (can truncate paths in C-based syscalls)
+ * - URL-encoded traversal (`%2e%2e%2f` → `../`)
+ * - NFKC normalization that collapses to `..` / separators (fullwidth `．．／`)
+ * - backslashes (Windows separator used as a traversal vector)
+ * - absolute paths
+ * @param key - the relative path key under the team directory.
+ * @returns the sanitized key (unchanged).
+ */
+export declare function sanitizePathKey(key: string): string;
+/**
+ * Resolve the team memory directory for one workspace. Team memory is shared
+ * by all users of THE PROJECT, so it lives inside the workspace's private
+ * memory directory: `<workspaceDir>/team`. (Before per-workspace isolation it
+ * sat at the global `<memoryHome>/team`; that directory is now inert.)
+ * @param workspaceDir - the workspace's private memory directory.
+ * @returns the team directory path (`<workspaceDir>/team`).
+ */
+export declare function resolveTeamMemoryRoot(workspaceDir: string): string;
+/**
+ * The seam-native team path validation chain. For a relative key under a team
+ * directory, enforce, in order:
+ * 1. `sanitizePathKey` — pure-string rejection (no fs access).
+ * 2. `fs.lstat` — reject a final-segment symlink before following it.
+ * 3. `fs.resolve` of both the team root and the candidate, then `fs.contains`
+ *    — reject when the resolved candidate escapes the resolved team root.
+ *
+ * Throws {@link TeamMemoryError} when any step fails. A missing file is not an
+ * error here: the resolve+contains step still spans the nearest existing
+ * ancestor (realpath), so a missing child under an escaping symlinked ancestor
+ * is still caught.
+ * @param fs - the contiguous filesystem seam.
+ * @param teamDir - the resolved team directory path.
+ * @param relativeKey - the sanitizable relative key to validate.
+ * @returns the resolved, contained {@link FsTarget} for the candidate.
+ */
+export declare function validateTeamMemKey(fs: FileSystem, teamDir: string, relativeKey: string): Promise<FsTarget>;
+/**
+ * Validate and read a team memory file body, or `undefined` when the file is
+ * absent. The read only proceeds when {@link validateTeamMemKey} passes, so a
+ * traversal or symlink-escape key never reaches the read.
+ * @param fs - the contiguous filesystem seam.
+ * @param teamDir - the resolved team directory path.
+ * @param relativeKey - the sanitizable relative key to read.
+ * @param signal - optional cancellation.
+ * @returns the file body, or `undefined` if absent.
+ */
+export declare function readTeamMemFile(fs: FileSystem, teamDir: string, relativeKey: string, signal?: AbortSignal): Promise<string | undefined>;
+//# sourceMappingURL=team.d.ts.map

package/lib/team.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team.d.ts","sourceRoot":"","sources":["../src/team.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAE/D,0EAA0E;AAC1E,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAI5B;AAED,mEAAmE;AACnE,eAAO,MAAM,eAAe,SAAS,CAAA;AAErC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,cAAc,CAAA;AAE/C;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA0CnD;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,QAAQ,CAAC,CAiBnB;AAED;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAQ7B"}

package/lib/team.js

@@ -0,0 +1,167 @@
+/**
+ * Team memory: an opt-in shared per-project memory directory layered on the
+ * private memdir. Provides the team path resolution, the dual-directory
+ * (private + team) merged prompt, and a seam-native read/write path validation
+ * chain so a relative key cannot escape the team directory.
+ *
+ * Security model (three hard prerequisites, all enforced before any read or
+ * write):
+ * 1. **Key sanitization** — a pure string pass (`sanitizePathKey`) run before
+ *    any filesystem operation rejects null bytes, URL-encoded traversal, NFKC
+ *    normalization differences, backslashes, and absolute keys.
+ * 2. **Seam-native validation chain** — for the sanitized key: `fs.lstat`
+ *    rejects a final-segment symlink, then `fs.resolve` + `fs.contains`
+ *    enforce prefix containment against the resolved team root.
+ * 3. **Containment on every access** — reads and writes go through the chain,
+ *    so a symlinked intermediate component that points outside is caught by
+ *    the resolve + contains step.
+ *
+ * Residual gap (documented): this closes per-access traversal, but a
+ * mutate-between-check TOCTOU window on *intermediate* components is not fully
+ * closed — only the final segment is lstat-checked, and the resolve/contains
+ * check and the read are not atomic. Do not enable `teamEnabled` in multi-tenant
+ * or untrusted-writer deployments.
+ * @module @dsh-cc/memory/team
+ */
+import { join } from 'node:path';
+/** Error thrown when a team-memory key/path fails security validation. */
+export class TeamMemoryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TeamMemoryError';
+    }
+}
+/** Default subdirectory of the memory home holding team memory. */
+export const TEAM_MEMORY_DIR = 'team';
+/**
+ * The team memory entrypoint filename, matching the private entrypoint.
+ * Each directory (private and team) keeps its own MEMORY.md index.
+ */
+export const TEAM_ENTRYPOINT_NAME = 'MEMORY.md';
+/**
+ * Sanitize a relative path key by rejecting dangerous patterns, mirroring the
+ * Claude Code `sanitizePathKey` semantics. Pure string — run this before any
+ * filesystem operation. Returns the sanitized key unchanged or throws
+ * {@link TeamMemoryError}. Rejects:
+ * - null bytes (can truncate paths in C-based syscalls)
+ * - URL-encoded traversal (`%2e%2e%2f` → `../`)
+ * - NFKC normalization that collapses to `..` / separators (fullwidth `．．／`)
+ * - backslashes (Windows separator used as a traversal vector)
+ * - absolute paths
+ * @param key - the relative path key under the team directory.
+ * @returns the sanitized key (unchanged).
+ */
+export function sanitizePathKey(key) {
+    if (key.length === 0) {
+        throw new TeamMemoryError('Empty path key');
+    }
+    // Null bytes can truncate paths in C-based syscalls.
+    if (key.includes('\0')) {
+        throw new TeamMemoryError(`Null byte in path key: "${key}"`);
+    }
+    // URL-encoded traversals (e.g. %2e%2e%2f = ../).
+    let decoded;
+    try {
+        decoded = decodeURIComponent(key);
+    }
+    catch {
+        // Malformed percent-encoding (e.g. %ZZ, lone %) — not valid URL-encoding,
+        // so no URL-encoded traversal is possible.
+        decoded = key;
+    }
+    if (decoded !== key && (decoded.includes('..') || decoded.includes('/') || decoded.includes('\\'))) {
+        throw new TeamMemoryError(`URL-encoded traversal in path key: "${key}"`);
+    }
+    // Unicode normalization attacks: fullwidth ．．／ normalize to ASCII ../ under
+    // NFKC. Reject for defense-in-depth even though a literal-fs backend treats
+    // these as bytes, not separators.
+    const normalized = key.normalize('NFKC');
+    if (normalized !== key &&
+        (normalized.includes('..') ||
+            normalized.includes('/') ||
+            normalized.includes('\\') ||
+            normalized.includes('\0'))) {
+        throw new TeamMemoryError(`Unicode-normalized traversal in path key: "${key}"`);
+    }
+    // Reject backslashes (Windows path separator used as a traversal vector).
+    if (key.includes('\\')) {
+        throw new TeamMemoryError(`Backslash in path key: "${key}"`);
+    }
+    // Reject absolute paths.
+    if (key.startsWith('/')) {
+        throw new TeamMemoryError(`Absolute path key: "${key}"`);
+    }
+    return key;
+}
+/**
+ * Resolve the team memory directory for one workspace. Team memory is shared
+ * by all users of THE PROJECT, so it lives inside the workspace's private
+ * memory directory: `<workspaceDir>/team`. (Before per-workspace isolation it
+ * sat at the global `<memoryHome>/team`; that directory is now inert.)
+ * @param workspaceDir - the workspace's private memory directory.
+ * @returns the team directory path (`<workspaceDir>/team`).
+ */
+export function resolveTeamMemoryRoot(workspaceDir) {
+    return join(workspaceDir, TEAM_MEMORY_DIR);
+}
+/**
+ * The seam-native team path validation chain. For a relative key under a team
+ * directory, enforce, in order:
+ * 1. `sanitizePathKey` — pure-string rejection (no fs access).
+ * 2. `fs.lstat` — reject a final-segment symlink before following it.
+ * 3. `fs.resolve` of both the team root and the candidate, then `fs.contains`
+ *    — reject when the resolved candidate escapes the resolved team root.
+ *
+ * Throws {@link TeamMemoryError} when any step fails. A missing file is not an
+ * error here: the resolve+contains step still spans the nearest existing
+ * ancestor (realpath), so a missing child under an escaping symlinked ancestor
+ * is still caught.
+ * @param fs - the contiguous filesystem seam.
+ * @param teamDir - the resolved team directory path.
+ * @param relativeKey - the sanitizable relative key to validate.
+ * @returns the resolved, contained {@link FsTarget} for the candidate.
+ */
+export async function validateTeamMemKey(fs, teamDir, relativeKey) {
+    sanitizePathKey(relativeKey);
+    const fullPath = join(teamDir, relativeKey);
+    // Step 2: reject a final-segment symlink.
+    const pathInfo = await fs.lstat(fullPath);
+    if (pathInfo !== undefined && pathInfo.type === 'symlink') {
+        throw new TeamMemoryError(`Symlink at final path segment: "${relativeKey}"`);
+    }
+    // Step 3: resolve + prefix containment.
+    const candidate = await fs.resolve(fullPath);
+    const teamRoot = await fs.resolve(teamDir);
+    if (!fs.contains(teamRoot, candidate)) {
+        throw new TeamMemoryError(`Path escapes team memory directory: "${relativeKey}"`);
+    }
+    return candidate;
+}
+/**
+ * Validate and read a team memory file body, or `undefined` when the file is
+ * absent. The read only proceeds when {@link validateTeamMemKey} passes, so a
+ * traversal or symlink-escape key never reaches the read.
+ * @param fs - the contiguous filesystem seam.
+ * @param teamDir - the resolved team directory path.
+ * @param relativeKey - the sanitizable relative key to read.
+ * @param signal - optional cancellation.
+ * @returns the file body, or `undefined` if absent.
+ */
+export async function readTeamMemFile(fs, teamDir, relativeKey, signal) {
+    const target = await validateTeamMemKey(fs, teamDir, relativeKey);
+    try {
+        return await fs.readText(target, signal);
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return undefined;
+        throw error;
+    }
+}
+function isNotFound(error) {
+    return typeof error === 'object' && error !== null
+        && 'code' in error
+        && (error.code === 'FS_NOT_FOUND'
+            || error.code === 'ENOENT');
+}
+//# sourceMappingURL=team.js.map

package/lib/team.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"team.js","sourceRoot":"","sources":["../src/team.ts"],"names":[],"mappings":"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"}

package/lib/truncate.d.ts

@@ -0,0 +1,35 @@
+/**
+ * MEMORY.md entrypoint bounds and truncation.
+ * The entrypoint is the always-loaded index; its content is capped so a
+ * runaway index cannot flood the system prompt.
+ * @module @dsh-cc/memory/truncate
+ */
+/** The always-loaded index filename inside a memory directory. */
+export declare const ENTRYPOINT_NAME = "MEMORY.md";
+/** Line cap for the entrypoint index. */
+export declare const MAX_ENTRYPOINT_LINES = 200;
+/** Byte cap for the entrypoint index (long lines are the failure mode). */
+export declare const MAX_ENTRYPOINT_BYTES = 25000;
+/** Result of applying the entrypoint caps. */
+export interface EntrypointTruncation {
+    /** Truncated content, plus a trailing warning line when a cap fired. */
+    content: string;
+    /** Original trimmed line count (before any truncation). */
+    lineCount: number;
+    /** Original trimmed byte count (before any truncation). */
+    byteCount: number;
+    /** Whether the line cap fired. */
+    wasLineTruncated: boolean;
+    /** Whether the byte cap fired (against the original, pre-line-cap size). */
+    wasByteTruncated: boolean;
+}
+/**
+ * Truncate MEMORY.md content to the line AND byte caps. Line-truncates first
+ * (a natural boundary), then byte-truncates at the last newline before the cap
+ * so a line is never cut mid-way, then appends a warning that names which cap
+ * fired. Unmodified content is returned unchanged.
+ * @param raw - the raw entrypoint index text.
+ * @returns the capped content and the cap flags.
+ */
+export declare function truncateEntrypointContent(raw: string): EntrypointTruncation;
+//# sourceMappingURL=truncate.d.ts.map

package/lib/truncate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncate.d.ts","sourceRoot":"","sources":["../src/truncate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,kEAAkE;AAClE,eAAO,MAAM,eAAe,cAAc,CAAA;AAE1C,yCAAyC;AACzC,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAEvC,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,QAAS,CAAA;AAE1C,8CAA8C;AAC9C,MAAM,WAAW,oBAAoB;IACnC,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAA;IACjB,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAA;IACjB,kCAAkC;IAClC,gBAAgB,EAAE,OAAO,CAAA;IACzB,4EAA4E;IAC5E,gBAAgB,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAoC3E"}

package/lib/truncate.js

@@ -0,0 +1,52 @@
+/**
+ * MEMORY.md entrypoint bounds and truncation.
+ * The entrypoint is the always-loaded index; its content is capped so a
+ * runaway index cannot flood the system prompt.
+ * @module @dsh-cc/memory/truncate
+ */
+/** The always-loaded index filename inside a memory directory. */
+export const ENTRYPOINT_NAME = 'MEMORY.md';
+/** Line cap for the entrypoint index. */
+export const MAX_ENTRYPOINT_LINES = 200;
+/** Byte cap for the entrypoint index (long lines are the failure mode). */
+export const MAX_ENTRYPOINT_BYTES = 25_000;
+/**
+ * Truncate MEMORY.md content to the line AND byte caps. Line-truncates first
+ * (a natural boundary), then byte-truncates at the last newline before the cap
+ * so a line is never cut mid-way, then appends a warning that names which cap
+ * fired. Unmodified content is returned unchanged.
+ * @param raw - the raw entrypoint index text.
+ * @returns the capped content and the cap flags.
+ */
+export function truncateEntrypointContent(raw) {
+    const trimmed = raw.trim();
+    const contentLines = trimmed.split('\n');
+    const lineCount = contentLines.length;
+    const byteCount = trimmed.length;
+    const wasLineTruncated = lineCount > MAX_ENTRYPOINT_LINES;
+    const wasByteTruncated = byteCount > MAX_ENTRYPOINT_BYTES;
+    if (!wasLineTruncated && !wasByteTruncated) {
+        return { content: trimmed, lineCount, byteCount, wasLineTruncated, wasByteTruncated };
+    }
+    let truncated = wasLineTruncated
+        ? contentLines.slice(0, MAX_ENTRYPOINT_LINES).join('\n')
+        : trimmed;
+    if (truncated.length > MAX_ENTRYPOINT_BYTES) {
+        const cutAt = truncated.lastIndexOf('\n', MAX_ENTRYPOINT_BYTES);
+        truncated = truncated.slice(0, cutAt > 0 ? cutAt : MAX_ENTRYPOINT_BYTES);
+    }
+    const size = byteCount >= 1024 ? `${(byteCount / 1024).toFixed(1)}KB` : `${byteCount}B`;
+    const reason = wasByteTruncated && !wasLineTruncated
+        ? `${size} (limit: 25KB) — index entries are too long`
+        : wasLineTruncated && !wasByteTruncated
+            ? `${lineCount} lines (limit: ${MAX_ENTRYPOINT_LINES})`
+            : `${lineCount} lines and ${size}`;
+    return {
+        content: `${truncated}\n\n> WARNING: ${ENTRYPOINT_NAME} is ${reason}. Only part of it was loaded. Keep index entries to one line under ~200 chars; move detail into topic files.`,
+        lineCount,
+        byteCount,
+        wasLineTruncated,
+        wasByteTruncated,
+    };
+}
+//# sourceMappingURL=truncate.js.map

package/lib/truncate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncate.js","sourceRoot":"","sources":["../src/truncate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,kEAAkE;AAClE,MAAM,CAAC,MAAM,eAAe,GAAG,WAAW,CAAA;AAE1C,yCAAyC;AACzC,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAA;AAEvC,2EAA2E;AAC3E,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAA;AAgB1C;;;;;;;GAOG;AACH,MAAM,UAAU,yBAAyB,CAAC,GAAW;IACnD,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAA;IAC1B,MAAM,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IACxC,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAA;IACrC,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAA;IAEhC,MAAM,gBAAgB,GAAG,SAAS,GAAG,oBAAoB,CAAA;IACzD,MAAM,gBAAgB,GAAG,SAAS,GAAG,oBAAoB,CAAA;IAEzD,IAAI,CAAC,gBAAgB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC3C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAA;IACvF,CAAC;IAED,IAAI,SAAS,GAAG,gBAAgB;QAC9B,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QACxD,CAAC,CAAC,OAAO,CAAA;IAEX,IAAI,SAAS,CAAC,MAAM,GAAG,oBAAoB,EAAE,CAAC;QAC5C,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAA;QAC/D,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAA;IAC1E,CAAC;IAED,MAAM,IAAI,GAAG,SAAS,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAA;IACvF,MAAM,MAAM,GAAG,gBAAgB,IAAI,CAAC,gBAAgB;QAClD,CAAC,CAAC,GAAG,IAAI,6CAA6C;QACtD,CAAC,CAAC,gBAAgB,IAAI,CAAC,gBAAgB;YACrC,CAAC,CAAC,GAAG,SAAS,kBAAkB,oBAAoB,GAAG;YACvD,CAAC,CAAC,GAAG,SAAS,cAAc,IAAI,EAAE,CAAA;IAEtC,OAAO;QACL,OAAO,EAAE,GAAG,SAAS,kBAAkB,eAAe,OAAO,MAAM,8GAA8G;QACjL,SAAS;QACT,SAAS;QACT,gBAAgB;QAChB,gBAAgB;KACjB,CAAA;AACH,CAAC"}

package/lib/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Closed memory-type taxonomy and rationalized frontmatter for `dsh-memory`
+ * topic files.
+ * @module @dsh-cc/memory/types
+ */
+/** The four memory types a topic file may declare. */
+export declare const MEMORY_TYPES: readonly ["user", "feedback", "project", "reference"];
+/** One valid memory type; unknown or absent values degrade gracefully. */
+export type MemoryType = (typeof MEMORY_TYPES)[number];
+/**
+ * Parse a raw frontmatter `type` value into a {@link MemoryType}.
+ * @param raw - the value read from a topic file's frontmatter.
+ * @returns the matching type, or `undefined` for missing or unknown values.
+ */
+export declare function parseMemoryType(raw: unknown): MemoryType | undefined;
+/** One topic file's rationalized frontmatter header. */
+export interface MemoryFrontmatter {
+    /** Topic name used as the MEMORY.md index title. */
+    name: string;
+    /** One-line relevance description presented to the recall selector. */
+    description: string;
+    /** Topic type, or `undefined` for legacy files without a `type` field. */
+    type?: MemoryType;
+}
+/** A topic file discovered in a memory directory, with its rationalized header. */
+export interface MemoryIndexEntry {
+    /** Absolute path of the topic file. */
+    path: string;
+    /** Basename used to join a MEMORY.md pointer and to dedupe recall. */
+    filename: string;
+    /** Rationalized frontmatter (name/description/type). */
+    frontmatter: MemoryFrontmatter;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,sDAAsD;AACtD,eAAO,MAAM,YAAY,uDAAwD,CAAA;AAEjF,0EAA0E;AAC1E,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA;AAEtD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAIpE;AAED,wDAAwD;AACxD,MAAM,WAAW,iBAAiB;IAChC,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAA;IACnB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,UAAU,CAAA;CAClB;AAED,mFAAmF;AACnF,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAA;IACZ,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAA;IAChB,wDAAwD;IACxD,WAAW,EAAE,iBAAiB,CAAA;CAC/B"}

package/lib/types.js

@@ -0,0 +1,18 @@
+/**
+ * Closed memory-type taxonomy and rationalized frontmatter for `dsh-memory`
+ * topic files.
+ * @module @dsh-cc/memory/types
+ */
+/** The four memory types a topic file may declare. */
+export const MEMORY_TYPES = ['user', 'feedback', 'project', 'reference'];
+/**
+ * Parse a raw frontmatter `type` value into a {@link MemoryType}.
+ * @param raw - the value read from a topic file's frontmatter.
+ * @returns the matching type, or `undefined` for missing or unknown values.
+ */
+export function parseMemoryType(raw) {
+    return typeof raw === 'string'
+        ? MEMORY_TYPES.find(type => type === raw)
+        : undefined;
+}
+//# sourceMappingURL=types.js.map

package/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,sDAAsD;AACtD,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,CAAU,CAAA;AAKjF;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,GAAY;IAC1C,OAAO,OAAO,GAAG,KAAK,QAAQ;QAC5B,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,GAAG,CAAC;QACzC,CAAC,CAAC,SAAS,CAAA;AACf,CAAC"}

package/lib/writeback.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Host-side write-back for memory fork output.
+ *
+ * The extraction/dream forks inherit the parent session's sandbox policy,
+ * under which the memory directory (the harness home) is OUTSIDE the session
+ * workspace: every model-side `write` is fenced, and a background job cannot
+ * escalate (escalation prompts, and its approval policy is `never`). So the
+ * forks return their file set as structured output and the plugin — trusted
+ * host code — performs the writes itself, stamping a per-call policy whose
+ * writable root IS the memory directory. The sandbox still confines each
+ * write behind the filename validation below (defense in depth); nothing
+ * outside the memory directory becomes writable.
+ *
+ * Validation rejects the WHOLE batch on any violation — a partial write would
+ * leave the index and its topic files inconsistent with no signal back to the
+ * fork that produced them.
+ * @module @dsh-cc/memory-consolidation/writeback
+ */
+import type { FileSystem } from '@deepseek-ai/dsh-fs';
+/** One file the fork asks the plugin to write: a flat filename plus full body. */
+export interface MemoryWrite {
+    readonly path: string;
+    readonly content: string;
+}
+/** The structured-output contract every memory fork reports. */
+export declare const MEMORY_WRITES_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly writes: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly path: {
+                        readonly type: "string";
+                    };
+                    readonly content: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["path", "content"];
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly required: readonly ["writes"];
+    readonly additionalProperties: false;
+};
+/** At most this many files per fork report. */
+export declare const WRITEBACK_MAX_FILES = 32;
+/** Per-file body cap, in UTF-8 bytes. */
+export declare const WRITEBACK_MAX_FILE_BYTES: number;
+/** Whole-batch body cap, in UTF-8 bytes. */
+export declare const WRITEBACK_MAX_TOTAL_BYTES: number;
+/**
+ * The per-call policy stamped on host-side memory writes: confinement is kept
+ * (`workspace-write`), but the writable root is the memory directory itself.
+ * Mirrors the upstream "an approved escalation stamps a wider mode for one
+ * call" mechanism — here the plugin is the approver, and the name validation
+ * above has already narrowed the file set.
+ */
+export interface MemoryWritePolicy {
+    readonly mode: 'workspace-write';
+    readonly workspaceRoot: string;
+}
+/** The policy for host-side writes inside `dir` (also used for the dream lock). */
+export declare function memoryWritePolicy(dir: string): MemoryWritePolicy;
+/**
+ * Validate a fork's structured payload into a writable batch. Throws with a
+ * precise reason on ANY violation; an empty `writes` array is a valid no-op.
+ * @param input - the raw `structured` value captured from the fork.
+ * @returns the validated writes.
+ */
+export declare function validateMemoryWrites(input: unknown): MemoryWrite[];
+/**
+ * Validate, then write the batch inside the memory directory under the
+ * confined per-call policy. Writes are sequential so a mid-batch failure
+ * leaves a deterministic prefix; the caller maps any throw to a failed job.
+ * @param fs - the filesystem seam.
+ * @param dir - the memory directory root.
+ * @param writes - an already-validated batch (see {@link validateMemoryWrites}).
+ * @returns the filenames written, in batch order.
+ */
+export declare function writeMemoryFiles(fs: FileSystem, dir: string, writes: readonly MemoryWrite[]): Promise<string[]>;
+//# sourceMappingURL=writeback.d.ts.map

package/lib/writeback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeback.d.ts","sourceRoot":"","sources":["../src/writeback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAErD,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED,gEAAgE;AAChE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CAkBvB,CAAA;AAEV,+CAA+C;AAC/C,eAAO,MAAM,mBAAmB,KAAK,CAAA;AACrC,yCAAyC;AACzC,eAAO,MAAM,wBAAwB,QAAY,CAAA;AACjD,4CAA4C;AAC5C,eAAO,MAAM,yBAAyB,QAAa,CAAA;AASnD;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;CAC/B;AAED,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,EAAE,CAuClE;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,UAAU,EACd,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,SAAS,WAAW,EAAE,GAC7B,OAAO,CAAC,MAAM,EAAE,CAAC,CASnB"}

package/lib/writeback.js

@@ -0,0 +1,121 @@
+/**
+ * Host-side write-back for memory fork output.
+ *
+ * The extraction/dream forks inherit the parent session's sandbox policy,
+ * under which the memory directory (the harness home) is OUTSIDE the session
+ * workspace: every model-side `write` is fenced, and a background job cannot
+ * escalate (escalation prompts, and its approval policy is `never`). So the
+ * forks return their file set as structured output and the plugin — trusted
+ * host code — performs the writes itself, stamping a per-call policy whose
+ * writable root IS the memory directory. The sandbox still confines each
+ * write behind the filename validation below (defense in depth); nothing
+ * outside the memory directory becomes writable.
+ *
+ * Validation rejects the WHOLE batch on any violation — a partial write would
+ * leave the index and its topic files inconsistent with no signal back to the
+ * fork that produced them.
+ * @module @dsh-cc/memory-consolidation/writeback
+ */
+import { join } from 'node:path';
+/** The structured-output contract every memory fork reports. */
+export const MEMORY_WRITES_SCHEMA = {
+    type: 'object',
+    properties: {
+        writes: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string' },
+                    content: { type: 'string' },
+                },
+                required: ['path', 'content'],
+                additionalProperties: false,
+            },
+        },
+    },
+    required: ['writes'],
+    additionalProperties: false,
+};
+/** At most this many files per fork report. */
+export const WRITEBACK_MAX_FILES = 32;
+/** Per-file body cap, in UTF-8 bytes. */
+export const WRITEBACK_MAX_FILE_BYTES = 64 * 1024;
+/** Whole-batch body cap, in UTF-8 bytes. */
+export const WRITEBACK_MAX_TOTAL_BYTES = 256 * 1024;
+/**
+ * Flat `.md` filenames only: a leading alphanumeric, then alphanumerics /
+ * dots / dashes / underscores. This forbids separators, `..` escapes,
+ * absolute paths, and dotfiles (including the consolidation lock) in one rule.
+ */
+const FILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*\.md$/;
+/** The policy for host-side writes inside `dir` (also used for the dream lock). */
+export function memoryWritePolicy(dir) {
+    return { mode: 'workspace-write', workspaceRoot: dir };
+}
+/**
+ * Validate a fork's structured payload into a writable batch. Throws with a
+ * precise reason on ANY violation; an empty `writes` array is a valid no-op.
+ * @param input - the raw `structured` value captured from the fork.
+ * @returns the validated writes.
+ */
+export function validateMemoryWrites(input) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw new Error('memory fork output must be an object with a "writes" array');
+    }
+    const raw = input.writes;
+    if (!Array.isArray(raw)) {
+        throw new Error('memory fork output must be an object with a "writes" array');
+    }
+    if (raw.length > WRITEBACK_MAX_FILES) {
+        throw new Error(`memory fork reported ${raw.length} files, over the ${WRITEBACK_MAX_FILES} cap`);
+    }
+    const seen = new Set();
+    let total = 0;
+    const writes = raw.map((entry, i) => {
+        if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+            throw new Error(`memory write #${i} must be an object with path/content strings`);
+        }
+        const { path, content } = entry;
+        if (typeof path !== 'string' || typeof content !== 'string') {
+            throw new Error(`memory write #${i} must be an object with path/content strings`);
+        }
+        if (!FILE_NAME.test(path)) {
+            throw new Error(`invalid memory filename "${path}": expected a flat .md name`);
+        }
+        if (seen.has(path)) {
+            throw new Error(`duplicate memory filename "${path}" in one batch`);
+        }
+        seen.add(path);
+        const bytes = Buffer.byteLength(content, 'utf8');
+        if (bytes > WRITEBACK_MAX_FILE_BYTES) {
+            throw new Error(`memory file "${path}" is ${bytes} bytes, over the ${WRITEBACK_MAX_FILE_BYTES} cap`);
+        }
+        total += bytes;
+        return { path, content };
+    });
+    if (total > WRITEBACK_MAX_TOTAL_BYTES) {
+        throw new Error(`memory batch is ${total} bytes, over the ${WRITEBACK_MAX_TOTAL_BYTES} cap`);
+    }
+    return writes;
+}
+/**
+ * Validate, then write the batch inside the memory directory under the
+ * confined per-call policy. Writes are sequential so a mid-batch failure
+ * leaves a deterministic prefix; the caller maps any throw to a failed job.
+ * @param fs - the filesystem seam.
+ * @param dir - the memory directory root.
+ * @param writes - an already-validated batch (see {@link validateMemoryWrites}).
+ * @returns the filenames written, in batch order.
+ */
+export async function writeMemoryFiles(fs, dir, writes) {
+    const policy = memoryWritePolicy(dir);
+    const written = [];
+    for (const { path, content } of writes) {
+        const target = await fs.resolve(join(dir, path));
+        await fs.writeText(target, content, undefined, undefined, policy);
+        written.push(path);
+    }
+    return written;
+}
+//# sourceMappingURL=writeback.js.map

package/lib/writeback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeback.js","sourceRoot":"","sources":["../src/writeback.ts"],"names":[],"mappings":"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"}