@t4r71/dsh-dual-axis 0.1.0

package/lib/types/session-store.d.ts

@@ -0,0 +1,496 @@
+/**
+ * THE per-session axis store, outside the session log.
+ *
+ * The axes cannot live in a session's own log: this package's own event type is
+ * not in 0.1.7's `KNOWN_SESSION_EVENT_TYPES`, and `Session.append` takes no
+ * envelope option, so the event cannot be marked `ignorable` and a log carrying
+ * it is refused WHOLE by `validateStoredEvents`
+ * (`packages/session/session-persistence/src/storage-contract.ts:75-77`).
+ * A session this package had written to could therefore not be opened at all
+ * after a restart.
+ *
+ * The axes live instead in this package's OWN settings namespace,
+ * `dual-axis-sessions`, partitioned by session id. That namespace is a
+ * separate Loader entry from `dual-axis` because the row's namespace carries the
+ * settings page's read/write/defaultGroups form: an undeclared field inside that
+ * row would be projected into the row's form. This namespace declares exactly one
+ * field and the settings page never renders it.
+ *
+ * `sandbox/mode` REMAINS the write axis's legal landing place in the log — see
+ * `./session-axes.ts`, which mirrors the write base onto it. The log therefore
+ * still records the containment the operating-system layer enforces; what it no
+ * longer records is the path-level axis pair, which is this module's.
+ *
+ * A session with NO record is neither an error state nor a reason to hide a
+ * control: every live decision path reads through {@link SessionAxesStore.ensure},
+ * which answers {@link seedAxesFor} — the deployment seed a newly created session
+ * is pinned with — and hands that SAME value to the ONE repair write it
+ * schedules. Such a session therefore runs under the deployment's seed from its
+ * first read, not under {@link DEFAULT_AXES} until the record lands, and the pair
+ * a picker shows before the record exists is the pair the fence and the prompt
+ * are already enforcing (the client half recomputes that seed from the same row —
+ * see `sessionAxesSeed` in `@t4r71/dsh-dual-axis-ui`).
+ * {@link DEFAULT_AXES} is now only the answer {@link SessionAxesStore.getOr} gives
+ * a caller that holds no session to build a seed from.
+ *
+ * A session with no record that has ALSO never been used is a different case, and
+ * it is the one the workspace picker creates every time: reopening the same
+ * workspace reopens the same session id, so freezing it at creation would pin the
+ * axes of a conversation nobody has had to whatever the settings row said that
+ * day. Its record is therefore written when it is USED ({@link hasContent}), not
+ * when it is created: until then every read recomputes the seed from the row as
+ * it stands NOW, and the dropdown follows the settings page in real time.
+ *
+ * @module @t4r71/dsh-dual-axis/session-store
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Dict } from '@deepseek-ai/cosmokit';
+import z from '@deepseek-ai/schemastery';
+import type { Session } from '@deepseek-ai/dsh-session';
+import type { AxisScope, EffectiveScopes } from './axis.ts';
+import type { WriteNarrowing } from './groups.ts';
+/**
+ * The settings namespace holding every session's axis pair. It is a Loader entry
+ * id (`cordis.patch.yml`), which is what `SettingsForms.write` looks up.
+ */
+export declare const SESSION_AXES_NAMESPACE = "dual-axis-sessions";
+/** The single Config field: session id -> axis pair. */
+export declare const SESSION_AXES_FIELD = "axes";
+/**
+ * One session's stored axis pair, keyed by session id inside
+ * {@link SESSION_AXES_FIELD}. Both members are the session's own preset, group
+ * references included; a group's rules are never copied here, so editing a group
+ * still reaches every session that references it.
+ */
+export interface SessionAxesRecord {
+    /** The read axis preset. */
+    readonly read: AxisScope;
+    /** The write axis preset. */
+    readonly write: AxisScope;
+    /**
+     * What the write-never-exceeds-read invariant removed from that write axis, as
+     * the resolution computed it.
+     *
+     * Stored rather than recomputed by the reader because only the host can compute
+     * it: the resolution canonicalizes every root with `realpath` and derives a
+     * `workspace` base from `os.tmpdir()`. A browser surface showing a narrowing
+     * the fence does not enforce — or missing one it does — is worse than showing
+     * none, so the display reads the resolution's own output instead of a second
+     * implementation of the path algebra.
+     *
+     * Absent for a record written before this member existed, and for a record
+     * whose write range the intersection left alone: the reader then shows no
+     * narrowing, which is what the fence enforced in both cases.
+     */
+    readonly narrowing?: WriteNarrowing;
+}
+/** The whole stored field: session id -> pair. */
+export type SessionAxesField = Readonly<Record<string, SessionAxesRecord>>;
+/**
+ * This entry's composition config. The field is `.volatile()` because 0.1.7
+ * refuses an entry with no volatile field outright
+ * (`packages/settings/settings/src/index.ts:385-386`) and because path writes
+ * are refused for every non-volatile path (`:387-389`).
+ *
+ * `z.dict(z.any())` rather than a per-session object schema: the keys are session
+ * ids, which no schema can enumerate, and the VALUES are validated by
+ * {@link parseSessionAxesField}, where an unreadable axis becomes a throw rather
+ * than an invented boundary — the same rule the row's own axes follow.
+ *
+ * Annotated rather than inferred: `z.dict`'s output names `Dict` from
+ * `@deepseek-ai/cosmokit`, and declaration emit refuses a type it can only reach
+ * through a nested `node_modules` path (TS2883). The annotation states the same
+ * type through that package's own entry.
+ */
+export declare const Config: z<{
+    axes: Dict<any>;
+}>;
+/**
+ * The pair {@link SessionAxesStore.getOr} answers for a session with no stored
+ * record, and nothing else.
+ *
+ * It is deliberately NOT what a session with no record is held to any more:
+ * every live read goes through {@link SessionAxesStore.ensure}, which answers the
+ * deployment's seed ({@link seedAxesFor}), so the pair in force is the pair the
+ * session was created with rather than the built-in one. Reaching for this
+ * constant on a decision path would hold a session to a boundary the settings
+ * page never chose — narrower than an `all` default, wider than a `deny` one.
+ * @see SessionAxesStore.getOr
+ */
+export declare const DEFAULT_AXES: EffectiveScopes;
+/**
+ * The axis pair a session with no stored record is REPAIRED to — the same seed a
+ * newly created session is pinned with.
+ *
+ * Repairing to the standing pair instead (`DEFAULT_AXES`) would be narrower but wrong: a
+ * session whose creation-time write was lost would keep the built-in defaults
+ * for the rest of its life, and the settings page's seed would never reach it.
+ * Repairing to the seed keeps `pin`'s retry semantics intact — the retry just
+ * happens on the next touch of the session instead of only at creation.
+ *
+ * The seed is computed from two synchronous reads: the settings row's
+ * `read`/`write`/`defaultGroups` (seeds for a session that has none of its own)
+ * and, for a subagent child, the parent's pair AS IT STANDS NOW. A parent with
+ * no record of its own yields `undefined` from {@link inheritedAxes}, which is
+ * the same answer `pin` gets, so parent and child agree in that case too.
+ * @param ctx - host context; carries the settings service the seed is read from.
+ * @param session - the session to seed.
+ * @param fallback - the composing plugin's own config, used only when no settings
+ *   service is mounted (where the namespace cannot be written anyway).
+ * @returns the pair a newly created session would have been pinned with.
+ */
+export declare function seedAxesFor(ctx: Context, session: Session, fallback?: {
+    readonly axes: EffectiveScopes;
+    readonly groups: readonly string[];
+}): EffectiveScopes;
+/**
+ * The pure core of {@link seedAxesFor}: one settings row value, plus the pair a
+ * subagent child inherits, into the pair a session with no record is seeded with.
+ *
+ * It is TOTAL on purpose, and the client half mirrors it step for step
+ * (`sessionAxesSeed` in `@t4r71/dsh-dual-axis-ui`, pinned by
+ * `tests/seed-parity.spec.ts`): an unreadable row, and an unreadable inherited
+ * pair, answer {@link DEFAULT_AXES}. That is also what a live read answers — see
+ * {@link SessionAxesStore.ensure} — so the pair a picker shows for a session with
+ * no record and the pair the host enforces are one value rather than two.
+ * @param row - the settings row's value, untrusted: a human may have edited it.
+ * @param inherited - the parent's pair for a subagent child, or `undefined`.
+ * @returns the seed pair.
+ */
+export declare function seedPair(row: unknown, inherited: EffectiveScopes | undefined): EffectiveScopes;
+/**
+ * The pair a **subagent child session** inherits, or `undefined` when this is not
+ * a child or its parent holds no record.
+ *
+ * A child does not read the settings page: 0.1.7 deliberately seeds a child with
+ * its parent's explicit per-session override, and the parent's STORED pair is the
+ * only copy of that override this package has. Returning `undefined` (rather than
+ * inventing one) leaves the caller on the settings seed, which is what the child
+ * would have received had the parent never overridden anything — and is exactly
+ * the pair an un-recorded parent is itself held to.
+ *
+ * The record is looked up by the id the child's header names. The parent's own
+ * Session object is NOT required: requiring it made the answer depend on whether
+ * the parent happened to be resident in this process, and the client half — which
+ * reads the same document by the same id — cannot observe residency, so the two
+ * would disagree for a child whose parent is not materialized.
+ * @param ctx - host context carrying the axis store.
+ * @param session - the session whose parent to read.
+ * @returns the parent's pair, or `undefined`.
+ */
+export declare function inheritedAxes(ctx: Context, session: Session): EffectiveScopes | undefined;
+/**
+ * The one persistence read the sweep performs.
+ *
+ * Declared here rather than imported: this package resolves every
+ * `@deepseek-ai/*` import from its own `node_modules` (tsconfig.base.json declares
+ * no `paths`), and `@deepseek-ai/dsh-session-persistence` is not one of its
+ * dependencies, so a type-only import of it would not resolve.
+ * The member is declared OPTIONAL on purpose — a composition without persistence
+ * (an in-memory session store) must not fail this plugin's load, it must simply
+ * leave the sweep unable to judge.
+ */
+export interface SessionPersistenceLister {
+    /**
+     * List every stored session visible to this process.
+     * @returns one entry per stored session, carrying its header.
+     */
+    list(): Promise<readonly {
+        header: {
+            id: string;
+        };
+    }[]>;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** The mounted persistence backend, when the composition has one. */
+        sessionPersistence?: SessionPersistenceLister;
+    }
+}
+/** The axes this package writes and the settings document it writes them through. */
+export interface SessionAxesWriter {
+    /** Project every configurable entry's current form values. */
+    describe(): readonly {
+        ns: string;
+        value: unknown;
+    }[];
+    /**
+     * Reset this namespace's volatile fields, then set the supplied ones.
+     * @param ns - the entry id.
+     * @param section - the complete form values to keep.
+     * @param expectedRevision - the revision `describe` reported, or none.
+     */
+    replace(ns: string, section: object, expectedRevision?: number): Promise<void>;
+}
+/** How many times one write re-reads the revision after a conflict. */
+export declare const AXES_WRITE_ATTEMPTS = 4;
+/** Milliseconds before attempt N is issued, N counted from zero. */
+export declare const AXES_WRITE_BACKOFF_MS: readonly number[];
+/**
+ * A whole-document write was refused because another writer moved the settings
+ * document between this writer's read and its write.
+ *
+ * It is thrown, never swallowed: the axis a person just picked is not in force
+ * unless it was stored, and reporting success for a lost write would leave the
+ * fence enforcing a range the picker does not show.
+ */
+export declare class SessionAxesConflictError extends Error {
+    /** Stable machine code for callers that map failures to their own taxonomy. */
+    readonly code = "DUAL_AXIS_AXES_CONFLICT";
+    /** The namespace whose write was refused. */
+    readonly ns = "dual-axis-sessions";
+    /** Attempts made before giving up. */
+    readonly attempts: number;
+    /**
+     * @param cause - the last conflict the settings service raised.
+     * @param attempts - attempts made before giving up.
+     */
+    constructor(cause: unknown, attempts: number);
+}
+/**
+ * Read one stored record into an axis pair, or throw naming the member that is
+ * unreadable.
+ * @param id - the session id the record belongs to, for the error message.
+ * @param value - the untrusted record.
+ * @returns the validated pair.
+ * @throws When either member is not a legal axis value.
+ */
+export declare function parseSessionAxesRecord(id: string, value: unknown): SessionAxesRecord;
+/**
+ * Read the whole stored field. A human may have edited the settings document, so
+ * an unreadable entry throws instead of being dropped: dropping it would silently
+ * widen that session back to the deployment defaults.
+ * @param value - the untrusted `axes` field.
+ * @returns every stored pair, by session id.
+ * @throws When the field is not an object of readable records.
+ */
+export declare function parseSessionAxesField(value: unknown): Record<string, SessionAxesRecord>;
+/** What one GC sweep removed. */
+export interface SessionAxesSweep {
+    /** Session ids whose records were dropped. */
+    readonly removed: readonly string[];
+    /** How many records the store held before the sweep. */
+    readonly before: number;
+}
+/** Options for {@link SessionAxesStore}. */
+export interface SessionAxesStoreOptions {
+    /** Attempts per write; defaults to {@link AXES_WRITE_ATTEMPTS}. */
+    readonly attempts?: number;
+    /** Backoff before attempt N; defaults to {@link AXES_WRITE_BACKOFF_MS}. */
+    readonly backoffMs?: readonly number[];
+    /** Delay used by {@link SessionAxesStore.sleep}; injectable so tests do not wait. */
+    readonly sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * The read and write face of {@link SESSION_AXES_NAMESPACE}, plus the sweep that
+ * keeps it from growing with the sessions that no longer exist.
+ *
+ * Reads go through `settings.describe()`, the same projection the settings page
+ * renders from, and are memoized on the namespace's `revision` — which 0.1.7 bumps
+ * exactly when that entry's stored profile override changes
+ * (`packages/settings/settings/src/index.ts:311-317`). A decision path therefore
+ * pays one `describe()` per document change, not one per tool dispatch.
+ */
+export declare class SessionAxesStore {
+    private readonly ctx;
+    private readonly options;
+    private cachedRevision;
+    private cachedRecords;
+    /** Parsed records by the JSON spelling that produced them. */
+    private readonly bySpelling;
+    /**
+     * Session ids with a repair write outstanding (or already landed) since the
+     * record was found missing. Prevents one repair per tool dispatch while the
+     * whole-document write is in flight; cleared when a write FAILS so the next
+     * touch retries instead of leaving the session on the defaults forever.
+     */
+    private readonly repairing;
+    /**
+     * The last narrowing report this store handed to a write, by session id. A
+     * decision path re-resolves on every touch, so this is what keeps it from
+     * queueing the same document write over and over; it is cleared when a write
+     * lands (or fails), never on a read.
+     */
+    private readonly narrowingMemo;
+    /** Sessions with a narrowing write outstanding right now. */
+    private readonly narrowingWriting;
+    /**
+     * @param ctx - host context; the settings service is looked up, never injected,
+     *   so a composition without settings still loads this package's fence.
+     * @param options - retry policy and the sleep used between attempts.
+     */
+    constructor(ctx: Context, options?: SessionAxesStoreOptions);
+    /**
+     * This namespace's current settings row, or `undefined` when no settings
+     * service is mounted or the entry is not composed.
+     * @returns the descriptor carrying the value and the revision.
+     */
+    private descriptor;
+    /**
+     * Every stored pair, by session id.
+     * @returns the parsed field.
+     * @throws When the document carries an unreadable record.
+     */
+    records(): Record<string, SessionAxesRecord>;
+    /**
+     * One session's stored pair.
+     * @param sessionId - the session whose axes to read.
+     * @returns the pair, or `undefined` when this session has no record yet.
+     */
+    get(sessionId: string): EffectiveScopes | undefined;
+    /**
+     * One session's stored pair, or the built-in defaults.
+     *
+     * The answer for a caller that has no session to build a seed from, and the only
+     * remaining reader of {@link DEFAULT_AXES}. Every live path reads {@link ensure}
+     * instead, whose un-recorded answer is the session's own seed.
+     * @param sessionId - the session whose axes to read.
+     * @returns the pair in force.
+     */
+    getOr(sessionId: string): EffectiveScopes;
+    /**
+     * One session's pair, with an un-recorded session scheduled for repair.
+     *
+     * This is the read every LIVE touch point uses (the model-facing prompt, the
+     * read fence, and `/axis`). A session that has a record answers it; a session
+     * that has none answers {@link seedAxesFor} — the pair `pin` writes for a newly
+     * created session — and that ONE value is both this read's answer and what the
+     * scheduled repair stores. The answer and the write therefore cannot disagree,
+     * and a session created under a saved default runs under that default from its
+     * FIRST turn instead of waiting for the record to land. The record is what
+     * answers from the moment it lands.
+     *
+     * An un-recorded session is only REPAIRED when it has been used
+     * ({@link hasContent}). Until then the seed is recomputed on every read, so the
+     * settings row stays live: a session the workspace picker reopens before anyone
+     * has sent anything follows the settings page, which is the whole point of not
+     * having a record yet. The moment a turn lands, the next read repairs the
+     * session and it freezes — the same seed it answered with, computed from the row
+     * as it then stood.
+     *
+     * The seed is a thunk because only the caller can build it (it needs the
+     * session, and the composing plugin's config for a settings-less host). It is
+     * evaluated exactly once per un-recorded read — those reads are a prompt
+     * assembly, a tool dispatch and a pick, never a hot loop — and it must have no
+     * side effect, because its value IS this read's answer.
+     * @param sessionId - the session whose axes to read.
+     * @param seed - builds the pair a repair persists AND this read answers; never
+     *   called when a record exists.
+     * @param frozen - whether the session has been used, so its pair must be
+     *   written rather than recomputed. Defaults to `true`: a caller that cannot
+     *   judge the session's content keeps the pre-existing freeze-on-first-touch
+     *   behaviour, which is the safe direction — it never widens a live session's
+     *   axes behind the person's back.
+     * @returns the pair in force right now.
+     */
+    ensure(sessionId: string, seed: () => EffectiveScopes, frozen?: boolean): EffectiveScopes;
+    /**
+     * Publish the narrowing a live read just resolved, when the record does not
+     * already carry it.
+     *
+     * This is how the client half learns what the read axis removed from the write
+     * range without re-implementing the path algebra: it reads this member out of
+     * the same document its two dropdowns already read. The value comes from the
+     * very resolution the prompt and the fence used, so the surfaced narrowing and
+     * the enforced one are one computation rather than two that must agree.
+     *
+     * Called on every touch of a session that references groups, so an edit to a
+     * group's rules is republished by the next touch instead of waiting for the
+     * record to be rewritten for another reason. A session with no record is left
+     * alone: its axes are recomputed from the settings row on every read, and a
+     * store of its own would freeze that. Writes are fire-and-forget — a caller is
+     * a synchronous decision path and its answer must not depend on a document
+     * write.
+     * @param sessionId - the session whose narrowing to publish.
+     * @param narrowing - the value {@link resolveEffectiveAxes} returned for it.
+     */
+    refreshNarrowing(sessionId: string, narrowing: WriteNarrowing): void;
+    /**
+     * Store one narrowing report for a session that already has a record, at most
+     * once per value.
+     *
+     * A failed write only forgets what was attempted: the next touch republishes
+     * the same report, and the dropdowns keep showing the last stored one instead
+     * of nothing. It never touches the axes, so a refresh that loses its race
+     * cannot revert a pick.
+     * @param sessionId - the session to update.
+     * @param narrowing - the report to store.
+     */
+    private writeNarrowing;
+    /**
+     * Store one session's pair, whole-document, and report a lost write loudly.
+     *
+     * A single `replace` of the field: removal needs the whole map anyway, and a
+     * per-id path write cannot prune. Every attempt re-reads the revision, so an
+     * edit that landed between the read and the write is retried against the value
+     * it produced instead of being overwritten from a stale snapshot.
+     * @param sessionId - the session the pair belongs to.
+     * @param axes - the pair to store.
+     * @throws {SessionAxesConflictError} when every attempt lost the revision race.
+     * @throws When no settings service serves this namespace.
+     */
+    set(sessionId: string, axes: EffectiveScopes, narrowing?: WriteNarrowing): Promise<void>;
+    /**
+     * Persist one un-recorded session's seed, at most once until it lands.
+     *
+     * Fire-and-forget on purpose: every caller is a synchronous decision path
+     * (a tool dispatch, a prompt assembly) that cannot await a whole-document
+     * write, and none of them may fail because the repair could not be stored —
+     * the answer that read already gave stands either way. A failed repair is
+     * logged and re-armed.
+     * @param sessionId - the session to repair.
+     * @param seed - builds the pair to persist; may throw on an unreadable document.
+     */
+    private scheduleRepair;
+    /**
+     * Prune records whose session no longer exists.
+     *
+     * The deletion signal is the persistence layer itself: a session whose id is
+     * absent from `sessionPersistence.list()` has no stored log. `session/disposed`
+     * is NOT that signal — residency churn disposes a session whose file is still on
+     * disk, and dropping its axes there would silently reset a session that is about
+     * to be resumed.
+     * @returns the ids dropped, or `undefined` when the sweep cannot judge (no
+     *   persistence service mounted, or a listing failed): an unjudgeable sweep
+     *   removes nothing.
+     */
+    sweep(): Promise<SessionAxesSweep | undefined>;
+    /**
+     * Replace the whole field, retrying while the revision fence refuses it.
+     * @param records - the complete next field.
+     * @throws {SessionAxesConflictError} when every attempt was refused.
+     */
+    private replaceRecords;
+}
+/**
+ * The store of one host context. Consumers hold no service of their own: the
+ * fence and the prompt must keep working in a composition that never mounted the
+ * settings service, where the store simply has nothing to read.
+ * @param ctx - host context.
+ * @returns the shared store.
+ */
+export declare function sessionAxesStore(ctx: Context): SessionAxesStore;
+/**
+ * `Loader.unwrapExports` returns `exports.default` and DROPS every sibling named
+ * export (`vendor/loader/src/index.ts:201-208`), while the registry reads the
+ * schema off the plugin value itself. The Config therefore has to ride the
+ * default export, exactly as `./read-guard.ts` attaches its own.
+ */
+export interface SessionStoreEntry {
+    /** Does nothing; every read and write goes through {@link SessionAxesStore}. */
+    (): Promise<void>;
+    /** This entry's composition config, projected by the settings form. */
+    Config: z<{
+        axes: Dict<any>;
+    }>;
+}
+/**
+ * The Loader entry's value: the no-op apply carrying the Config the registry
+ * reads off the plugin value itself. Spelled as an interface for the same reason
+ * {@link Config} is annotated — the inferred type of `Object.assign(apply, {
+ * Config })` names `Dict` from `@deepseek-ai/cosmokit`, which declaration emit
+ * cannot reach by name.
+ */
+declare const entry: SessionStoreEntry;
+export default entry;
+//# sourceMappingURL=session-store.d.ts.map

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@t4r71/dsh-dual-axis",
+  "description": "The dual-axis access-mode bundle: the file sandbox's read and write axes, custom allow/deny paths included, as an installable profile layer",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./fs": {
+      "types": "./lib/types/fs.d.ts",
+      "default": "./lib/fs.js"
+    },
+    "./read-guard": {
+      "types": "./lib/types/read-guard.d.ts",
+      "default": "./lib/read-guard.js"
+    },
+    "./session-store": {
+      "types": "./lib/types/session-store.d.ts",
+      "default": "./lib/session-store.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "tsc -b && tsdown",
+    "test": "node --import tsx/esm --test tests/axis.spec.ts tests/groups.spec.ts tests/settings.spec.ts tests/session-store.spec.ts tests/seed-parity.spec.ts tests/narrowing.spec.ts tests/content.spec.ts",
+    "typecheck": "tsc -b && tsc -p tsconfig.test.json --noEmit"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/fs.js",
+    "lib/read-guard.js",
+    "lib/session-store.js",
+    "cordis.patch.yml",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "author": "T4R71 <T4R71@outlook.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/T4R71/dsh-dual-axis.git",
+    "directory": "packages/dual-axis"
+  },
+  "homepage": "https://github.com/T4R71/dsh-dual-axis#readme",
+  "bugs": "https://github.com/T4R71/dsh-dual-axis/issues",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "cordis",
+    "plugin",
+    "sandbox",
+    "access-control"
+  ],
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-agent": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-commands": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-fs": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-fs-sandbox": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-sandbox": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-sandbox-policy": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-session-projection": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-settings": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.4",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/cosmokit": "^1.8.5",
+    "@deepseek-ai/dsh-agent": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-commands": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-fs": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-fs-local": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-fs-sandbox": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-sandbox": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-sandbox-policy": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-session-projection": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-settings": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.4",
+    "@types/node": "^24.0.0",
+    "tsdown": "^0.22.2",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3"
+  }
+}