OthmanAdi/plandeck

git clone https://github.com/OthmanAdi/plandeck

Lineage ------------------------------------------------------------------------------- planning-with-files  —  https://github.com/OthmanAdi/planning-with-files

------------------------------------------------------------------------------- planning-with-files  —  https://github.com/OthmanAdi/planning-with-files Copyright (c) 2026 Ahmad Othman Ammar Adi

planning-with-files  —  https://github.com/OthmanAdi/planning-with-files

npx skills add https://github.com/othmanadi/plandeck --skill plandeck

![License MIT](https://img.shields.io/badge/license-MIT-informational) ![Node >=18](https://img.shields.io/badge/node-%3E%3D18-informational) ![SKILL.md standard](https://img.shields.io/badge/SKILL.md-standard-informational) ![Zero dependen

Plandeck grows out of **planning-with-files** ([OthmanAdi/planning-with-files](https://github.com/OthmanAdi/planning-with-files), MIT), which gave crash-proof markdown plans that survive `/clear` plus a deterministic completion gate. Plande

# 2. Open the URL it prints, e.g. #    http://plandeck.localhost:41747/ship-onboarding-flow/

#    http://plandeck.localhost:41747/ship-onboarding-flow/

- Live board: http://plandeck.localhost:41747/ship-onboarding-flow/

risk: med     depends_on: [C002]     verify: ["curl -f localhost:3000/api/signup -d @test/fixtures/user.json"]

depends_on: [C002]     verify: ["curl -f localhost:3000/api/signup -d @test/fixtures/user.json"]     next_action: "Wire the POST /signup handler to the users table, return 201 with the new id."

verify: ["curl -f localhost:3000/api/signup -d @test/fixtures/user.json"]

Plandeck grows out of **planning-with-files** by [OthmanAdi](https://github.com/OthmanAdi/planning-with-files) (MIT): durable, crash-proof plans on disk and a deterministic completion gate. Everything else, the board server, the YAML reader

- Live board: http://plandeck.localhost:41747/ship-onboarding-flow/

risk: med     depends_on: [C002]     verify: ["npm test -- test/auth/signup.test.ts", "curl -s localhost:3000/api/signup"]

depends_on: [C002]     verify: ["npm test -- test/auth/signup.test.ts", "curl -s localhost:3000/api/signup"]     next_action: "Finish POST /api/signup: hash password, insert user, emit onboarding.started."

verify: ["npm test -- test/auth/signup.test.ts", "curl -s localhost:3000/api/signup"]

async function boot(){   if(window.__PLANDECK_STATIC__){render(window.__PLANDECK_STATIC__);setLive(true);return;}   try{const r=await fetch("./api/board",{cache:"no-store"});render(await r.json())}catch(e){}

if(window.__PLANDECK_STATIC__){render(window.__PLANDECK_STATIC__);setLive(true);return;}   try{const r=await fetch("./api/board",{cache:"no-store"});render(await r.json())}catch(e){}   connect();

try{const r=await fetch("./api/board",{cache:"no-store"});render(await r.json())}catch(e){}

<svg width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="Plandeck">

Executable file

"repository": {     "type": "git",     "url": "git+https://github.com/OthmanAdi/plandeck.git"

"type": "git",     "url": "git+https://github.com/OthmanAdi/plandeck.git"   },

"url": "git+https://github.com/OthmanAdi/plandeck.git"

},   "homepage": "https://github.com/OthmanAdi/plandeck#readme",   "bugs": "https://github.com/OthmanAdi/plandeck/issues",

"homepage": "https://github.com/OthmanAdi/plandeck#readme",

"bugs": "https://github.com/OthmanAdi/plandeck/issues",

Executable file

const timer = setTimeout(() => controller.abort(), 1000);   try {     const target = `http://${urlHost(connectHost(host))}:${port}/api/boards`;

try {     const target = `http://${urlHost(connectHost(host))}:${port}/api/boards`;     const handshake = await fetch(target, { signal: controller.signal });

const target = `http://${urlHost(connectHost(host))}:${port}/api/boards`;     const handshake = await fetch(target, { signal: controller.signal });     if (handshake.status !== 200) return null;

const handshake = await fetch(target, { signal: controller.signal });

const state = await handshake.json();     if (!state || state.hub !== true) return null;     const response = await fetch(target, {

if (!state || state.hub !== true) return null;     const response = await fetch(target, {       method: "POST",

const response = await fetch(target, {

try {     const origin = new URL(summary.url).origin;     await fetch(`${origin}/api/boards?path=${encodeURIComponent(summary.boardPath)}`, { method: "DELETE" });

const origin = new URL(summary.url).origin;     await fetch(`${origin}/api/boards?path=${encodeURIComponent(summary.boardPath)}`, { method: "DELETE" });   } catch {

await fetch(`${origin}/api/boards?path=${encodeURIComponent(summary.boardPath)}`, { method: "DELETE" });

async function handleRequest(hub, req, res) {   const requestUrl = new URL(req.url || "/", `http://${BIND_HOST}`);

const requestUrl = new URL(req.url || "/", `http://${BIND_HOST}`);

function hubOrigin(hub) {   return `http://${urlHost(hub.publicHost)}:${hub.port}`;

return `http://${urlHost(hub.publicHost)}:${hub.port}`;

Executable file

#!/usr/bin/env node

atomicWriteFile(dest, nextMarkdown(       payload,       `http://plandeck.localhost:${PORT}/${payload.plan.slug}/`,

payload,       `http://plandeck.localhost:${PORT}/${payload.plan.slug}/`,       recentForNext(root, 5),

`http://plandeck.localhost:${PORT}/${payload.plan.slug}/`,

Executable file

Executable file

Executable file

Executable file

Executable file

Executable file

async function boot(){   if(window.__PLANDECK_STATIC__){render(window.__PLANDECK_STATIC__);setLive(true);return;}   try{const r=await fetch("./api/board",{cache:"no-store"});render(await r.json())}catch(e){}

if(window.__PLANDECK_STATIC__){render(window.__PLANDECK_STATIC__);setLive(true);return;}   try{const r=await fetch("./api/board",{cache:"no-store"});render(await r.json())}catch(e){}   connect();

try{const r=await fetch("./api/board",{cache:"no-store"});render(await r.json())}catch(e){}

Executable file

#!/usr/bin/env node

Executable file

Executable file

const base = "http://127.0.0.1:" + hub.port;     const state = await fetch(base + "/api/boards").then((response) => response.json());

const state = await fetch(base + "/api/boards").then((response) => response.json());

const secondPayload = await fetch(base + "/x-2/api/board").then((response) => response.json());

const index = await fetch(base + "/").then((response) => response.text());

const wrongType = await fetch(base + "/api/boards", {

const removed = await fetch(base + "/api/boards?path=" + encodeURIComponent("/x-2/"), {

});     assert.equal(removed.status, 200);     const afterDelete = await fetch(base + "/api/boards").then((response) => response.json());

assert.equal(removed.status, 200);     const afterDelete = await fetch(base + "/api/boards").then((response) => response.json());     assert.deepEqual(afterDelete.boards.map((board) => board.boardPath), ["/x/"]);

const afterDelete = await fetch(base + "/api/boards").then((response) => response.json());

unlinkSync(join(firstDir, "plan.yaml"));     await waitFor(async () => {       const current = await fetch(base + "/api/boards").then((response) => response.json());

await waitFor(async () => {       const current = await fetch(base + "/api/boards").then((response) => response.json());       return current.boards.length === 0;

const current = await fetch(base + "/api/boards").then((response) => response.json());

const unknown = await fetch(base + "/not-a-board");

const state = await fetch(`http://127.0.0.1:${hub.port}/api/boards`).then((response) => response.json());

});     hub = await quietly(() => runBoard({ planDir: root, port: 0, host: "127.0.0.1" }));     const base = `http://127.0.0.1:${hub.port}`;

hub = await quietly(() => runBoard({ planDir: root, port: 0, host: "127.0.0.1" }));     const base = `http://127.0.0.1:${hub.port}`;     const response = await fetch(base + "/api/boards", {

const base = `http://127.0.0.1:${hub.port}`;     const response = await fetch(base + "/api/boards", {       method: "POST",

const response = await fetch(base + "/api/boards", {

const healthy = await fetch(base + "/api/boards");

unlinkSync(join(root, "cards", "A.md"));     const payload = await waitFor(async () => {       const current = await fetch(boardServer.url + "api/board").then((response) => response.json());

const payload = await waitFor(async () => {       const current = await fetch(boardServer.url + "api/board").then((response) => response.json());       return current.warnings.some((warning) => warning.kind === "missing-note") ? current : n

const current = await fetch(boardServer.url + "api/board").then((response) => response.json());

const state = await fetch(`http://127.0.0.1:${boardServer.port}/api/boards`).then((response) => response.json());

boardServer = await quietly(() => runBoard({ planDir: root, port: 0, host: "127.0.0.1" }));     const endpoint = boardServer.url + "api/board";     const good = await fetch(endpoint).then((response) => response.json());

const endpoint = boardServer.url + "api/board";     const good = await fetch(endpoint).then((response) => response.json());     assert.ok(good.columns.length > 0);

const good = await fetch(endpoint).then((response) => response.json());

writeFileSync(join(root, "plan.yaml"), "version: 1\n plan:\n");     const stale = await waitFor(async () => {       const payload = await fetch(endpoint).then((response) => response.json());

const stale = await waitFor(async () => {       const payload = await fetch(endpoint).then((response) => response.json());       return payload.error ? payload : null;

const payload = await fetch(endpoint).then((response) => response.json());

await new Promise((resolveWait) => setTimeout(resolveWait, 5));     const second = appendJournalEntry(root, { cardId: "A", field: "column", from: "ready", to: "doing", actor: "second" });     const response = await fetch(`${boardServer.url}

const second = appendJournalEntry(root, { cardId: "A", field: "column", from: "ready", to: "doing", actor: "second" });     const response = await fetch(`${boardServer.url}api/journal?since=${encodeURIComponent(second.ts)}&limit=5`);     as

const response = await fetch(`${boardServer.url}api/journal?since=${encodeURIComponent(second.ts)}&limit=5`);

assert.equal(body.entries.length, 1);     assert.deepEqual(body.entries[0], second);     const post = await fetch(`${boardServer.url}api/journal`, { method: "POST" });

assert.deepEqual(body.entries[0], second);     const post = await fetch(`${boardServer.url}api/journal`, { method: "POST" });     assert.equal(post.status, 405);

const post = await fetch(`${boardServer.url}api/journal`, { method: "POST" });

Executable file

Executable file