@tenphi/akno-protocol 0.1.0

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyB7B;;;;GAIG;AAEH,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAEhD,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO;IAC5F,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC;IACT,MAAM,EAAE,CAAC,CAAC;IACV,mFAAmF;IACnF,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAAC;CACtB;AAMD,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwLN,CAAC;AAEX,MAAM,MAAM,MAAM,GAAG,MAAM,OAAO,GAAG,CAAC;AAEtC,eAAO,MAAM,QAAQ,EAAuB,MAAM,EAAE,CAAC;AAErD,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;AAC1E,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;AAE7E,qFAAqF;AACrF,MAAM,MAAM,OAAO,GAAG;KACnB,CAAC,IAAI,MAAM,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;CAC3D,CAAC;AAEF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,MAAM,CAEvD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEhD"}

package/dist/registry.js

@@ -0,0 +1,191 @@
+import { RecallInput, RecallOutput } from "./ops/recall.js";
+import { AnswerInput, AnswerOutput } from "./ops/answer.js";
+import { ReadInput, ReadOutput } from "./ops/read.js";
+import { ListInput, ListOutput } from "./ops/list.js";
+import { TimelineInput, TimelineOutput } from "./ops/timeline.js";
+import { ContextInput, ContextOutput } from "./ops/context.js";
+import { GraphInput, GraphOutput } from "./ops/graph.js";
+import { WriteInput, WriteOutput } from "./ops/write.js";
+import { FolderInput, FolderOutput } from "./ops/folder.js";
+import { AdoptInput, AdoptOutput, ForgetInput, ForgetOutput, IngestInput, IngestOutput, MoveInput, MoveOutput, RememberInput, RememberOutput, UndoInput, UndoOutput, } from "./ops/mutate.js";
+function op(def) {
+    return def;
+}
+export const OPS = {
+    recall: op({
+        name: 'recall',
+        kind: 'read',
+        input: RecallInput,
+        output: RecallOutput,
+        implemented: true,
+        description: 'Search memory. Returns typed page and document cards with exact source citations. A readable document ' +
+            'does not need an owning Markdown page to be found. Handles both keyword lookups and natural ' +
+            'language questions; the expansion strategy is inferred from the query. Bounded exact graph paths add ' +
+            'related candidates before ordinary reranking and qualification, with compact path provenance on cards. ' +
+            'An empty result is proof that ' +
+            'nothing matched, not a failure: check `status` for "empty" (nothing there), "degraded" (a model was ' +
+            'missing, search was weaker) or "unavailable" (the index could not be read). In question mode, ' +
+            '`coverage` reports which concepts from the question the results actually cover — do not answer the ' +
+            'parts it reports as false.',
+    }),
+    answer: op({
+        name: 'answer',
+        kind: 'read',
+        input: AnswerInput,
+        output: AnswerOutput,
+        implemented: true,
+        description: 'Answer a direct factual question using only bounded memory evidence and an independent support ' +
+            'verification pass. Returns compact exact ' +
+            'citations plus ranked related page slugs and orphan document ids. It skips reranking by default to avoid ' +
+            'a redundant interactive model call; request rerank for strict retrieval qualification, or include_context ' +
+            'to return the exact evidence already supplied to the answer model. ' +
+            'Use recall instead when evidence must be inspected, compared, or quoted. Do not call both by default: ' +
+            'answer already performs recall internally. Check status and outcome: only empty/not_found proves memory ' +
+            'has no matching evidence; degraded or unavailable never proves absence. When answer generation is not ' +
+            'configured, it returns compact related identities with degraded/not_answered and no_answer_model. A ' +
+            'failed verifier returns answer_verification_failed and no generated prose.',
+    }),
+    read: op({
+        name: 'read',
+        kind: 'read',
+        input: ReadInput,
+        output: ReadOutput,
+        implemented: true,
+        description: 'Read one exact thing: a page by slug or id, with its links and backlinks, or a document by id with ' +
+            'its extracted text. Returns the full body regardless of page role — recall caps what a source ' +
+            'page contributes unprompted, but read never does.',
+    }),
+    list: op({
+        name: 'list',
+        kind: 'read',
+        input: ListInput,
+        output: ListOutput,
+        implemented: true,
+        description: 'Browse structure rather than search it: folders and their page counts, a tree outline, or pages ' +
+            'filtered by type, tag, role or recency. Use this to find out what exists before guessing a slug.',
+    }),
+    timeline: op({
+        name: 'timeline',
+        kind: 'read',
+        input: TimelineInput,
+        output: TimelineOutput,
+        implemented: true,
+        description: 'When things happened. Dated events, filtered by range, by subject page, or by text match. Events are ' +
+            'indexed from the ledger and from dated lines on any page, so a date written on the page it belongs to ' +
+            'is found too.',
+    }),
+    context: op({
+        name: 'context',
+        kind: 'read',
+        input: ContextInput,
+        output: ContextOutput,
+        implemented: true,
+        description: 'The whole pre-turn bundle against one budget: pinned pages, recent timeline, a structure outline, and ' +
+            "this turn's recall. Normally called by the host before the model sees the turn, not by the agent. " +
+            '`profile: "auto_recall"` instead returns only a small, precision-first evidence bundle for automatic ' +
+            'host injection. It may return empty normally, uses recent conversation only to resolve local references, ' +
+            'and conditionally qualifies ambiguous candidates rather than paying for reranking on every turn.',
+    }),
+    graph: op({
+        name: 'graph',
+        kind: 'read',
+        input: GraphInput,
+        output: GraphOutput,
+        implemented: true,
+        description: 'Inspect bounded evidence paths from one exact page slug, entity id, or query. Returns compact nodes, ' +
+            'typed relationships, and line/frontmatter/document/event locators but no page bodies or copied claims. ' +
+            'Traversal is limited to three hops, excludes historical facts by default, and reports ambiguity or ' +
+            'truncation as typed degradation rather than guessing or claiming absence.',
+    }),
+    write: op({
+        name: 'write',
+        kind: 'write',
+        input: WriteInput,
+        output: WriteOutput,
+        implemented: true,
+        description: 'Create, append, patch or replace a page, optionally with an event, documents, tags and links. Check ' +
+            '`outcome`: "conflict" means an existing line claims something different — ask the user rather than ' +
+            'overwriting; "requires_folder" means the folder has not been declared yet — call `folder` to say what ' +
+            'belongs in it, then repeat this write, without asking anyone. The event ledger takes events only: pass ' +
+            '`event` and let it be filed, never `append`.',
+    }),
+    folder: op({
+        name: 'folder',
+        kind: 'write',
+        input: FolderInput,
+        output: FolderOutput,
+        implemented: true,
+        description: 'Declare a folder and what belongs in it, before writing the first page there. Never gated — nothing ' +
+            'here waits on the user. Say what the folder is for in `description`, and set `role` to "source" ' +
+            'when it holds evidence rather than claims (transcripts, articles, research, legal texts), because only ' +
+            'claims become facts. Returns "noop" when the folder is already declared.',
+    }),
+    remember: op({
+        name: 'remember',
+        kind: 'write',
+        input: RememberInput,
+        output: RememberOutput,
+        implemented: true,
+        description: 'Hand over a transcript or notes and let memory decide what is worth keeping and where it goes. Use ' +
+            'this instead of write when you do not want to choose slugs or phrasing yourself. Pass `mission` to say ' +
+            'what to pay attention to in this particular text; the standing rules about what lasts still apply. ' +
+            '`no_writable_destination` means relevant memory was found but no authorized page or managed-page ' +
+            'location could receive one or more retained claims; inspect their typed approval reasons. A configured ' +
+            'fallback page is used only after ordinary routing and page creation fail, and never grants itself write ' +
+            'permission.',
+    }),
+    forget: op({
+        name: 'forget',
+        kind: 'write',
+        input: ForgetInput,
+        output: ForgetOutput,
+        implemented: true,
+        description: 'Retract a fact by removing the sentence that produced it, delete a page to trash, or drop a document. ' +
+            'Always journalled and always reversible with undo for the retention window.',
+    }),
+    undo: op({
+        name: 'undo',
+        kind: 'write',
+        input: UndoInput,
+        output: UndoOutput,
+        implemented: true,
+        description: 'Reverse a change by its id. The id outlives the session.',
+    }),
+    move: op({
+        name: 'move',
+        kind: 'write',
+        input: MoveInput,
+        output: MoveOutput,
+        implemented: true,
+        description: 'Relocate a page with its documents, rewriting embeds. Inbound links that now point nowhere are ' +
+            'reported, never silently rewritten.',
+    }),
+    ingest: op({
+        name: 'ingest',
+        kind: 'write',
+        input: IngestInput,
+        output: IngestOutput,
+        implemented: true,
+        description: 'Pull a file, folder or URL into memory. The text is extracted for you, OCRed if there is no text layer, ' +
+            'named from its contents, summarized, and routed to a folder. You never run an extraction tool.',
+    }),
+    adopt: op({
+        name: 'adopt',
+        kind: 'write',
+        input: AdoptInput,
+        output: AdoptOutput,
+        implemented: true,
+        description: 'Organize one orphan document card by proposing its exact deterministic filing page. Uses the configured ' +
+            'adoption trust mode: audit returns a durable diff, review waits for an operator decision, and auto asks ' +
+            'the independent curator before applying and verifying ownership. It never adopts other orphan documents ' +
+            'and retrieval does not depend on accepting the proposal.',
+    }),
+};
+export const OP_NAMES = Object.keys(OPS);
+export function isOpName(value) {
+    return Object.prototype.hasOwnProperty.call(OPS, value);
+}
+export function opsByKind(kind) {
+    return OP_NAMES.filter((name) => OPS[name].kind === kind);
+}
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

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

package/dist/version.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Wire version, bumped only when an existing exchange changes in a way an older
+ * client cannot absorb. `connect()` handshakes on it and refuses a server it cannot
+ * speak to, rather than failing subtly on the third call.
+ *
+ * Adding an operation or an optional field is capability-compatible and must not
+ * bump this number: the handshake already advertises `hello.ops`. A needless bump
+ * disconnects long-lived hosts from otherwise unchanged operations until they are
+ * restarted, which turns a service-only deploy into lost memory calls.
+ */
+export declare const PROTOCOL_VERSION = 1;
+/** Advertised MCP server name. The spec calls for `memory`, not `akno`. */
+export declare const MCP_SERVER_NAME = "memory";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,2EAA2E;AAC3E,eAAO,MAAM,eAAe,WAAW,CAAC"}

package/dist/version.js

@@ -0,0 +1,14 @@
+/**
+ * Wire version, bumped only when an existing exchange changes in a way an older
+ * client cannot absorb. `connect()` handshakes on it and refuses a server it cannot
+ * speak to, rather than failing subtly on the third call.
+ *
+ * Adding an operation or an optional field is capability-compatible and must not
+ * bump this number: the handshake already advertises `hello.ops`. A needless bump
+ * disconnects long-lived hosts from otherwise unchanged operations until they are
+ * restarted, which turns a service-only deploy into lost memory calls.
+ */
+export const PROTOCOL_VERSION = 1;
+/** Advertised MCP server name. The spec calls for `memory`, not `akno`. */
+export const MCP_SERVER_NAME = 'memory';
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC;AAElC,2EAA2E;AAC3E,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC"}

package/dist/wire.d.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+/**
+ * Newline-delimited JSON, one object per line, over a unix socket or an HTTP
+ * body. Deliberately boring: the measured cost of a socket round trip is 18µs
+ * against a recall budget of 300ms, so there is nothing here worth optimizing
+ * and every reason to keep it debuggable with `nc`.
+ */
+/**
+ * The maintenance work a *host* asks the writer to do: reconcile the index, file what is in
+ * the inbox, run the cycle.
+ *
+ * Not ops, deliberately — the registry ops are what an agent calls about memory, and these are
+ * operator commands about the process. They travel the same wire for one reason: exactly one
+ * process may write, so anything that writes has to be reachable *through* it or be
+ * unavailable whenever the service is running. It used to be unavailable, and the nightly
+ * cycle would have failed every night with "another process holds the write handle".
+ */
+/**
+ * Not ops. The ops are what an agent calls *about memory*; these are what an operator asks of the
+ * *process* — reconcile the tree, file the inbox, run the cycle — plus the four that answer a gate
+ * or the journal.
+ *
+ * Gates, journal reads, and maintenance plans are here for the same reason the first three are:
+ * exactly one process may write, so with a service running they are reachable through it or not at
+ * all. They are deliberately absent from the op registry — an agent does not get to approve its own
+ * gated proposal or approve its own maintenance rewrite, and putting them on the op surface would hand it
+ * exactly that.
+ */
+export declare const COMMAND_NAMES: readonly ["index", "inbox", "dream", "approve", "decline", "changes", "proposals", "plan"];
+export type CommandName = (typeof COMMAND_NAMES)[number];
+export declare function isCommandName(value: string): value is CommandName;
+export declare const WireRequest: z.ZodObject<{
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    op: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+        op: "op";
+        command: "command";
+    }>>;
+    input: z.ZodOptional<z.ZodUnknown>;
+    actor: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        akno: "akno";
+    }>>;
+}, z.core.$strip>;
+export type WireRequest = z.infer<typeof WireRequest>;
+export declare const WireError: z.ZodObject<{
+    code: z.ZodEnum<{
+        empty: "empty";
+        degraded: "degraded";
+        unavailable: "unavailable";
+        busy: "busy";
+        interrupted: "interrupted";
+        requires_approval: "requires_approval";
+        conflict: "conflict";
+        invalid: "invalid";
+        forbidden: "forbidden";
+        not_found: "not_found";
+        read_only: "read_only";
+        not_implemented: "not_implemented";
+        internal: "internal";
+    }>;
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type WireError = z.infer<typeof WireError>;
+export declare const WireResponse: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    ok: z.ZodLiteral<true>;
+    result: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            empty: "empty";
+            degraded: "degraded";
+            unavailable: "unavailable";
+            busy: "busy";
+            interrupted: "interrupted";
+            requires_approval: "requires_approval";
+            conflict: "conflict";
+            invalid: "invalid";
+            forbidden: "forbidden";
+            not_found: "not_found";
+            read_only: "read_only";
+            not_implemented: "not_implemented";
+            internal: "internal";
+        }>;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+export type WireResponse = z.infer<typeof WireResponse>;
+/**
+ * Sent by the server on connect, before any request. The client refuses a
+ * version it cannot speak to rather than failing on the third call.
+ */
+export declare const Hello: z.ZodObject<{
+    hello: z.ZodLiteral<"akno">;
+    protocol: z.ZodNumber;
+    version: z.ZodString;
+    writable: z.ZodBoolean;
+    akno_path: z.ZodString;
+    ops: z.ZodArray<z.ZodString>;
+    commands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type Hello = z.infer<typeof Hello>;
+/** Splits a byte stream into complete lines, buffering the partial tail. */
+export declare function createLineDecoder(): (chunk: string) => string[];
+export declare function encodeLine(value: unknown): string;
+//# sourceMappingURL=wire.d.ts.map

package/dist/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../src/wire.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;GAKG;AAEH;;;;;;;;;GASG;AACH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,4FAShB,CAAC;AACX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,WAAW,CAEjE;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;iBAoBtB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;iBAIpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;mBAGvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,KAAK;;;;;;;;iBAUhB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;AAE1C,4EAA4E;AAC5E,wBAAgB,iBAAiB,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EAAE,CAS/D;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEjD"}

package/dist/wire.js

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import { ERROR_CODES } from "./errors.js";
+/**
+ * Newline-delimited JSON, one object per line, over a unix socket or an HTTP
+ * body. Deliberately boring: the measured cost of a socket round trip is 18µs
+ * against a recall budget of 300ms, so there is nothing here worth optimizing
+ * and every reason to keep it debuggable with `nc`.
+ */
+/**
+ * The maintenance work a *host* asks the writer to do: reconcile the index, file what is in
+ * the inbox, run the cycle.
+ *
+ * Not ops, deliberately — the registry ops are what an agent calls about memory, and these are
+ * operator commands about the process. They travel the same wire for one reason: exactly one
+ * process may write, so anything that writes has to be reachable *through* it or be
+ * unavailable whenever the service is running. It used to be unavailable, and the nightly
+ * cycle would have failed every night with "another process holds the write handle".
+ */
+/**
+ * Not ops. The ops are what an agent calls *about memory*; these are what an operator asks of the
+ * *process* — reconcile the tree, file the inbox, run the cycle — plus the four that answer a gate
+ * or the journal.
+ *
+ * Gates, journal reads, and maintenance plans are here for the same reason the first three are:
+ * exactly one process may write, so with a service running they are reachable through it or not at
+ * all. They are deliberately absent from the op registry — an agent does not get to approve its own
+ * gated proposal or approve its own maintenance rewrite, and putting them on the op surface would hand it
+ * exactly that.
+ */
+export const COMMAND_NAMES = [
+    'index',
+    'inbox',
+    'dream',
+    'approve',
+    'decline',
+    'changes',
+    'proposals',
+    'plan',
+];
+export function isCommandName(value) {
+    return COMMAND_NAMES.includes(value);
+}
+export const WireRequest = z.object({
+    id: z.union([z.string(), z.number()]),
+    /** An op name, or — when `kind` says so — a command name. */
+    op: z.string(),
+    kind: z.enum(['op', 'command']).optional(),
+    input: z.unknown().optional(),
+    /**
+     * Who this call speaks for. Absent means the service's own actor, which is `agent`.
+     *
+     * On the socket and the loopback HTTP door the caller is trusted to say — filesystem permissions
+     * and loopback are the authentication, and a caller that can open either could write anything it
+     * liked regardless. The gate is not a defence against that caller; it is a policy about *whose*
+     * request this is, and only the caller knows. A host mediating for an agent and a person at
+     * a terminal both need to say "this one is the user speaking" — otherwise approving a gated
+     * proposal is impossible through the very door the service is meant to be reached by.
+     *
+     * The MCP door never sets it. That door faces the agent itself, which does not get to claim to be
+     * the user, and is why `server.mcp_allow` exists on it and not here.
+     */
+    actor: z.enum(['user', 'agent', 'akno']).optional(),
+});
+export const WireError = z.object({
+    code: z.enum(ERROR_CODES),
+    message: z.string(),
+    details: z.record(z.string(), z.unknown()).optional(),
+});
+export const WireResponse = z.union([
+    z.object({ id: z.union([z.string(), z.number()]), ok: z.literal(true), result: z.unknown() }),
+    z.object({ id: z.union([z.string(), z.number()]), ok: z.literal(false), error: WireError }),
+]);
+/**
+ * Sent by the server on connect, before any request. The client refuses a
+ * version it cannot speak to rather than failing on the third call.
+ */
+export const Hello = z.object({
+    hello: z.literal('akno'),
+    protocol: z.number().int(),
+    version: z.string(),
+    /** Read-only means another process holds the write handle. */
+    writable: z.boolean(),
+    akno_path: z.string(),
+    ops: z.array(z.string()),
+    /** Maintenance commands this door accepts. Absent from an older server. */
+    commands: z.array(z.string()).optional(),
+});
+/** Splits a byte stream into complete lines, buffering the partial tail. */
+export function createLineDecoder() {
+    let buffer = '';
+    return (chunk) => {
+        buffer += chunk;
+        const parts = buffer.split('\n');
+        // The last element is either '' (chunk ended on a newline) or a partial line.
+        buffer = parts.pop() ?? '';
+        return parts.filter((line) => line.length > 0);
+    };
+}
+export function encodeLine(value) {
+    return `${JSON.stringify(value)}\n`;
+}
+//# sourceMappingURL=wire.js.map

package/dist/wire.js.map

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

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@tenphi/akno-protocol",
+  "version": "0.1.0",
+  "description": "Akno op registry and schemas — the single source of truth every door is generated from",
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "engines": {
+    "node": ">=22.18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tenphi/akno.git",
+    "directory": "packages/protocol"
+  },
+  "homepage": "https://github.com/tenphi/akno#readme",
+  "bugs": {
+    "url": "https://github.com/tenphi/akno/issues"
+  },
+  "author": "Andrey Yamanov",
+  "scripts": {}
+}