@vincemakes/kiso-task-ext 0.1.45

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kiso contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# kiso-task-ext
+
+The kiso official task extension: long-horizon working memory (`task_set`),
+the kernel untouched. Stateless — the list's memory is the session event
+log, so it survives kill -9 and compaction.
+
+## How it is loaded
+
+Since 0.1.45 this extension ships **built-in** with the kiso CLI — a fresh
+install starts with it registered (the startup banner lists it), with zero
+disk setup. The same artifact can also be installed as a user-level
+extension: copy `dist/kiso-task.mjs` into `~/.kiso/extensions/` — the
+user-layer loader accepts exactly this shape.
+
+## Configuration
+
+None. No persistent resources.
+
+## Versioning
+
+The version counter is this package's own. It is pinned exactly by the kiso
+CLI it ships with; an extension release reaches CLI users through the next
+CLI release.

package/dist/kiso-task.mjs

@@ -0,0 +1,130 @@
+/**
+ * kiso (foundation) official task extension — ⑥: long-horizon working memory,
+ * kernel untouched.
+ *
+ * task_set is a WHOLE-TABLE REPLACE (the CC whole-table-replace shape): the model
+ * sends the complete current list on every update — one item marked
+ * active/done, the rest carried over verbatim. Idempotent: the same items
+ * in → the same echo out, byte for byte.
+ *
+ * The extension is STATELESS — the list's memory is the SESSION EVENT LOG.
+ * The result (the normalized echo) is a durable tool-result message: it
+ * survives kill -9 (a resume rebuilds the projection from the log) and
+ * /compact (the result is tagged do-not-compact, so the summary layer's
+ * boundary never covers its round — the contrast with Claude Code's
+ * runtime-state checklist, which dies with the process).
+ *
+ * The content contract (the CLI's checklist cell parses this EXACT shape
+ * — keep it stable):
+ *   [task] 3 items — 1 pending, 1 active, 1 done
+ *   [pending] write the plan
+ *   [active] implement the feature
+ *   [done] verify with tests
+ * The first line is a count summary; every item line is
+ * `[<status>] <text>`. Unknown lines never appear — the echo is the
+ * canonical form.
+ */
+
+const MAX_ITEMS = 50;
+const MAX_TEXT = 500;
+const STATUSES = ["pending", "active", "done"];
+
+/** Parse + validate ONE call. Pure: same input, same echo. */
+export function parseTaskSet(input) {
+  const raw = (input ?? {}).items;
+  if (!Array.isArray(raw)) {
+    return { error: "task_set: 'items' must be an array of {text, status}" };
+  }
+  if (raw.length > MAX_ITEMS) {
+    return { error: `task_set: at most ${MAX_ITEMS} items (got ${raw.length})` };
+  }
+  const items = [];
+  for (let i = 0; i < raw.length; i += 1) {
+    const item = raw[i];
+    if (typeof item !== "object" || item === null) {
+      return { error: `task_set: item ${i} is not an object` };
+    }
+    const status = item.status;
+    if (!STATUSES.includes(status)) {
+      return { error: `task_set: item ${i} status must be one of ${STATUSES.join("/")} (got "${String(status)}")` };
+    }
+    const text = typeof item.text === "string" ? item.text.trim() : "";
+    if (text === "") {
+      return { error: `task_set: item ${i} text must be a non-empty string` };
+    }
+    if (text.length > MAX_TEXT) {
+      return { error: `task_set: item ${i} text exceeds ${MAX_TEXT} chars (got ${text.length})` };
+    }
+    items.push({ text, status });
+  }
+  // CC's discipline: at most ONE active item — a second active means the
+  // model did not mark the previous step done. Refused loudly, never
+  // silently normalized.
+  const active = items.filter((it) => it.status === "active");
+  if (active.length > 1) {
+    return { error: `task_set: at most one active item (${active.length} are active — mark the others done first)` };
+  }
+  return { items };
+}
+
+/** The normalized echo — the deterministic, parseable canonical form. */
+export function taskEcho(items) {
+  const counts = { pending: 0, active: 0, done: 0 };
+  for (const it of items) counts[it.status] += 1;
+  const lines = [
+    `[task] ${items.length} item${items.length === 1 ? "" : "s"} — ${counts.pending} pending, ${counts.active} active, ${counts.done} done`,
+    ...items.map((it) => `[${it.status}] ${it.text}`),
+  ];
+  return lines.join("\n");
+}
+
+export default function createTaskExtension() {
+  return {
+    name: "task",
+    tools: [
+      {
+        name: "task_set",
+        description:
+          "set the work plan as a whole-table replace: pass the COMPLETE current list (each item {text, status}) — at most one active. The result echoes the normalized list; it survives /compact and kill -9 (durable working memory).",
+        parameters: {
+          type: "object",
+          properties: {
+            items: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  text: { type: "string", minLength: 1, maxLength: MAX_TEXT },
+                  status: { type: "string", enum: STATUSES },
+                },
+                required: ["text", "status"],
+              },
+              maxItems: MAX_ITEMS,
+            },
+          },
+          required: ["items"],
+        },
+        execute: async (input) => {
+          const parsed = parseTaskSet(input);
+          if (parsed.error !== undefined) {
+            return { content: parsed.error, isError: true, errorKind: "invalid_input" };
+          }
+          return { content: taskEcho(parsed.items), isError: false, tags: ["do-not-compact"] };
+        },
+      },
+    ],
+    // The plan guidance — restrained, no runtime checks (a verification
+    // step is a discipline, not a gate).
+    systemPrompt: {
+      append: [
+        "Work planning (task_set):",
+        "- For a task with 3+ steps, call task_set once up front with one item",
+        "  per step, and make the LAST item a verification step.",
+        "- Mark an item active just before you start it — at most one active.",
+        "- Mark an item done the moment its step completes, then call",
+        "  task_set again with the whole updated list.",
+        "- For a single small step, skip the list and do the work directly.",
+      ].join("\n"),
+    },
+  };
+}

package/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The published type surface of @vincemakes/kiso-task-ext: the default
+ * export is the FACTORY (the same contract the user-layer disk loader
+ * accepts — a KisoExtension or a factory returning one). The type import
+ * from kiso-core is compile-time only — the shipped bundle is
+ * self-contained, zero runtime dependencies.
+ */
+import type { KisoExtension } from "@vincemakes/kiso-core";
+
+declare const createTaskExtension: () => KisoExtension | Promise<KisoExtension>;
+export default createTaskExtension;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@vincemakes/kiso-task-ext",
+  "version": "0.1.45",
+  "description": "kiso official task extension \u2014 long-horizon working memory (task_set), kernel untouched",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/kiso-task.mjs",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./dist/kiso-task.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node build.mjs",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@vincemakes/kiso-core": "0.1.35",
+    "@types/node": "^26.1.2",
+    "typescript": "^5.7.2",
+    "vitest": "^3.0.0"
+  }
+}