diff --git a/research/08-competitive-analysis.md b/research/08-competitive-analysis.md new file mode 100644 index 0000000..e84ec90 --- /dev/null +++ b/research/08-competitive-analysis.md @@ -0,0 +1,152 @@ +# Competitive Analysis — The Direct Set + +This is the first item of the narrow pass: the positioning, pricing, feature, and traction study of the direct competitive set named at the end of [01-market-overview.md](01-market-overview.md). It profiles each competitor as it stands today, builds the cross-cutting matrices, and closes with the strategic read — what changed since the broad pass, where the differentiation actually is, and what it implies for positioning and launch. Sources are cited inline on load-bearing claims; facts are snapshots of the research date. + +Researched: 2026-08-07 + +## The headline reads + +Five things changed or sharpened since the 2026-08-01 broad pass. + +1. **The whitespace is confirmed, and narrower claims survive scrutiny.** A Mac App Store field check found every sampled native kanban app (Sprout, Kanba, Boards, and company) storing data in an opaque database or app container, with at most a manual JSON/PDF export. Nothing offers user-legible files as live source of truth, let alone one file per card. "No polished native Mac kanban app uses files the user can read as its source of truth" holds as a checkable fact, not a marketing claim. +2. **Signboard is smaller than the broad pass implied.** The closest philosophical competitor is a solo side project: 85 GitHub stars, roughly 750 direct installer downloads over six months, an active install base in the low hundreds by auto-updater telemetry, no community, no launch, no press beyond a blog roundup. It ships monthly and its feature direction is exactly Lanework's axes (MCP, CLI, Obsidian, local AI), but as a business threat it is currently negligible — and as a *demand* signal it is sobering (see read 5). +3. **Obsidian Bases' native kanban view is now the top external threat, and it is imminent.** The legacy Kanban plugin is formally abandoned (unmaintained since May 2024, 2.4M downloads, 592 open issues, maintainer publicly seeking successors), and a native "Display files in side-by-side kanban boards" view is the single **Active** item on Obsidian's official roadmap as of August 2026 ([obsidian.md/roadmap](https://obsidian.md/roadmap/)). When it ships, "markdown kanban" as a phrase commoditizes inside the largest file-based audience. +4. **The agent-board cluster commoditized and split, and its GUI branch is not a task-management competitor.** Vibe Kanban's company (Bloop) shut down in April 2026 — 27.7k stars, "the vast majority are free users," no viable business model ([vibekanban.com/blog/shutdown](https://www.vibekanban.com/blog/shutdown)); Conductor raised a $22M Series A and monetizes cloud compute for engineering teams; Cursor and Cline shipped their own boards; OpenAI open-sourced Symphony as a spec rather than a product. All of it is *session orchestration* — cards are agent runs bound to worktrees and PRs, state is app-owned, and none of it manages tasks a human authors. Adjacent, validating, not direct. +5. **The demand is provably in the developer channel, and the pure-product players all have near-zero traction.** Beads (~26k stars, 650k downloads) refuses to build a GUI, and its community keeps building board viewers over it anyway — a running proof that people want a human surface over agent-legible task state. Backlog.md (6.4k stars) is actively building that surface, web-first. Meanwhile every *paid product* in the file-based kanban niche — Signboard, Kanbanero, FileBoard, Sprout, Kanban MD — has effectively zero measurable users. The demand signal at scale lives entirely in GitHub/HN channels; the Mac-indie channel has so far bought none of this. That is the strongest answer yet to the broad pass's audience-funnel question, and it points the launch strategy firmly at the developer channel first. + +## Tier 1 — direct competitors + +### Signboard + +The philosophical twin: local-first kanban writing Markdown files, tagline "Open source. Local-first. No account. … private, portable, and agent ready" ([cdevroe.com/signboard](https://cdevroe.com/signboard/)). + +- **What it is:** Electron (deliberately framework-free vanilla JS), macOS/Windows/Linux, distributed via GitHub Releases only — notarized but outside the App Store, so first launch hits the Gatekeeper malware warning ([issue #39](https://github.com/cdevroe/signboard/issues/39)). +- **Business:** solo side project of Colin Devroe (day job at NerdPress), MIT-licensed, free for personal use, $49 one-time honor-system "sponsorship" for commercial use, tip jar. Bootstrapped, team of one. +- **Activity:** monthly releases, v1.0 March 2026 → v1.6 July 2026. Shipped in that span: Trello/Obsidian/Tasks.md import, a Planner workspace (calendar/week/day/agenda), Table view with filtering and bulk actions, linked objects, an Obsidian community plugin, a published calendar feed, and "Smart Actions" — off-by-default local-LLM automation via Ollama (title/summary/task-list/label/due-date generation, card Q&A) ([releases](https://github.com/cdevroe/signboard/releases)). +- **Agent story:** built-in MCP server with board allowlisting plus a standalone CLI with JSON output; markets to "Claude, Codex, Gemini, OpenCode or any agent." +- **Traction:** 85 stars, 9 forks, ~750 direct installer downloads across six months of releases, auto-updater pings suggesting an active base in the low hundreds. No Discord, no subreddit, no Show HN, no Product Hunt — growth is the developer's blog and word of mouth. +- **Weaknesses:** Electron; Gatekeeper friction; **no manual card ordering within a list** (open request as of July 2026, [issue #46](https://github.com/cdevroe/signboard/issues/46)); renaming or moving a board's folder breaks board switching ([issue #27](https://github.com/cdevroe/signboard/issues/27)); CLI-created cards invisible to the Obsidian plugin ([issue #47](https://github.com/cdevroe/signboard/issues/47)); linked objects only — no real attachment model; no first-party sync stance beyond "it's files." +- **Read:** the schema comparison ([07](07-schema-comparison-signboard.md)) already established the structural differentiation; this pass establishes the *scale* difference. Signboard's feature velocity is real and its positioning language is nearly Lanework's own, so it defines the messaging territory Lanework must beat on execution — native speed, ordering that works, attachments, rename-safety, a board model with rigor. Its traction failure despite a year of shipping is a distribution lesson, not proof of no demand: it never launched anywhere. + +### Backlog.md + +The most serious dual-audience trajectory in the set: "Trello or a lightweight Jira that lives right in your repo," for humans *and* agents ([github.com/MrLesk/Backlog.md](https://github.com/MrLesk/Backlog.md)). + +- **What it is:** MIT, Bun/TypeScript, tasks as Markdown files with YAML frontmatter in a `backlog/` directory inside a git repo. Three surfaces: CLI, terminal kanban, and a localhost web UI with drag-and-drop. +- **Agent story:** first-party MCP server with workflow resource URIs; explicit three-checkpoint human-review workflow (spec, plan, code) before an agent implements. +- **Activity:** the standout — 4–5 releases a month through mid-2026, concentrated on the *human* board UI: deep links, task types, custom priorities, label filters, acceptance-criteria counts on cards. +- **Traction:** ~6.4k stars, 254-point HN launch (July 2025), large fork ecosystem, VS Code extension, multiple third-party MCP wrappers. +- **Weaknesses:** web UI, not a native app; scoped to one git repo (a dev-project tool, not a life tool); no real multi-agent concurrency story (sequential "one task = one context window = one PR" by design); community sees it as small-project-scale. +- **Read:** proof that "markdown tasks + polished human board + MCP" wins developer traction when actually launched. It competes for Lanework's developer buyer inside repos; it does not compete for boards as documents, native experience, or anything beyond code projects. Watch its web UI polish — it is the yardstick for "good enough" in the dev channel. + +### Tasks.md + +The demand-proof incumbent of folder-as-board: lanes are folders, cards are Markdown files, self-hosted web app ([github.com/BaldissaraMatheus/Tasks.md](https://github.com/BaldissaraMatheus/Tasks.md)). + +- **Traction:** 2.2k stars, 100K+ Docker pulls, listed across self-hosting directories — by far the most-adopted pure folder-as-board tool. +- **Activity:** tapering — multiple releases a month through late 2025, then a single 2026 release (v3.3.0, March, i18n) and nothing in the five months since. README states scope is "purposefully kept narrow." +- **Weaknesses:** requires a self-hosted Docker container; recurring open issues around lane/file rename propagation, image upload failures, silent backend-unreachable failures; **no API, no MCP, no agent story at all**. +- **Read:** unchanged from the broad pass as a demand signal, sharpened as a competitor: it serves the self-hoster who will run a container, and it has left the agent axis completely unclaimed. Its 100K pulls against Signboard's hundreds of installs also says the *free self-host* channel dwarfs the *download-an-app* channel in this niche today. + +### Obsidian — the Kanban plugin's corpse and the Bases trajectory + +- **The plugin:** 2.4M downloads and functionally dead — last real release May 2024, repo moved to a community-archive org, MAINTAINERS.md openly soliciting successors, 592 open issues, "is this maintained?" threads unanswered ([github.com/community-archive/obsidian-kanban](https://github.com/community-archive/obsidian-kanban)). +- **Bases:** four official views today (Table, List, Cards, Map); **Kanban is the current Active roadmap item** ("Display files in side-by-side kanban boards"), with community Bases-kanban plugins already filling the gap ([obsidian.md/roadmap](https://obsidian.md/roadmap/), [forum thread](https://forum.obsidian.md/t/bases-kanban-view/101593)). +- **Agent story:** app-mediated, not file-direct — the official CLI (GA Feb 2026) remote-controls a *running* Obsidian instance, and the dominant Local REST API + MCP plugin (591K downloads) also requires the app open. Pure-disk access falls back to generic filesystem tools with no board semantics. +- **Read:** when Bases kanban ships, the largest file-based audience gets a first-party markdown board, and "kanban over markdown files" stops being a differentiator *as a phrase*. What Bases will not be: a board as a self-contained portable document (it is a view over vault-wide note queries), agent-legible without Obsidian running, or a native-feeling board surface. Lanework's messaging should pre-position against it now: boards as documents you can zip and send, agents that need no app and no plugin, and a surface built for the board rather than a view bolted on a vault. + +## Tier 2 — adjacent competitors + +### Beads + +Steve Yegge's agent-memory tracker: ~26.1k stars, 650k downloads claimed, MIT ([github.com/steveyegge/beads](https://github.com/steveyegge/beads)). + +- Migrated *away* from flat files to Dolt (version-controlled SQL) in early 2026 — the substrate bet is now "git-semantics database," explicitly not human-legible markdown. +- Deliberately no first-party GUI, ever; Yegge moved up-stack to Gas City (multi-agent orchestration SDK). The community keeps shipping board viewers over it — TUI kanbans, web boards, a Tauri desktop app, a VS Code board — none with traction, all evidence of the unbuilt human surface. +- Carries real trust baggage: install-script re-signing flagged as bypassing Apple's malware checks ([issue #1857](https://github.com/steveyegge/beads/issues/1857)), "pseudo-malware" discourse on HN, and Yegge's own "crummy architecture" admission. +- **Read:** not a competitor for the human board; a competitor for the *substrate* claim and the loudest demand proof in the space. Lanework's counter-story: the substrate that needs no daemon, no database, and no trust decision — folders and Markdown an agent's existing file tools already speak, with the app as the human surface Beads users keep asking volunteers to build. + +### Vibe Kanban, Conductor, Kanban Code — the agent-session cockpits + +- **Vibe Kanban:** 27.7k stars, SQLite-backed board over git worktrees, broadest agent support — and a dead company (Bloop shut down April 2026; community-maintained, Apache-2.0). Its post-mortem is the niche's clearest business-model datum: free OSS orchestration couldn't monetize. +- **Conductor:** native Mac agent cockpit from Melty Labs, $22M Series A (March 2026), 2–3-day release cadence, free local tier with $50/mo cloud, enterprise logos (Google, Meta, Amazon among cited users). Workspace-centric — no general task management at all. GitHub-clone-only flow and a full-account OAuth-permissions controversy are its friction points. +- **Kanban Code:** LangWatch's AGPLv3 native SwiftUI app (macOS 26 only), 303 stars, six fixed agent-lifecycle columns, deep session/worktree/tmux/PR binding, JSON-file state. Unnotarized, build-from-source, tiny. +- **New entrants since May:** Cursor's agent-kanban SDK example, Cline Kanban, a half-dozen smaller clones; OpenAI's Symphony released as an open spec (April 2026) that OpenAI explicitly will not productize. +- **Read:** the cluster validates board-as-agent-control-plane and simultaneously demonstrates it is a different product: cards are *runs*, not tasks; state is app-owned; the human is a reviewer, not a planner. The overlap with Lanework is one buyer persona (the developer running agents) at a different moment of their day. The risk is vocabulary collision — "kanban for agents" now means these — so Lanework's language should stay "your board is files agents can work" rather than "orchestrate agents from a board." + +## Tier 3 — the native-Mac field (positioning foil) + +- **Sprout:** CoreData + iCloud, subscription-first ($0.99/mo / $9.99/yr with a lifetime IAP muddle across channels), macOS 15+, launched Dec 2025, 16 Product Hunt upvotes, too few MAS ratings to display. Positioning is "quiet native kanban"; storage is opaque; traction is negligible. +- **Kanbanero:** $8.99 one-time, native, whole board as a single YAML/JSON file (not per-card files), no markdown/search/images, ~14 months without an update, zero visible traction. +- **FileBoard:** $0.99 lifetime IAP, genuinely folder=column/file=card — but over arbitrary files as a Finder-view utility, with no card authoring, no task semantics, brand-new, unrated. +- **banban / Kanban MD:** effectively out of scope on inspection — banban is SQLite-backed (not file-based at all), unlicensed, and a year dormant; Kanban MD is Linux-only, one Markdown file per whole board, explicitly unsupported by its author. +- **MAS "kanban" field:** Kanba (free + IAP, 4.8★/20 ratings), Boards – Personal Taskboards (`.board` ZIP archives, stale since Jan 2023), sundry $0.99–$4.99 utilities — all opaque storage, all thin. +- **Read:** the native channel contains no credible file-over-app player and no breakout of any kind; its lesson is that nobody has yet given the Mac-indie buyer a *reason* — the wedge that makes files matter to them is agents, which is exactly the story none of these apps can tell. + +## Feature matrix + +Legend: ● yes · ◐ partial · ○ no. Lanework column reflects what has shipped plus Pro's built git core (remotes still ahead). + +| | Lanework | Signboard | Backlog.md | Tasks.md | Beads | Vibe Kanban | Conductor | Obsidian (Bases now) | Sprout | +|---|---|---|---|---|---|---|---|---|---| +| Native Mac app | ● | ○ Electron | ○ web | ○ web | ○ CLI | ○ web | ● | ○ Electron | ● | +| Files as live source of truth | ● | ● | ● | ● | ◐ Dolt db in git | ○ SQLite | ○ | ● | ○ CoreData | +| One file per card | ● | ● | ● | ● | ○ | ○ | ○ | ● (notes) | ○ | +| Byte-faithful to foreign edits | ● | ○ not contractual | ○ | ○ | n/a | n/a | n/a | ◐ | n/a | +| Agent-usable with app closed | ● no tooling needed | ◐ CLI/files | ◐ CLI/files | ◐ files | ● | ○ | ○ | ○ app must run | ○ | +| Written agent contract in-board | ● CLAUDE.md, versioned | ○ | ◐ MCP resources | ○ | ◐ | ○ | ○ | ○ | ○ | +| MCP server | ○ unneeded by design | ● | ● | ○ | ● | ● | ○ | ◐ plugin | ○ | +| Board as portable document | ● folder = board | ◐ | ○ repo-bound | ◐ | ○ | ○ | ○ | ○ vault-bound | ○ | +| Manual card ordering | ● ranks | ○ open request | ● | ● | ○ | ● | n/a | ◐ | ● | +| Attachments model | ● files + Quick Look | ○ links only | ○ | ◐ buggy | ○ | ○ | ○ | ◐ vault files | ○ | +| Git integration in-app | ● Pro: auto-commit, undo-as-commits, branches | ○ | ◐ lives in repo | ○ | ● core model | ◐ worktrees | ● worktrees | ○ | ○ | +| Multi-writer reconciliation | ● provenance ledger | ○ | ○ sequential by design | ○ | ● hash IDs | n/a | n/a | ◐ | n/a | +| Full keyboard operability | ● | ◐ | ◐ | ◐ | ● CLI | ◐ | ◐ | ◐ | ◐ | +| Accessibility (VO, contrast, motion) | ● verified | ◐ claims | ○ unknown | ○ | n/a | ○ | ○ | ◐ | ○ unknown | +| Active development | ● | ● monthly | ● weekly | ◐ tapering | ● | ◐ community | ● | ● | ◐ | + +## Pricing landscape + +| Player | Model | Price | Note | +|---|---|---|---| +| Lanework (planned) | free tier + Pro subscription | Pro unlocks git | one app, complete board experience free | +| Signboard | free + honor-system commercial | $49 one-time, unenforced | MIT source; tip jar | +| Backlog.md / Tasks.md / Beads / Kanban Code | free OSS | — | no monetization anywhere | +| Vibe Kanban | free OSS (+ dead cloud tier) | was $30/user/mo | company folded on this model | +| Conductor | freemium compute | $50/mo Pro, $60/user/mo Teams | monetizes cloud, not the board | +| Sprout | subscription + lifetime IAP | $0.99/mo, $9.99/yr | muddled across channels | +| Kanbanero | one-time | $8.99 | stale, no traction | +| FileBoard | freemium lifetime IAP | $0.99 | utility pricing | +| Obsidian | free + optional services | Sync/Catalyst | the free ceiling once Bases kanban ships | + +Three pricing facts stand out. Nobody in the direct set runs a functioning paid product — the field is free OSS, honor-system, or sub-$10 apps with no users, so there is no established price anchor and no evidence of price resistance either. The one venture-funded board company that stayed free died of it, and the one that charges monetizes compute, not software. And nobody anywhere charges for git-native features — Lanework Pro's "git as the paid tier" has no direct precedent, which cuts both ways: unclaimed ground, unproven willingness to pay. The broad pass's pricing-model question (Agenda hybrid vs Curio dual-track vs Things one-time) remains open and is *not* answered by this field; the closest datum is that subscription-first Sprout has zero traction while pay-once Things thrives, but neither is this niche. + +## Differentiation — where Lanework actually wins + +1. **The only native, polished human surface over per-card files.** Confirmed unique across every ring examined. Everything native is opaque; everything file-based is web, CLI, or Electron. +2. **Agents need zero tooling.** No MCP server to install, no CLI, no app running: the board *is* files, and the in-board versioned `CLAUDE.md` teaches any file-capable agent the schema on arrival. Every competitor's agent story requires their bridge (MCP/CLI) or their app process. This is the sharpest single differentiator and should lead the developer-channel messaging. +3. **Contractual byte-fidelity and multi-writer honesty.** The round-trip guarantee, write-provenance ledger, foreign-edit reconciliation, and mid-drag re-grounding address the exact failure modes competitors demonstrably have (Signboard's rename breakage and CLI/plugin inconsistency, Tasks.md's rename propagation bugs) and the space's acknowledged hard problem (Beads' whole thesis). "Other writers are normal, not exceptional" is an architecture posture nobody else took. +4. **Boards as documents.** A board is a folder you can zip, send, template, and version — not a vault, a repo, or a server. Nobody else in the set has this shape; Bases specifically cannot. +5. **Git as product, not plumbing.** Auto-commit with composed messages and structural authorship, undo-as-forward-commits, per-card history — the agent-era audit trail as a first-class human feature. The cockpits use git as isolation machinery; Beads uses it as transport; nobody surfaces it to a human as legible board history. +6. **Ship the basics the twin is missing.** Manual ordering, a real attachments model, rename-safety, App Store distribution without Gatekeeper friction — table-stakes wins over Signboard that require no strategy, only the existing build. + +## Threats, ranked + +1. **Obsidian Bases kanban (high, imminent).** Commoditizes the phrase and satisfies the casual markdown-board user inside a 2.4M-download demand pool. Mitigation: position on what Bases structurally isn't (document boards, app-free agent access, native surface) and ship before or fast after it lands. +2. **Niche conversion risk (high, structural).** The sobering pattern: every *product* in this niche has near-zero users while every *dev-channel OSS tool* has thousands of stars. Demand exists; paying customers are unproven. Mitigation: launch where the demand demonstrably is (Show HN, the agent-tooling audience), free tier genuinely complete, and treat the Mac-indie channel as a second wave. +3. **Signboard velocity (medium).** One committed builder shipping monthly with the same philosophy and a five-platform surface. Mitigation: out-execute on native quality and schema rigor (the durable moats from doc 07); watch its 1.x cadence for an ordering/attachments catch-up. +4. **Vocabulary collision with the cockpit cluster (medium).** "Kanban + agents" increasingly parses as "run coding agents from a board." Mitigation: language discipline — Lanework manages *work*, agents are first-class *users* of the board, not processes it launches. +5. **Backlog.md expanding out of the repo (low-medium).** If it ships a desktop app or repo-independent boards, it becomes the free developer default. Currently no sign of either. + +## Positioning recommendation + +Hold the line from the charter, now with evidence: **the best human surface over the substrate agents already speak** — a real Mac app for boards that are just folders and Markdown, where anything that reads files is a first-class user and the app never holds the data hostage. Against the cockpits: Lanework is for the work, not the runs. Against Beads/Backlog.md: the human surface they refuse to build or can't make native. Against Bases: boards as documents, no app required for agents. Against Signboard: the same philosophy executed with native speed, schema rigor, and the basics done right. Against Sprout and the MAS field: your data in your files, forever, agent-ready. + +Launch implication, stated plainly: the buyer who *gets it* today reads Hacker News, runs Claude Code, and already keeps markdown in git. The Tasks.md/Beads/Backlog.md star counts are the addressable early market; the Mac-indie channel converts later, once "agents work my board" is a demonstrable trick rather than a pitch. + +## What this pass leaves open + +- Launch case studies with real numbers (HN/PH for file-based task apps) — still unfound; Backlog.md's 254-point launch is the one hard datum and deserves a dedicated tear-down. +- Pricing-model design for Pro — this field gave anchors' absence, not answers; the Agenda/Curio/Things comparison still needs doing on its own terms. +- Superlist's post-merger direction (untouched this pass). +- A Bases-kanban watch item: re-check the Obsidian roadmap monthly; its ship date sets Lanework's messaging clock. diff --git a/research/README.md b/research/README.md index d7fb517..6bec6b8 100644 --- a/research/README.md +++ b/research/README.md @@ -16,6 +16,7 @@ This directory is a living body of work. The first pass (2026-08) is deliberatel Narrow-pass deep dives (per-competitor, added as they happen): - [07-schema-comparison-signboard.md](07-schema-comparison-signboard.md) — Signboard's on-disk format vs Lanework's: definition rigor, identity, ordering, denormalization, and the strategic read +- [08-competitive-analysis.md](08-competitive-analysis.md) — the direct set profiled: features, pricing, traction, tiered profiles, matrices, ranked threats, and the positioning read (2026-08-07) ## Conventions diff --git a/strategy/01-git-excision.md b/strategy/01-git-excision.md new file mode 100644 index 0000000..14d30bc --- /dev/null +++ b/strategy/01-git-excision.md @@ -0,0 +1,106 @@ +# Git Excision — Plan + +This document is the **ruled plan** for removing app-managed git from Lanework entirely. It is the second step beyond the 2026-08-07 pivot recorded in DESIGN/12-editions.md (git left the paywall and went tier-independent); this step retires the git stack itself. The safety-net successor — the foreign-change journal that would reclaim tracking of agent-borne mutations — is **explicitly deferred**, a later decision and not part of this milestone; the harvest step below stays in scope precisely because it keeps that option cheap. + +Researched: 2026-08-07 · Ruled: 2026-08-08 — excise; execute as written + +## Why (the case, compressed) + +The strategic reasoning lives in the 2026-08-07 tier-strategy discussion; the plan only summarizes it. + +- The dividing line for tiers became "your board beyond your Mac" (iPhone + ops-based sync service as Pro); git carries no revenue in that structure. +- Sync no longer needs git rails: the phone was ruled a worktree client speaking semantic ops, and once an ops protocol exists the Mac and server can speak it too. +- The most natural developer usage — a board inside a project repo — was always excluded from app-managed git (nearest-`.git`-wins leaves it alone); those users get history from their own workflow, forever, because the *format* is git-friendly by construction. +- The safety-net value (history of externally delivered changes, e.g. agents) survives via a designated successor: a foreign-change journal built on the write-provenance ledger plus close-time text snapshots — protection by default on every board, no opt-in, no git states. +- What ends is the permanent design tax: every future feature answering "what does this do mid-merge, index-locked, mid-branch-switch?" +- Market evidence (research/08): nobody anywhere successfully charges for git features; the closest competitor thrives with zero git integration; the wedge is files, not git. + +## Reversibility + +- Tag the pre-excision commit `pre-git-excision`. The entire stack — ~8,150 lines in `Kanban/Git/`, ~8,300 lines of tests — remains in history. +- Dependency pins recorded here for resurrection: SwiftGitX `0.4.0`, libgit2 `1.9.2` (both `github.com/ibrahimcetin/…`, declared in `project.yml`). +- The seams the git stack plugged into (`HistoryProviding`, `commitSeam`, `IdentityHistoryRanker`) are all nil-safe/default-native and are **kept**, so a future provider — journal, ops service, or even git again — re-binds without re-plumbing. + +## What is kept (do not over-cut) + +- **`.gitignore` seeding and parsing** — `BoardWriter.gitignoreSeed` / `seedGitignoreIfAbsent`, `Storage/GitignoreRules.swift`. Since 2026-07-31 this is the noise-gate definition for the loose-file heal on *every* board, git or not; the format's git-friendliness promise also keeps it. Tests: `GitignoreRulesTests`, the noise-gate suite in `LooseFileRelocationTests` — untouched. +- **FSEvents watcher `.git` filtering** — `FolderWatcher`'s `.git` exclusion. Boards living inside user repos remain first-class; the watcher must keep ignoring their churn. Tests in `FolderWatcherTests` — untouched. +- **The write-provenance ledger** — `EchoLedger` runs identically with the announcer as its only consumer (02-architecture.md already states this posture for no-git boards); it is the foundation of the successor journal. The macOS-gated harvest surface (`HarvestedReceipt`) stays; only its git consumer (`CommitAttribution.swift`) goes. +- **Native undo, whole** — `Kanban/History/` becomes the only substrate: `HistoryProviding`, `NativeHistoryProvider`, `BoardUndoManager`, `CardWindowUndo`, staleness re-checks, phrase vocabulary. `HistoryProviderTests` (968 lines) untouched. The protocol seam is retained deliberately (see Reversibility). +- **Duplicate-id repair** — the ladder's `historyRank` rung is nil-safe by design; with the ranker gone, the birth-date rung is the top rung, exactly today's no-git behavior. Only the two git-rung tests in `DuplicateIdentityTests` go. +- **Tier/StoreKit machinery** — already dormant and structurally separate since the pivot (`Tier`, `ProEntitlement`, `ProSettingsSection` unrendered, `TierTests` git-free). Zero changes; it waits for the phone/sync split. The one git-referencing marketing string in `ProSettingsSection` gets rewritten whenever Pro re-surfaces, not now. +- **The Sync tab placeholder** — `BoardSyncTabView` keeps its claimed position in the popover; its annotation changes from "the remote half of the git story" to the future ops-based sync service. +- **The network-client entitlement** — stays dormant; the future sync service needs it regardless. +- **`UndoProbe`** — provider-agnostic diagnostic, keeps working over the native provider alone. +- **The agent guide mechanism** — `AgentGuide.swift` stays; only its `## Git` prose changes (step 6). + +## What is harvested before deletion + +**The semantic message composer becomes the change narrator.** `CommitMessageEngine.swift` (1,419 lines, pure Foundation, a `BoardModel` × `BoardModel` × changed-paths → prose function) and its spec (`CommitMessageTests.swift`, 998 lines) are the designated core of the future activity feed / foreign-change journal. Harvest in place, before any deletion: + +- Relocate engine + `CommitMessageComposer.swift`'s request/protocol types out of `Kanban/Git/` into a neutral home (working name: `Kanban/Changes/`), renamed away from commit vocabulary (e.g. `ChangeNarrator`). +- Sever the two git ties the inventory found: move `GitChangedPath` (a plain path+kind value type currently defined inside `GitCommitOperation.swift`) into the neutral module; replace `CommitAuthorship.foreign(GitIdentity)` with a plain string identity. +- Transplant the spec tests alongside; they keep the engine alive and correct until the journal work begins. +- The "previous snapshot" input becomes the caller's problem by contract (the journal will supply it from memory/snapshot; git supplied it from HEAD). + +## What is deleted + +- **`Kanban/Git/` wholesale** (minus the two harvested files): mode detection, repository wrapper, auto-committer, commit/branch/restore operations, HEAD snapshot, history walk/provider, history store, housekeeping, identity, attribution, operation stamp, commit seam type. ~6,600 lines after harvest. +- **UI surfaces** (~1,160 lines): `BoardGitControls`, `BoardGitSetup`, `BoardGitTabView`, `CardHistorySection`; the `.git` case of `BoardInfoTab` and its switch arm; the card window's `historySlot` wiring. +- **Menu placeholders**: `RemoteCommands` (Board ▸ Pull/Push, `m7-git`-tagged) removed; the `View ▸ History` future row re-tagged to the journal successor rather than removed (the reserved slot survives the substrate). +- **`AppModel` wiring** (the largest single edit, ~130 mentions): `makeHistoryProvider` collapses to always-native; `wireGitUndo`, `wireBranchSwitching`, `bindHistoryProvider`'s add-git path, and the card-session staging threading (`setCardSession` / `releaseCardSessionStaging` / `resumeCardSessionStaging`) all go; `HistoryStore` composition leaves `beginSession`. +- **`BoardStore`**: the `commitSeam` property and its three call sites (`willWrite`, `writeBracketDidClose`, `reloadDidLand`); the `makeIdentityHistoryRanker` property. +- **`BoardRegistry`**: the persisted `gitOperationStamp` field and accessors. Safe removal: decoders ignore unknown keys, so existing registries with the field simply drop it on next write. +- **`BannerCenter`**: `GitFailureBanner`, the `GitOperation` enum, `.gitFailure` / `.repositoryUnreadable` cases and their rows. +- **`SessionSettleGate`**: the `GitRestoreOperation.plan` integration goes with the git restore path; the path utility it borrows from `GitHistoryWalk` moves to a neutral home; the gate itself (settle editors before wholesale operations) stays — it serves any future wholesale operation. +- **Dependencies**: SwiftGitX and libgit2 leave `project.yml` (with their rationale comment blocks, including the now-stale "never runs in the free app" note); `xcodegen generate`; `Package.resolved` regenerates. +- **Tests**: eleven wholesale suites (~8,285 lines minus the transplanted `CommitMessageTests`): `AutoCommitTests`, `GitUndoTests`, `BranchSwitchTests`, `HistoryStoreTests`, `RepositoryHygieneTests`, `GitIdentityTests`, `CardSessionCommitTests`, `BoardGitModeTests`, `BoardGitSetupTests`, `BoardInfoPopoverTests` (git-only despite the generic name). Mixed-file edits: `AppModelTests` (helper + 3 branch tests), `CardSessionUndoTests` (2 lines), `DuplicateIdentityTests` (2 git-rung tests), `BoardDecisionSurfaceTests` (the Pro-repair-commit suite), `BannerCenterTests` (git banner rows), `AccessibilityAuditTests` (git-tab audit mentions). +- **Naming footguns, called out so the sweep doesn't misfire**: `BoardInfoPopoverTests.swift` is entirely git (delete); `InertGitTests.swift` is a Storage-layer keeper despite the name (keep, rename to say what it pins — the writer/loader's byte-level git-agnosticism); `RepositoryHygieneTests.swift` is fully git despite two ".gitignore"-titled suites (delete — the kept gitignore behavior is covered by `GitignoreRulesTests` and `LooseFileRelocationTests`). + +## Companion changes (same milestone, not deletions) + +- **Agent guide rewrite + version bump.** The `## Git` section currently documents auto-commit ("If you don't commit, Lanework Pro auto-commits your changes"). Rewrite to the new posture: boards may live in git repos; agents working a repo-resident board should commit their own changes with clear messages, stage only their own paths, never touch app state. The guide is version-gated, so the marker bumps and existing boards heal to the new text on next open. +- **README key features.** Remove the four git bullets (git integration, auto-commit, undo-as-forward-commits/branches, card History) and the Pro-unlocks-git framing in the tiers bullet; add one line stating the format's git-friendliness promise (per-card files, stable UUIDs, byte-fidelity, seeded `.gitignore` — version boards with any tools you like). +- **DESIGN re-rulings** (each as a dated note in the doc it amends, per the corpus convention): + - `12-editions.md` — second pivot note: git excised entirely; tier machinery stays dormant pending the phone/sync split. + - `06-history-undo.md` — retired, with one migration first: its tier-independent **Undo routing** section (both substrates dispatch through it) moves into `13-native-undo.md` before the retirement note lands, so the routing rules keep a live home. + - `13-native-undo.md` — amended: the only substrate; add-git swap language removed. + - `07-sync-collab.md` — retired as written; a successor sync doc arrives with the ops-service workstream. + - `14-git-operations.md` — retired (superseded record). + - `DESIGN/README.md` — index updated: retired docs marked, the stale "— Pro tier" labels on 06/07/14 fixed. + - Source-file doc comments citing 06/07/14 by number get repointed during the sweep (mostly they go with the deleted files; the survivors repoint to 13). +- **`strategy/00-charter.md`** — the tier anchors re-ruled to the 2026-08-07 structure (free = complete Mac experience; Pro = iPhone + ops-based sync) once the user rules; the charter edit is the ruling's paper trail, not part of the mechanical excision. + +## Successors (deferred — explicitly outside this ruling) + +- **Foreign-change journal** — deferred by the 2026-08-08 ruling ("we'll worry about reclaiming the value of tracking agent-borne mutation another time"); recorded here so the shape isn't lost: pre-images of foreign writes journaled at reconciliation (the store holds prior content in memory when the ledger flags a foreign batch), a close-time text snapshot covering the app-closed blind window, `modified-by` attribution, bounded retention, a plain "previous versions / what changed" surface. Text only; attachment binaries deliberately out of scope locally. Interim safety net until then: the trash for deletes, user-run `git init` on boards that warrant it, and the agent guide's commit etiquette on repo-resident boards. +- **Ops-based sync service** — per the tier-strategy discussion: semantic ops, server-side worktree API, phone as worktree client; the harvested change narrator supplies the activity feed. Own workstream, own docs. + +## Sequencing + +Each step leaves the build green and the unit suite passing; steps are separately committable. + +1. **Preconditions.** Settle or land the in-flight working-tree changes (the pivot's implementation is mid-flight in `BoardStoreHistory`/`HistoryStaleness`/`BoardStore`); tag `pre-git-excision`. +2. **Harvest.** Relocate the message engine + composer types and `GitChangedPath` to `Kanban/Changes/`; sever the `GitIdentity` tie; transplant the spec tests; rename to narrator vocabulary. Green. +3. **UI peel.** Remove the Git tab, `CardHistorySection`, git banners, `RemoteCommands`; re-annotate the Sync placeholder. Green — the git engine still compiles underneath, unreferenced by UI. +4. **Seam unbind.** `AppModel` wiring out (provider always native), `BoardStore` seam + ranker out, `SessionSettleGate` cleaned, `BoardRegistry` stamp field out. Green — `Kanban/Git/` now compiles dead. +5. **Delete.** `Kanban/Git/` (minus harvested), the eleven test suites, the mixed-file edits. Green. +6. **Dependency drop.** SwiftGitX/libgit2 out of `project.yml`; regenerate; `Package.resolved` refreshes. Green — this is the step that proves nothing living referenced libgit2. +7. **Companions.** Agent-guide rewrite + version bump; README features; keeper renames (`InertGitTests`); DESIGN re-rulings and index; grep sweep for orphaned references (`git` case-insensitive over `Kanban/` and `KanbanTests/`, adjudicated against the keeper list above — filename-based sweeps misfire on the three footguns). +8. **Verify.** Full unit suite; UI suites compile (`build-for-testing`) and the accessibility audit passes without the Git tab; golden fixture suite untouched (no git fixtures exist — repos were built at runtime); a fixture board inside a real user repo still opens, watches, and heals correctly (the keeper behaviors). + +## Size and risk + +- Net deletion: roughly 9,000 lines of source and 8,000 of tests; edits in ~15 shared files. With the seams as clean as the inventory found, this is a one-to-two-session milestone. +- Biggest single risk: `AppModel`'s ~130-mention entanglement — step 4 is the one to do slowly, against a green step-3 baseline. +- Second risk: over-cutting a keeper — the keeper list and the three naming footguns above exist to prevent exactly that; the sweep adjudicates against this document. +- Registry compatibility: dropping `gitOperationStamp` is decode-safe (unknown keys ignored); no migration needed. +- The agent-guide bump is mandatory, not optional — shipping the old text would document machinery that no longer exists, to agents. + +## What this plan does not decide + +The journal's design and timing, the ops-service architecture, the Pro split's final contents, and Pro pricing are all downstream workstreams with their own documents. This plan only removes the git stack, preserves its seams and keepers, harvests its one reusable engine, and keeps the paper trail honest. + +## Handoff + +Excise app-managed git per `strategy/01-git-excision.md` (ruled 2026-08-08): tag `pre-git-excision`, then run Sequencing steps 1–8 in order, each committed green — the keeper list and the three test-file naming footguns are binding, the message engine is harvested to `Kanban/Changes/` before anything is deleted, and the agent guide's Git section is rewritten with a version bump; the foreign-change journal (reclaiming tracking of agent-borne mutations) is deferred and out of scope. diff --git a/strategy/README.md b/strategy/README.md index f333c24..9a90130 100644 --- a/strategy/README.md +++ b/strategy/README.md @@ -5,6 +5,7 @@ Long-term strategy work for Lanework's release, distribution, and business model ## Documents - [00-charter.md](00-charter.md) — the framing document: strategic goal, the two tier anchors, what is already ruled, the decision surface, the tensions to resolve, and the research agenda (start here) +- [01-git-excision.md](01-git-excision.md) — **ruled 2026-08-08: excise** — the plan for removing app-managed git entirely: keepers, harvest, delete list, sequencing, deferred successors, handoff Workstream documents are added as they happen, numbered in sequence.