opencode-self-improvement 0.8.5 → 0.8.7

package/README.md

@@ -65,8 +65,10 @@ prompt cache on every message. This one is built the other way around:
   queries (one or two words — a deliberate search) need only one. Injection
   stays quiet on single-word coincidences, which `memory_recall` still
   reaches on the pull path — rare and right beats frequent and maybe.
-- **Hard character budget.** The block is capped at 1200 characters by default
-  (see Options) and trimmed at whole-memory boundaries — never cut mid-sentence.
+- **Hard character budgets.** The relevance block and each contextual pull are
+  capped at 1200 characters by default; the session-start open-threads frontier
+  has its own 3600-character cap (see Options). All are trimmed at whole-memory
+  boundaries — never cut mid-sentence.
 - **Evidence is never injected**, and the standing system digest is two lines.
 - **Receipts, not promises.** The plugin measures your session's actual
   prompt-cache usage (from each turn's `tokens.cache` accounting) and shows it
@@ -263,13 +265,14 @@ the plugin entry in `opencode.json(c)` instead of the plain string:
 
 ```json
 {
-  "plugins": [{ "package": "opencode-self-improvement", "options": { "injectBudget": 1200 } }]
+  "plugins": [{ "package": "opencode-self-improvement", "options": { "injectBudget": 1200, "frontierBudget": 3600 } }]
 }
 ```
 
 | Option | Default | What it does |
 | --- | --- | --- |
-| `injectBudget` | `1200` | Character cap on the injected relevance block, trimmed at whole-memory boundaries. Env fallback: `OPENCODE_MEMORY_INJECT_BUDGET`. |
+| `injectBudget` | `1200` | Character cap on the injected relevance block and each contextual pull; trimmed at whole-memory boundaries. Env fallback: `OPENCODE_MEMORY_INJECT_BUDGET`. |
+| `frontierBudget` | `3 × injectBudget` (`3600` by default) | Character cap on the session-start open-threads block. A thread longer than this budget is not injected and is visibly reported as omitted; raise this option (or `OPENCODE_MEMORY_FRONTIER_BUDGET`) to include longer planning threads. |
 | `autoCapture` | `false` (off) | When on, each session-idle event makes one cheap model pass that proposes memory candidates. Every candidate still goes through the 4-gate write pipeline — capture can never bypass the gates. Off by default: the zero-token install stays zero-token. |
 | `captureModel` | — | `"provider/id"` model used for auto-capture. Required when `autoCapture` is on; a missing or invalid value disables capture with a startup warning. |
 | `captureMax` | `3` | Maximum candidates proposed per idle event. |
@@ -349,15 +352,23 @@ and the tool reports a tally of outcomes per line —
 | `collapsed` | near-duplicate of an existing memory; nothing written |
 | `blocked` | rejected by a gate; reason is in `memory_evidence` |
 | `skipped` | malformed line; never reaches the gates |
-| `downgraded` | `status:"open"` without an export header to vouch for it; imported as settled |
+| `downgraded` | `status:"open"` without an export header to vouch for it, claiming `repo:"global"`, or carrying an unverifiable stamp when the importing session has no repo scope; imported as settled |
 
 The frontier policy matters because an open row is exempt from ref grounding:
 a hand-written JSONL can't hand its rows that free pass (the header is
 friction, not a signature — the real defense is that imported content always
-injects framed as data and marked `[via import]`).
-
-so re-running the same import is a no-op (everything collapses). Copying an
-export to a fresh machine is how you seed a new laptop from an old one.
+injects framed as data and marked `[via import]`). Even with a header, an
+imported open row claiming `repo:"global"` is downgraded, so one file can't add
+an open thread to every repo. Imported `repo` and `repoPath` stamps are honored
+only when they match the importing session's current repo (an explicit
+`repo:"global"` on a settled row is kept); foreign stamps are discarded and the
+row is stamped for the importing repo instead. When there is no current repo
+scope, stamps are kept as they are (dropping them would widen the row to
+global) and a stamped open row is downgraded, since its stamp can't be verified.
+
+So re-running the same import in the same repo is a no-op (everything
+collapses). Copying an export to a fresh machine and importing it from that
+repo is how you seed a new laptop from an old one.
 
 ## Memory at a glance
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-self-improvement",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "Durable memory for opencode: remember facts, decisions, and commands across sessions, plus a one-command per-repo setup (/repo-init).",
   "main": "index.ts",
   "exports": {

package/src/config.ts

@@ -54,6 +54,19 @@ export function injectBudget(): number {
   return 1200;
 }
 
+// Character budget for the session-start open-thread frontier. Kept separate
+// from relevance injection and contextual pulls: planning rows are often much
+// longer, and raising this cap must not raise those per-request surfaces too.
+// Defaults to 3x the effective injection budget.
+export function frontierBudget(baseBudget = injectBudget()): number {
+  const raw = process.env.OPENCODE_MEMORY_FRONTIER_BUDGET;
+  if (raw) {
+    const n = Number.parseInt(raw, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return baseBudget * 3;
+}
+
 // Optional live-graph binary. When present the resolver cross-checks the local
 // source scan against the codebase-memory-mcp file graph; when absent the local
 // scan alone is authoritative (install-from-scratch requirement).

package/src/index.ts

@@ -12,7 +12,7 @@
 // helper modules.
 import type { Cleanup, Plugin } from "@opencode/plugin/promise/plugin";
 import { basename, join } from "node:path";
-import { evidenceDir, injectBudget, memoryRoot, dateStr } from "./config.ts";
+import { evidenceDir, frontierBudget, injectBudget, memoryRoot, dateStr } from "./config.ts";
 import { STATUSES, TYPES } from "./types.ts";
 import {
   clearSuperseded,
@@ -29,6 +29,7 @@ import { runWriteGate, type GateContext, type WriteCandidate } from "./gates.ts"
 import { pruneMemory } from "./prune.ts";
 import { exportMemories, findStaleOpen, importMemories } from "./portable.ts";
 import { listSnapshots, restoreSnapshot } from "./undo.ts";
+import { SESSION_CAP, SessionLru } from "./sessions.ts";
 import { record } from "./evidence.ts";
 import {
   capToBudget,
@@ -177,10 +178,12 @@ const impl = {
     const liveRoot = setupRoot ?? process.cwd();
     setRepoScope(setupRoot ? resolveRepo(setupRoot) : null);
 
-    // Character budget for the epoch-frozen injection block: plugin options
-    // (object form in opencode.json(c)) win, then OPENCODE_MEMORY_INJECT_BUDGET,
-    // then the 1200 default.
+    // Character budgets: relevance injection and contextual pulls share the
+    // existing cap; the session-start frontier has its own larger cap. Plugin
+    // options win over env fallbacks, and the frontier defaults to 3x the
+    // effective injection budget.
     const budget = Number(ctx.options?.injectBudget) || injectBudget();
+    const openBudget = Number(ctx.options?.frontierBudget) || frontierBudget(budget);
 
     // Mirror the /repo-init slash command into opencode's global commands dir
     // (idempotent, write-if-missing). OpenCode 2.x loads `*.md` from
@@ -480,7 +483,7 @@ const impl = {
       editor.add(validated(ExportArgs, {
         name: "memory_export",
         description:
-          "Export active memories as a JSONL file for backup or transfer to another machine. The first line is a metadata header ({_export,version,exportedAt,count}); each later line is one JSON object {ts,type,scope,content,status,tags,issue}. The header is what lets memory_import keep status:\"open\" frontier rows — a hand-written file without it imports such rows as settled. Defaults to <memory-root>/exports/<timestamp>.jsonl; pass `file` to choose the path, `scope` to export one scope. Superseded rows are not exported (history stays in the store).",
+          "Export active memories as a JSONL file for backup or transfer to another machine. The first line is a metadata header ({_export,version,exportedAt,count}); each later line is one JSON object {ts,type,scope,content,status,tags,issue}. The header is what lets memory_import keep repo-scoped status:\"open\" frontier rows — a hand-written file without it imports such rows as settled, as does an imported open row claiming repo:\"global\". Defaults to <memory-root>/exports/<timestamp>.jsonl; pass `file` to choose the path, `scope` to export one scope. Superseded rows are not exported (history stays in the store).",
         options: direct,
         async execute(args): Promise<{ content: string }> {
           const res = await exportMemories({ scope: args.scope, file: args.file });
@@ -491,7 +494,7 @@ const impl = {
       editor.add(validated(ImportArgs, {
         name: "memory_import",
         description:
-          "Import memories from a JSONL export (see memory_export). Every row goes through the same 4-gate write pipeline as memory_remember (tagged `import`, original tags preserved), so duplicates collapse and ungrounded rows are blocked exactly as usual — those are normal tallied outcomes, not errors. Malformed lines are skipped and counted. Frontier policy: status:\"open\" exempts a row from ref grounding, so it is honored ONLY if the file opens with a memory_export header; without one, open rows are downgraded to settled and tallied. Imported content is unverified by construction: injected rows surface a `[via import]` provenance marker.",
+          "Import memories from a JSONL export (see memory_export). Every row goes through the same 4-gate write pipeline as memory_remember (tagged `import`, original tags preserved), so duplicates collapse and ungrounded rows are blocked exactly as usual — those are normal tallied outcomes, not errors. Malformed lines are skipped and counted. Frontier policy: status:\"open\" exempts a row from ref grounding, so it requires a memory_export header and cannot claim global scope; imported repo stamps are kept only when they match the importing session's repo, otherwise the importing repo is stamped. A stamped open row is downgraded when there is no current repo scope to verify it. Imported content is unverified by construction: injected rows surface a `[via import]` provenance marker.",
         options: direct,
         async execute(args): Promise<{ content: string }> {
           try {
@@ -506,7 +509,7 @@ const impl = {
                 `Imported ${args.file}: ${t.promoted} promoted, ${t.collapsed} duplicates collapsed, ` +
                 `${t.blocked} blocked by the gate, ${t.skipped} malformed lines skipped.` +
                 (t.downgraded
-                  ? ` ${t.downgraded} open rows downgraded to settled (file has no memory_export header).`
+                  ? ` ${t.downgraded} open rows downgraded to settled (missing eligible memory_export header or verifiable repo scope).`
                   : ""),
             };
           } catch (err) {
@@ -604,13 +607,15 @@ const impl = {
     });
 
     // Per-session frozen injection epochs: the relevance block plus the store
-    // fingerprint it was computed against. Recomputed ONLY on the first prompt
-    // of a session, when injectable rows change, or after a compaction (see the
-    // prompt/context/compaction hooks) — so the system prefix, and with it the
-    // provider prompt cache, survives ordinary requests.
+    // fingerprint it was computed against. Recomputed on the first prompt of a
+    // tracked session, when injectable rows change, or after a compaction (see
+    // the prompt/context/compaction hooks) — so the system prefix, and with it
+    // the provider prompt cache, survives ordinary requests. The shared LRU
+    // below may evict the whole session state; a later prompt starts it fresh.
     const epoch = new Map<string, { version: string; block: string; at: string; reason: "first" | "store_changed" }>();
-    // Latest user prompt per session. A changed store is re-scored against it
-    // even when the change happened during a tool loop with no new prompt.
+    // Latest user prompt per tracked session. A changed store is re-scored
+    // against it even when the change happened during a tool loop with no new
+    // prompt. It is evicted together with the epoch and session ledgers.
     const latestPrompt = new Map<string, string>();
     // Recomputes since server start: every one invalidated a prompt cache, so
     // it is the honest cost number the surfaces show (status files / tools).
@@ -622,6 +627,13 @@ const impl = {
     // (memory_status, in-process).
     const sessionStats = new Map<string, SessionStats>();
     const measuredTurns = new Map<string, Measured>();
+    // Every map above is keyed by session and dropped together on eviction.
+    const sessions = new SessionLru(SESSION_CAP, (sid) => {
+      epoch.delete(sid);
+      latestPrompt.delete(sid);
+      sessionStats.delete(sid);
+      measuredTurns.delete(sid);
+    });
     const statsFor = (sid: string): SessionStats => {
       let st = sessionStats.get(sid);
       if (!st) {
@@ -724,7 +736,7 @@ const impl = {
         setCurrent(input);
         const out = { output: resultText(event?.result), metadata: resultMeta(event?.result) };
         await afterTool(input, out);
-        await contextualPull(input, out as { output?: unknown });
+        await contextualPull(input, out as { output?: unknown }, budget);
         // Write a contextual-pull append back when the tool result is text we own.
         if (event?.result && typeof event.result === "object" && typeof event.result.content === "string") {
           const text = resultText(event.result);
@@ -739,10 +751,15 @@ const impl = {
         // Route store reads in this hook through the right session's scope.
         setCurrent({ sessionID: event?.sessionID });
         const sid = event?.sessionID;
+        if (typeof sid === "string") sessions.touch(sid);
         const mems = await injectableRows();
         if (typeof sid === "string") await refreshEpoch(sid, mems);
         const parts: string[] = [];
-        await systemDigest({ sessionID: event?.sessionID }, { system: parts }, mems);
+        await systemDigest(
+          { sessionID: event?.sessionID },
+          { system: parts },
+          { rows: mems, frontierBudget: openBudget },
+        );
         for (const text of parts) event?.system?.push?.({ type: "text", text });
         // Deliver this epoch's relevance-ranked memory via the system channel.
         // The UI never renders system parts, unlike appended prompt text.
@@ -773,6 +790,7 @@ const impl = {
         setCurrent({ sessionID: event?.sessionID });
         const sid = event?.sessionID;
         if (typeof sid === "string") {
+          sessions.touch(sid);
           markTurn(sid);
           await checkNewSession(sid);
           await bindSessionFromMessages(sid);
@@ -839,6 +857,7 @@ const impl = {
             const sid = info.sessionID;
             const t = info.tokens;
             if (typeof sid !== "string" || !t) continue;
+            sessions.touch(sid);
             measuredTurns.set(sid, {
               at: new Date().toISOString(),
               input: Number(t.input) || 0,

package/src/inject.ts

@@ -8,7 +8,7 @@
 import { createHash } from "node:crypto";
 import { isActive, loadAll, visibleHere, type Memory } from "./memory.ts";
 import { record } from "./evidence.ts";
-import { dateStr } from "./config.ts";
+import { dateStr, frontierBudget, injectBudget } from "./config.ts";
 import { bracketList } from "./logfmt.ts";
 import { recentConvergenceSummary } from "./triggers.ts";
 import { flattenMemoryText } from "./sanitize.ts";
@@ -135,17 +135,63 @@ function openRank(m: Memory): number {
 }
 
 // Only the newest open threads are surfaced, and each session sees the block
-// once (per process), so the frontier costs a bounded number of tokens.
+// once (per process). Rows can be long (up to the content cap), so the block is
+// also held to its own frontierBudget, with any omission shown in the block.
 const OPEN_THREAD_LIMIT = 3;
 const frontierInjectedSessions = new Set<string>();
 
+function omittedLine(count: number): string {
+  return `+ ${count} open ${count === 1 ? "thread" : "threads"} omitted: over budget`;
+}
+
+function cappedFrontier(open: Memory[], budget: number): {
+  block: string;
+  shown: Memory[];
+  omitted: number;
+} {
+  const header = `## Open threads (frontier)${FRAME}`;
+  const rendered = open.map(formatMemory);
+  const full = [header, ...rendered].join("\n");
+  if (full.length <= budget) return { block: full, shown: open, omitted: 0 };
+
+  // Keep a strict newest-first prefix. Budget the omission marker alongside
+  // each candidate row so an older row can never replace a newer one that did
+  // not fit, and the drop is always visible.
+  const kept: string[] = [];
+  let used = header.length;
+  for (let i = 0; i < rendered.length; i++) {
+    const row = rendered[i];
+    if (row === undefined) break;
+    const remaining = rendered.length - i - 1;
+    const marker = remaining ? omittedLine(remaining) : "";
+    const projected = used + 1 + row.length + (marker ? 1 + marker.length : 0);
+    if (projected > budget) break;
+    kept.push(row);
+    used += 1 + row.length;
+  }
+
+  const omitted = open.length - kept.length;
+  const lines = [header, ...kept];
+  if (omitted) lines.push(omittedLine(omitted));
+  // The header plus omission marker is the minimum useful diagnostic. For a
+  // tiny budget that cannot hold even those two lines, emit them anyway rather
+  // than silently making an existing frontier disappear.
+  return { block: lines.join("\n"), shown: open.slice(0, kept.length), omitted };
+}
+
+export interface DigestOptions {
+  // Rows the caller already loaded for this request (shared with the epoch).
+  rows?: Memory[];
+  frontierBudget?: number;
+}
+
 export async function systemDigest(
   _input: unknown,
   output: TransformOutput,
-  rows?: Memory[],
+  opts: DigestOptions = {},
 ): Promise<void> {
   // Repo-scoped: model-facing reads see this repo + global rows.
-  const mems = rows ?? visibleHere((await loadAll()).filter(isActive));
+  const mems = opts.rows ?? visibleHere((await loadAll()).filter(isActive));
   if (!mems.length) return;
   const latest = flattenMemoryText(mems.map((m) => m.ts).sort().pop() ?? "?");
   output.system.push(
@@ -160,9 +206,8 @@ export async function systemDigest(
     .slice(0, OPEN_THREAD_LIMIT);
   if (!open.length) return;
 
-  output.system.push(
-    `\n## Open threads (frontier)${FRAME}\n` + open.map(formatMemory).join("\n"),
-  );
+  const frontier = cappedFrontier(open, opts.frontierBudget ?? frontierBudget());
+  output.system.push(`\n${frontier.block}`);
 
   // Aggregate of past sessions' convergence (one line, gated on data existing;
   // I3: it is a derived fact, never the raw log). Gives the next session the
@@ -183,8 +228,10 @@ export async function systemDigest(
     "frontier_injected",
     {
       session: sid,
-      scopes: bracketList([...new Set(open.map((m) => flattenMemoryText(m.scope)))]),
-      shown: open.length,
+      scopes: bracketList([...new Set(frontier.shown.map((m) => flattenMemoryText(m.scope)))]),
+      shown: frontier.shown.length,
+      omitted: frontier.omitted,
+      ...(frontier.omitted ? { reason: "over_budget" } : {}),
       open_total: openMems.length,
       ts_since: dateStr(),
     },
@@ -274,7 +321,11 @@ export async function compactionAnchor(limit = 12): Promise<string> {
   return capToBudget(block, ANCHOR_BUDGET);
 }
 
-export async function contextualPull(input: PullInput, output: PullOutput): Promise<void> {
+export async function contextualPull(
+  input: PullInput,
+  output: PullOutput,
+  budget = injectBudget(),
+): Promise<void> {
   const tool = typeof input.tool === "string" ? input.tool : "";
   if (!["grep", "glob", "read"].includes(tool)) return;
   const term = argText(input.args);
@@ -283,8 +334,9 @@ export async function contextualPull(input: PullInput, output: PullOutput): Prom
   const mems = visibleHere((await loadAll()).filter(isActive));
   const top = scoreMemories(term, mems, 3);
   if (!top.length) return;
-  const block = top.map(formatMemory).join("\n");
-  if (typeof output.output === "string") {
-    output.output += `\n## Related durable memory (pull)${FRAME}\n${block}`;
+  // Held to the injection budget too: three long rows were ~12 KB per call.
+  const block = capToBudget(`## Related durable memory (pull)${FRAME}\n${top.map(formatMemory).join("\n")}`, budget);
+  if (block && typeof output.output === "string") {
+    output.output += `\n${block}`;
   }
 }

package/src/memory.ts

@@ -139,9 +139,9 @@ export interface AppendMemoryInput {
   issue?: string;
   tags?: string[];
   status?: MemoryStatus;
-  // "global" for explicit cross-project writes; imports carry the row's own
-  // origin stamp (hash survives the machine hop — see repokey.ts). Any other
-  // value is resolved by appendMemory against the live repo scope.
+  // "global" for explicit cross-project writes; imports may carry a validated
+  // same-repo origin stamp (see portable.ts). Any missing value is resolved by
+  // appendMemory against the live repo scope.
   repo?: string;
   repoPath?: string;
 }

package/src/portable.ts

@@ -6,6 +6,8 @@
 import { join } from "node:path";
 import { memoryRoot } from "./config.ts";
 import { isActive, isVisibleHere, loadAll, type Memory } from "./memory.ts";
+import { repoScopeFor } from "./repokey.ts";
+import { getCurrent } from "./state.ts";
 import { TYPES } from "./types.ts";
 import type { WriteCandidate } from "./gates.ts";
 import { flattenMemoryText } from "./sanitize.ts";
@@ -63,8 +65,8 @@ export async function exportMemories(opts: ExportOptions = {}): Promise<ExportRe
       status: m.status,
       tags: m.tags,
       issue: m.issue,
-      // Origin stamps ride along so scoping survives the machine hop (the
-      // repo key is a remote-URL hash; the path is the secondary match).
+      // Origin stamps ride along so a same-repo machine hop can retain them.
+      // Import validates them against its current repo before promotion.
       repo: m.repo,
       repoPath: m.repoPath,
     }),
@@ -80,7 +82,7 @@ export interface ImportTally {
   collapsed: number;
   blocked: number;
   skipped: number;
-  /** Open rows downgraded to settled because the file carried no export header. */
+  /** Open rows downgraded because the file cannot grant that frontier scope. */
   downgraded: number;
 }
 
@@ -141,7 +143,12 @@ function parseRow(line: string): WriteCandidate | null {
 // Frontier policy: status="open" exempts a row from ref grounding
 // at the gate, so it is honored ONLY when the file opens with our export
 // header (version <= ours); otherwise every open row is downgraded to settled
-// and tallied. Only a missing file throws.
+// and tallied. Imported origin stamps are honored only when they match the
+// importing session's current repo (or are an explicit "global"); foreign
+// stamps are removed so the write choke point stamps the importing repo
+// instead. With no current scope, stamps are kept (removing them would widen
+// the row to global) and a stamped open row is downgraded, since its stamp
+// cannot be verified. Only a missing file throws.
 export async function importMemories(
   path: string,
   gate: (c: WriteCandidate) => Promise<{ action: string }>,
@@ -149,6 +156,7 @@ export async function importMemories(
   const file = Bun.file(path);
   if (!(await file.exists())) throw new Error(`import file not found: ${path}`);
   const tally: ImportTally = { promoted: 0, collapsed: 0, blocked: 0, skipped: 0, downgraded: 0 };
+  const currentScope = repoScopeFor(getCurrent().sid);
   let allowFrontier = false;
   let first = true;
   for (const line of (await file.text()).split("\n")) {
@@ -166,7 +174,18 @@ export async function importMemories(
       tally.skipped++;
       continue;
     }
-    if (c.status === "open" && !allowFrontier) {
+    const claimedGlobal = c.repo === "global";
+    const hadStamp = c.repo !== undefined || c.repoPath !== undefined;
+    // A foreign stamp is treated like no stamp, so appendMemory stamps the
+    // importing repo. Explicit "global" is not a foreign repo and is kept (open
+    // global rows are downgraded below). With no current scope there is nothing
+    // to re-stamp with: dropping the stamp would widen the row to global, so it
+    // is kept and only the open-row exemption is withdrawn.
+    if (currentScope && !claimedGlobal) {
+      if (c.repo !== currentScope.key) delete c.repo;
+      if (c.repoPath !== currentScope.path) delete c.repoPath;
+    }
+    if (c.status === "open" && (!allowFrontier || claimedGlobal || (hadStamp && !currentScope))) {
       c.status = "settled";
       tally.downgraded++;
     }

package/src/sessions.ts

@@ -0,0 +1,34 @@
+// Bounded per-session state for a long-lived server. The plugin keeps several
+// session-keyed maps (epoch, latest prompt, stats, measured usage); a resident
+// `opencode serve` would otherwise hold an entry per session it ever saw. One
+// recency list owns eviction so the maps are always dropped together: an
+// evicted session simply starts over (no block until its next prompt, then a
+// "first" epoch), which costs one recompute and never serves stale state.
+// Same cap as repokey.ts's session-scope cache.
+export const SESSION_CAP = 64;
+
+export class SessionLru {
+	private readonly order = new Set<string>();
+	private readonly cap: number;
+	private readonly onEvict: (sid: string) => void;
+
+	constructor(cap: number, onEvict: (sid: string) => void) {
+		this.cap = cap;
+		this.onEvict = onEvict;
+	}
+
+	// Mark a session as just used; evicts the least recently used beyond the cap.
+	touch(sid: string): void {
+		this.order.delete(sid);
+		this.order.add(sid);
+		while (this.order.size > this.cap) {
+			const oldest = this.order.values().next().value as string;
+			this.order.delete(oldest);
+			this.onEvict(oldest);
+		}
+	}
+
+	get size(): number {
+		return this.order.size;
+	}
+}