@chipschat/protocol 0.0.0-stage → 1.0.1

package/dist/src/agents.d.ts

@@ -0,0 +1,24 @@
+/**
+ * What a harness that has not learnt agents is shown (ADR 0087's addendum of 29 September).
+ *
+ * A harness takes part in rooms as its agents. One written before agents knows only itself: it
+ * reads `from.kind === "harness"` as another agent, looks for its own id in `addressed_to` and
+ * `mentions`, and learns whose agent is whose from `/v1/participants`. Until it declares
+ * `agents`, everything Chips hands it is put back into those terms, on the socket and over HTTP
+ * alike, so it goes on answering unchanged: its own agents are its own id, any other agent is a
+ * harness, and nothing says `for`. The server and the conformance fake both hand it over through
+ * this, so the two cannot drift.
+ */
+/** Events a harness that has not learnt agents is never handed: it has no words for them. */
+export declare const AGENT_EVENTS: ReadonlySet<string>;
+/** Who is looking: the harness, and the agents it speaks for without knowing it. */
+export interface LegacyView {
+    readonly harnessId: string;
+    readonly own: ReadonlySet<string>;
+}
+/**
+ * An event, a page of them or any body a harness reads, as a harness that has not declared
+ * `agents` knows it. The value given is not changed.
+ */
+export declare function inLegacyView<T>(value: T, view: LegacyView): T;
+//# sourceMappingURL=agents.d.ts.map

package/dist/src/agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/agents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,6FAA6F;AAC7F,eAAO,MAAM,YAAY,EAAE,WAAW,CAAC,MAAM,CAS3C,CAAC;AAEH,oFAAoF;AACpF,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACnC;AA8BD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,GAAG,CAAC,CAE7D"}

package/dist/src/agents.js

@@ -0,0 +1,58 @@
+/**
+ * What a harness that has not learnt agents is shown (ADR 0087's addendum of 29 September).
+ *
+ * A harness takes part in rooms as its agents. One written before agents knows only itself: it
+ * reads `from.kind === "harness"` as another agent, looks for its own id in `addressed_to` and
+ * `mentions`, and learns whose agent is whose from `/v1/participants`. Until it declares
+ * `agents`, everything Chips hands it is put back into those terms, on the socket and over HTTP
+ * alike, so it goes on answering unchanged: its own agents are its own id, any other agent is a
+ * harness, and nothing says `for`. The server and the conformance fake both hand it over through
+ * this, so the two cannot drift.
+ */
+/** Events a harness that has not learnt agents is never handed: it has no words for them. */
+export const AGENT_EVENTS = new Set([
+    "agent.registered",
+    "agent.updated",
+    "membership.replaced",
+    "agent.attached",
+    "agent.released",
+    "agent.fork",
+    "agent.asked",
+    "message.held",
+]);
+/** Whether a key names a kind of participant: `kind`, `participant_kind`. */
+function namesAKind(key) {
+    return key === "kind" || key.endsWith("_kind");
+}
+function seen(value, view, key) {
+    if (typeof value === "string")
+        return word(value, view, key);
+    if (Array.isArray(value)) {
+        const each = value.map((item) => seen(item, view, key));
+        // Two of its agents named in one list are the harness once: `addressed_to`, `mentions`.
+        return each.every((item) => typeof item === "string") ? [...new Set(each)] : each;
+    }
+    if (typeof value !== "object" || value === null)
+        return value;
+    const out = {};
+    for (const [field, inner] of Object.entries(value)) {
+        // A record keyed by participant, as the room note's `notes` is: its own agent's key is its own.
+        if (field !== "for")
+            out[view.own.has(field) ? view.harnessId : field] = seen(inner, view, field);
+    }
+    return out;
+}
+/** One string: its own agent's id is its own, and the kind `agent` is a harness. */
+function word(value, view, key) {
+    if (view.own.has(value))
+        return view.harnessId;
+    return value === "agent" && namesAKind(key) ? "harness" : value;
+}
+/**
+ * An event, a page of them or any body a harness reads, as a harness that has not declared
+ * `agents` knows it. The value given is not changed.
+ */
+export function inLegacyView(value, view) {
+    return seen(value, view, "");
+}
+//# sourceMappingURL=agents.js.map

package/dist/src/agents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.js","sourceRoot":"","sources":["../../src/agents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,6FAA6F;AAC7F,MAAM,CAAC,MAAM,YAAY,GAAwB,IAAI,GAAG,CAAC;IACvD,kBAAkB;IAClB,eAAe;IACf,qBAAqB;IACrB,gBAAgB;IAChB,gBAAgB;IAChB,YAAY;IACZ,aAAa;IACb,cAAc;CACf,CAAC,CAAC;AAQH,6EAA6E;AAC7E,SAAS,UAAU,CAAC,GAAW;IAC7B,OAAO,GAAG,KAAK,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;AACjD,CAAC;AAED,SAAS,IAAI,CAAC,KAAc,EAAE,IAAgB,EAAE,GAAW;IACzD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;IAC7D,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC;QACxD,wFAAwF;QACxF,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACpF,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACnD,gGAAgG;QAChG,IAAI,KAAK,KAAK,KAAK;YACjB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IACjF,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,oFAAoF;AACpF,SAAS,IAAI,CAAC,KAAa,EAAE,IAAgB,EAAE,GAAW;IACxD,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC,SAAS,CAAC;IAC/C,OAAO,KAAK,KAAK,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC;AAClE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAI,KAAQ,EAAE,IAAgB;IACxD,OAAO,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAM,CAAC;AACpC,CAAC"}

package/dist/src/capabilities.d.ts

@@ -0,0 +1,121 @@
+/**
+ * What a harness declares it takes, beyond the events it sends.
+ *
+ * A harness's manifest carries `capabilities`, "what the harness can do", stored when it is
+ * registered and presented back to it in `hello`. Most entries name tools — `email.send`,
+ * `drive.read` — and are the harness's own business. A few are read by the clients, because
+ * they decide whether a control is drawn at all: a control that cannot keep its promise is
+ * worse than none ([ADR 0046](../../../docs/decisions/0046-a-harness-declares-that-it-takes-the-dial.md)).
+ */
+export declare const HARNESS_CAPABILITIES: {
+    /**
+     * The harness reads the level and the rules Chips sends it — `hello.autonomy`, `policy.updated`
+     * — and asks accordingly, so the L0–L3 dial on its profile and in its run panel changes
+     * something. A harness on `@chipschat/sdk-ts` does; one with a permission model of its own — per
+     * tool, per connector — does not, and gets no dial.
+     */
+    readonly autonomy: "autonomy";
+    /**
+     * The harness takes a room a person opens and asks it into — `space.created` with `asked_of`
+     * naming it — makes its own thing for it, and claims the room with a key of its own. What makes
+     * the + for a new space worth drawing: a room asked of a harness that does not do this would
+     * wait for an answer that never comes.
+     */
+    readonly newSpaces: "new_spaces";
+    /**
+     * The harness keeps its own side of a room it opened under a key in step with the room: a
+     * person's archive and unarchive here are carried to the thing it keeps for the room, and a
+     * delete (`space.erased`) deletes that thing, or puts it away for its owner when the person
+     * deleting does not own the harness (ADR 0066, ADR 0069). What lets the sheets that ask first
+     * promise so. A harness that does not declare it is not bound by any of that — `moved_by` and
+     * the tombstone are there for it to read — and the sheets promise nothing on its behalf.
+     */
+    readonly followsRooms: "follows_rooms";
+    /**
+     * The harness speaks agents (ADR 0087): it reads `hello.agents` and `for`, and names one of its
+     * agents as the `actor` of what it sends. Until it declares this, everything Chips hands it, on
+     * the socket and over HTTP, is the view it knew before agents: its own agents are its own id,
+     * any other agent a harness, and nothing says `for` (ADR 0087's addendum of 29 September).
+     */
+    readonly agents: "agents";
+    /**
+     * The harness copies one of its agents when a person asks (ADR 0087, Fork): it hears
+     * `agent.fork`, makes a copy that remembers everything the agent did up to then, and registers
+     * it with `forked_from` and the room it was asked for, where Chips puts it. After that the two
+     * remember separately. Fork is offered only for a harness that declares this, because a room
+     * asked for a copy that never comes says so after a minute and nothing more.
+     */
+    readonly forks: "forks";
+    /**
+     * The harness makes a new agent when a person asks for one in a room (ADR 0108): it hears
+     * `agent.asked`, makes an agent that remembers nothing from elsewhere, called what the ask says,
+     * and registers it with `made_for` and the room, where Chips puts it. Only a harness that
+     * declares this is offered on a room's Add page, because a room asked for an agent that never
+     * comes says so after a minute and nothing more.
+     */
+    readonly newAgents: "new_agents";
+    /**
+     * The harness has a restart of its own and runs it when a person asks (ADR 0094): a socket of it
+     * says `restart` in its `hello`, hears the `restart` frame, and runs what the harness keeps for
+     * that — a process restarting itself, or a bridge starting what is behind it again. What makes
+     * Restart worth drawing on its page.
+     */
+    readonly restarts: "restarts";
+    /**
+     * The harness sends Chips a copy of each of its agents' context files and of its own set, keeps
+     * them current, and takes a person's edits (ADR 0134): a socket of it says `context` in its
+     * `hello`, hears `context.edit`, saves the file in its own way, and answers with its copy. What
+     * makes an agent's Context group, and its harness's shared files, worth drawing.
+     */
+    readonly contextFiles: "context_files";
+    /**
+     * The harness sends Chips a copy of each agent's model and effort, what it may run on instead
+     * and the words for each, keeps them current, and takes a person's changes (ADR 0140): a socket
+     * of it says `models` in its `hello`, hears `model.change`, sets the agent's model and effort in
+     * its own way, and answers with its copy. What makes an agent's Model group worth drawing.
+     */
+    readonly models: "models";
+    /**
+     * The harness sends Chips a copy of each agent's heartbeat, the turn it starts on its own every
+     * so often, keeps it current, and takes a person's changes (ADR 0143): a socket of it says
+     * `heartbeats` in its `hello`, hears `heartbeat.change`, switches or times the agent's heartbeat
+     * in its own way, and answers with its copy. What makes an agent's Heartbeat group worth drawing.
+     */
+    readonly heartbeats: "heartbeats";
+    /**
+     * The harness sends Chips a copy of each agent's context window, how full it is and the limit it
+     * compacts itself at, keeps it current, and takes a person's Compact now and new limit (ADR
+     * 0146): a socket of it says `context_windows` in its `hello`, hears `context_window.compact`
+     * and `context_window.change`, does them in its own way, and answers with its copy. What makes
+     * an agent's Context window group worth drawing.
+     */
+    readonly contextWindows: "context_windows";
+    /**
+     * The harness sends Chips a copy of the jobs it runs on its own, outside any space, and posts
+     * each run with what it cost, and takes a person's switch (ADR 0252): a socket of it says `jobs`
+     * in its `hello`, hears `job.change`, switches the job in its own way, and answers with its
+     * copy. What makes the harness page's "Its own jobs" group worth drawing.
+     */
+    readonly jobs: "jobs";
+};
+/**
+ * How long a room waits for a fork's copy (ADR 0087, Fork): a copy registered within it joins the
+ * room the person asked for; after it the room says the harness didn't make the copy, and one
+ * registered later is free, for a person to put in a room. The clients time it from the ask, as
+ * the server does, so nothing about the wait is stored.
+ */
+export declare const FORK_WAIT_MS = 60000;
+/**
+ * How long a room waits for a new agent a person asked a harness for (ADR 0108): the minute a
+ * fork's copy has. One registered within it joins the room; after it the room says the harness
+ * didn't make it, and one registered later is free.
+ */
+export declare const NEW_AGENT_WAIT_MS = 60000;
+export type HarnessCapability = (typeof HARNESS_CAPABILITIES)[keyof typeof HARNESS_CAPABILITIES];
+/**
+ * How long a harness stays restarting without a word from it (ADR 0094): after this the state says
+ * again whatever is true then, and Restart is offered again. The server keeps it; a client that
+ * draws a count reads it from here.
+ */
+export declare const RESTART_WAIT_MS = 180000;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/src/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,oBAAoB;IAC/B;;;;;OAKG;;IAEH;;;;;OAKG;;IAEH;;;;;;;OAOG;;IAEH;;;;;OAKG;;IAEH;;;;;;OAMG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;;;;OAKG;;IAEH;;;;;OAKG;;IAEH;;;;;OAKG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;CAEK,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,YAAY,QAAS,CAAC;AAEnC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,QAAe,CAAC;AAE9C,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAEjG;;;;GAIG;AACH,eAAO,MAAM,eAAe,SAAU,CAAC"}

package/dist/src/capabilities.js

@@ -0,0 +1,120 @@
+/**
+ * What a harness declares it takes, beyond the events it sends.
+ *
+ * A harness's manifest carries `capabilities`, "what the harness can do", stored when it is
+ * registered and presented back to it in `hello`. Most entries name tools — `email.send`,
+ * `drive.read` — and are the harness's own business. A few are read by the clients, because
+ * they decide whether a control is drawn at all: a control that cannot keep its promise is
+ * worse than none ([ADR 0046](../../../docs/decisions/0046-a-harness-declares-that-it-takes-the-dial.md)).
+ */
+export const HARNESS_CAPABILITIES = {
+    /**
+     * The harness reads the level and the rules Chips sends it — `hello.autonomy`, `policy.updated`
+     * — and asks accordingly, so the L0–L3 dial on its profile and in its run panel changes
+     * something. A harness on `@chipschat/sdk-ts` does; one with a permission model of its own — per
+     * tool, per connector — does not, and gets no dial.
+     */
+    autonomy: "autonomy",
+    /**
+     * The harness takes a room a person opens and asks it into — `space.created` with `asked_of`
+     * naming it — makes its own thing for it, and claims the room with a key of its own. What makes
+     * the + for a new space worth drawing: a room asked of a harness that does not do this would
+     * wait for an answer that never comes.
+     */
+    newSpaces: "new_spaces",
+    /**
+     * The harness keeps its own side of a room it opened under a key in step with the room: a
+     * person's archive and unarchive here are carried to the thing it keeps for the room, and a
+     * delete (`space.erased`) deletes that thing, or puts it away for its owner when the person
+     * deleting does not own the harness (ADR 0066, ADR 0069). What lets the sheets that ask first
+     * promise so. A harness that does not declare it is not bound by any of that — `moved_by` and
+     * the tombstone are there for it to read — and the sheets promise nothing on its behalf.
+     */
+    followsRooms: "follows_rooms",
+    /**
+     * The harness speaks agents (ADR 0087): it reads `hello.agents` and `for`, and names one of its
+     * agents as the `actor` of what it sends. Until it declares this, everything Chips hands it, on
+     * the socket and over HTTP, is the view it knew before agents: its own agents are its own id,
+     * any other agent a harness, and nothing says `for` (ADR 0087's addendum of 29 September).
+     */
+    agents: "agents",
+    /**
+     * The harness copies one of its agents when a person asks (ADR 0087, Fork): it hears
+     * `agent.fork`, makes a copy that remembers everything the agent did up to then, and registers
+     * it with `forked_from` and the room it was asked for, where Chips puts it. After that the two
+     * remember separately. Fork is offered only for a harness that declares this, because a room
+     * asked for a copy that never comes says so after a minute and nothing more.
+     */
+    forks: "forks",
+    /**
+     * The harness makes a new agent when a person asks for one in a room (ADR 0108): it hears
+     * `agent.asked`, makes an agent that remembers nothing from elsewhere, called what the ask says,
+     * and registers it with `made_for` and the room, where Chips puts it. Only a harness that
+     * declares this is offered on a room's Add page, because a room asked for an agent that never
+     * comes says so after a minute and nothing more.
+     */
+    newAgents: "new_agents",
+    /**
+     * The harness has a restart of its own and runs it when a person asks (ADR 0094): a socket of it
+     * says `restart` in its `hello`, hears the `restart` frame, and runs what the harness keeps for
+     * that — a process restarting itself, or a bridge starting what is behind it again. What makes
+     * Restart worth drawing on its page.
+     */
+    restarts: "restarts",
+    /**
+     * The harness sends Chips a copy of each of its agents' context files and of its own set, keeps
+     * them current, and takes a person's edits (ADR 0134): a socket of it says `context` in its
+     * `hello`, hears `context.edit`, saves the file in its own way, and answers with its copy. What
+     * makes an agent's Context group, and its harness's shared files, worth drawing.
+     */
+    contextFiles: "context_files",
+    /**
+     * The harness sends Chips a copy of each agent's model and effort, what it may run on instead
+     * and the words for each, keeps them current, and takes a person's changes (ADR 0140): a socket
+     * of it says `models` in its `hello`, hears `model.change`, sets the agent's model and effort in
+     * its own way, and answers with its copy. What makes an agent's Model group worth drawing.
+     */
+    models: "models",
+    /**
+     * The harness sends Chips a copy of each agent's heartbeat, the turn it starts on its own every
+     * so often, keeps it current, and takes a person's changes (ADR 0143): a socket of it says
+     * `heartbeats` in its `hello`, hears `heartbeat.change`, switches or times the agent's heartbeat
+     * in its own way, and answers with its copy. What makes an agent's Heartbeat group worth drawing.
+     */
+    heartbeats: "heartbeats",
+    /**
+     * The harness sends Chips a copy of each agent's context window, how full it is and the limit it
+     * compacts itself at, keeps it current, and takes a person's Compact now and new limit (ADR
+     * 0146): a socket of it says `context_windows` in its `hello`, hears `context_window.compact`
+     * and `context_window.change`, does them in its own way, and answers with its copy. What makes
+     * an agent's Context window group worth drawing.
+     */
+    contextWindows: "context_windows",
+    /**
+     * The harness sends Chips a copy of the jobs it runs on its own, outside any space, and posts
+     * each run with what it cost, and takes a person's switch (ADR 0252): a socket of it says `jobs`
+     * in its `hello`, hears `job.change`, switches the job in its own way, and answers with its
+     * copy. What makes the harness page's "Its own jobs" group worth drawing.
+     */
+    jobs: "jobs",
+};
+/**
+ * How long a room waits for a fork's copy (ADR 0087, Fork): a copy registered within it joins the
+ * room the person asked for; after it the room says the harness didn't make the copy, and one
+ * registered later is free, for a person to put in a room. The clients time it from the ask, as
+ * the server does, so nothing about the wait is stored.
+ */
+export const FORK_WAIT_MS = 60_000;
+/**
+ * How long a room waits for a new agent a person asked a harness for (ADR 0108): the minute a
+ * fork's copy has. One registered within it joins the room; after it the room says the harness
+ * didn't make it, and one registered later is free.
+ */
+export const NEW_AGENT_WAIT_MS = FORK_WAIT_MS;
+/**
+ * How long a harness stays restarting without a word from it (ADR 0094): after this the state says
+ * again whatever is true then, and Restart is offered again. The server keeps it; a client that
+ * draws a count reads it from here.
+ */
+export const RESTART_WAIT_MS = 180_000;
+//# sourceMappingURL=capabilities.js.map

package/dist/src/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC;;;;;OAKG;IACH,QAAQ,EAAE,UAAU;IACpB;;;;;OAKG;IACH,SAAS,EAAE,YAAY;IACvB;;;;;;;OAOG;IACH,YAAY,EAAE,eAAe;IAC7B;;;;;OAKG;IACH,MAAM,EAAE,QAAQ;IAChB;;;;;;OAMG;IACH,KAAK,EAAE,OAAO;IACd;;;;;;OAMG;IACH,SAAS,EAAE,YAAY;IACvB;;;;;OAKG;IACH,QAAQ,EAAE,UAAU;IACpB;;;;;OAKG;IACH,YAAY,EAAE,eAAe;IAC7B;;;;;OAKG;IACH,MAAM,EAAE,QAAQ;IAChB;;;;;OAKG;IACH,UAAU,EAAE,YAAY;IACxB;;;;;;OAMG;IACH,cAAc,EAAE,iBAAiB;IACjC;;;;;OAKG;IACH,IAAI,EAAE,MAAM;CACJ,CAAC;AAEX;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC;AAEnC;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,YAAY,CAAC;AAI9C;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAC"}

package/dist/src/checklist.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The connection checklist: which event lights which part of the interface.
+ *
+ * Agent Connect is progressive (blueprint, Connect). The minimum is three events — a run
+ * started, a message, a run completed — and every further event a harness sends earns it
+ * another part of the UI. This list is that promise, written down once: the Harnesses tab lights
+ * a row as the type arrives, and `chips conformance` prints the same rows for an adapter, so the
+ * two cannot say different things about what a harness has earned.
+ */
+export interface ChecklistRow {
+    /** The event types that light this row. The first is the one the row names. */
+    readonly types: readonly string[];
+    readonly label: string;
+    /** What sending it gets you, in the words the unlit row uses: "send X for <gives>". */
+    readonly gives: string;
+}
+/** The rows, in the order the interface upgrades. */
+export declare const CONNECTION_CHECKLIST: readonly ChecklistRow[];
+//# sourceMappingURL=checklist.d.ts.map

package/dist/src/checklist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checklist.d.ts","sourceRoot":"","sources":["../../src/checklist.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,YAAY;IAC3B,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uFAAuF;IACvF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,qDAAqD;AACrD,eAAO,MAAM,oBAAoB,EAAE,SAAS,YAAY,EAUvD,CAAC"}

package/dist/src/checklist.js

@@ -0,0 +1,22 @@
+/**
+ * The connection checklist: which event lights which part of the interface.
+ *
+ * Agent Connect is progressive (blueprint, Connect). The minimum is three events — a run
+ * started, a message, a run completed — and every further event a harness sends earns it
+ * another part of the UI. This list is that promise, written down once: the Harnesses tab lights
+ * a row as the type arrives, and `chips conformance` prints the same rows for an adapter, so the
+ * two cannot say different things about what a harness has earned.
+ */
+/** The rows, in the order the interface upgrades. */
+export const CONNECTION_CHECKLIST = [
+    { types: ["message.post"], label: "Messages", gives: "a bubble in the space" },
+    { types: ["run.started"], label: "Runs", gives: "a status pill and a run panel" },
+    { types: ["step.log"], label: "Steps", gives: "a timeline and a receipt" },
+    { types: ["approval.request"], label: "Approvals", gives: "an approval card in the space" },
+    { types: ["question.ask"], label: "Questions", gives: "a question card with options" },
+    { types: ["context.usage"], label: "Context", gives: "the context ring" },
+    { types: ["usage"], label: "Cost", gives: "the cost meter" },
+    { types: ["run.completed", "run.failed"], label: "Finished", gives: "a summary card" },
+    { types: ["task"], label: "Lanes", gives: "a route card, and a task card where the work goes" },
+];
+//# sourceMappingURL=checklist.js.map

package/dist/src/checklist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checklist.js","sourceRoot":"","sources":["../../src/checklist.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAUH,qDAAqD;AACrD,MAAM,CAAC,MAAM,oBAAoB,GAA4B;IAC3D,EAAE,KAAK,EAAE,CAAC,cAAc,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,uBAAuB,EAAE;IAC9E,EAAE,KAAK,EAAE,CAAC,aAAa,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,+BAA+B,EAAE;IACjF,EAAE,KAAK,EAAE,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,0BAA0B,EAAE;IAC1E,EAAE,KAAK,EAAE,CAAC,kBAAkB,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,+BAA+B,EAAE;IAC3F,EAAE,KAAK,EAAE,CAAC,cAAc,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,8BAA8B,EAAE;IACtF,EAAE,KAAK,EAAE,CAAC,eAAe,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,kBAAkB,EAAE;IACzE,EAAE,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,EAAE;IAC5D,EAAE,KAAK,EAAE,CAAC,eAAe,EAAE,YAAY,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,gBAAgB,EAAE;IACtF,EAAE,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,mDAAmD,EAAE;CAChG,CAAC"}

package/dist/src/commands.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A command an ask carries, read the way a shell would read it (ADR 0239), so that a standing yes
+ * remembers how each part of it starts rather than the whole kind of action. Here, so the server,
+ * the conformance kit's fake and the apps read a command the same way.
+ *
+ * A command is the ask's `input.command`: a string a shell runs, or an array of words a program
+ * runs as given. A string is split into parts at `&&`, `||`, `;`, `|` and new lines outside
+ * quotes, and each part into words, quotes taken off. A command that does more than this reader
+ * can follow is not read at all: a redirection (`>`, `<`), something run inside it (`$(`,
+ * backticks, `$`, parentheses, braces), a part run in the background (`&`), a variable set before
+ * the program (`FOO=1 node`), a comment, or an empty part. Its ask is answered each time.
+ *
+ * Chips still never sees the tool call itself; it reads the words the harness sent in its ask.
+ */
+/** The parts of a command, each as its words; nothing for one this reader can't follow. */
+export type CommandParts = readonly (readonly string[])[];
+/** What a command is, from an ask's input: its string or its words, or nothing. */
+export declare function askedCommand(input: unknown): string | readonly string[] | undefined;
+/** The command's parts, each as its words; nothing for a command this reader can't follow. */
+export declare function commandParts(command: string | readonly string[]): CommandParts | undefined;
+/**
+ * The commands a standing yes is never given for (ADR 0239): they can't be undone, leave the
+ * machine, act as somebody else, or run whatever code or command they are given. A part matches
+ * an entry of one word when its program is that word, and an entry of two when its program is the
+ * first and the second is among its words, wherever it stands (`git -C dir push`).
+ */
+export declare const NEVER_STANDING: readonly (readonly string[])[];
+/** The listed command a part uses, in words (`rm`, `git push`); nothing for one not listed. */
+export declare function neverStanding(parts: CommandParts): string | undefined;
+/** How a part starts, as a standing yes remembers it: its first two words, or its one. */
+export declare function startOf(part: readonly string[]): readonly string[];
+/** Each part's start, once each, in the command's order. */
+export declare function commandStarts(parts: CommandParts): readonly (readonly string[])[];
+/** Whether the part begins with these words, each exactly. */
+export declare function startsWith(part: readonly string[], start: readonly string[]): boolean;
+/**
+ * What a standing yes on this ask would remember, or why there is none: the starts, or that the
+ * command can't be read, or the listed command it uses. Nothing for an ask with no command.
+ */
+export type StandingOffer = {
+    readonly kind: "starts";
+    readonly starts: readonly (readonly string[])[];
+} | {
+    readonly kind: "unreadable";
+} | {
+    readonly kind: "never";
+    readonly command: string;
+};
+export declare function standingOffer(input: unknown): StandingOffer | undefined;
+//# sourceMappingURL=commands.d.ts.map

package/dist/src/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,2FAA2F;AAC3F,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;AAK1D,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,CAYnF;AAED,8FAA8F;AAC9F,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,GAAG,SAAS,CAW1F;AA2HD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EA+CxD,CAAC;AAOF,+FAA+F;AAC/F,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAUrE;AAED,0FAA0F;AAC1F,wBAAgB,OAAO,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,CAElE;AAED,4DAA4D;AAC5D,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAOjF;AAED,8DAA8D;AAC9D,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAErF;AAMD;;;GAGG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAA;CAAE,GAC5E;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;CAAE,GAC/B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,GAAG,SAAS,CAQvE"}