"front"	"back"	"tags"
"What is Command Code's defining architectural contribution?"	"Diff-driven taste learning: every accept/reject/edit produces a diff (generated vs. kept) that becomes a preference constraint. Persisted as taste.md. Shapes every future output. A fundamentally different compounding model than skill accumulation."	harness-engineering::dd15::recall
"How does the taste system technically work (the 5-stage verifiable mechanism)?"	"(1) SIGNAL CAPTURE: accept/reject/edit produces a diff. (2) PROFILE GENERATION: a prompt template turns diffs into preferences. (3) PERSISTENCE: plain Markdown at .commandcode/taste/taste.md. (4) SERVER-SIDE MODEL: synced to api.commandcode.ai where taste-1 runs. (5) SHARING: taste push/pull for Git-style profile sharing across machines/teams."	harness-engineering::dd15::recall
"State the difference between Hermes's self-evolving skills and Command Code's taste learning."	"Hermes: learns PROCEDURES (how to do things). Command Code: learns PREFERENCES (how you want things done). Same compounding-memory insight, different layer. Both are model-initiated writes that compound. On Module 4's memory-tier framework, taste is a candidate SIXTH tier: learned preferences derived from behavioral signal, distinct from both static memory (what you wrote) and episodic memory (what happened)."	harness-engineering::dd15::analysis
"Why is preference poisoning a COMPOUNDING surface, and how does it differ from ordinary memory poisoning?"	"Ordinary memory poisoning (Module 4.3) persists ONE bad entry. Preference poisoning persists one bad entry that then influences the GENERATION OF EVERY SUBSEQUENT OUTPUT. A poisoned preference in taste.md shapes all future code generation until detected. The same compounding property that makes taste learning valuable makes taste poisoning durable. As-built, Command Code has NO validation gate between 'the model inferred a preference' and 'the preference is persisted.'"	harness-engineering::dd15::analysis
"What is preference exfiltration and why does it matter for proprietary codebases?"	"The taste profile syncs to api.commandcode.ai BY DESIGN — your coding patterns leave your machine. The taste-1 model runs server-side. For a proprietary codebase with distinctive conventions, the taste profile is a distilled representation of how you want code written, and that representation is itself valuable IP. Defense: understand what leaves the machine; do not deploy on codebases where the preference profile IS the IP."	harness-engineering::dd15::analysis
"What is the honest gap in Command Code's 'taste-1' marketing claims?"	"Marketing calls it 'meta neuro-symbolic AI with continuous RL.' The only VERIFIABLE mechanism is diff-driven Markdown profile updates + a hosted model. No paper published. The RL/symbolic internals are not auditable because the code is obfuscated (UNLICENSED, ~1.26 MB minified). Treat the neuro-symbolic framing as vendor characterization until a paper exists."	harness-engineering::dd15::analysis
"Why is 'diff as learning signal' a better preference signal than thumbs-up/down or explicit feedback?"	"The user's edit is the GROUND TRUTH of what they wanted. (a) vs thumbs-up/down: a thumbs-down carries no information about WHAT was wrong; a diff does. (b) vs explicit feedback: explicit feedback requires a separate action the user would not otherwise perform; the diff is captured as a side-effect of editing the user is already doing. The diff is the feedback; no separate feedback action is required."	harness-engineering::dd15::analysis
"Why does Command Code persist the taste profile as Markdown rather than an opaque embedding?"	"Legibility. The user can read, edit, and audit what the system learned — the legibility property most learned-preference systems sacrifice. A poisoned preference can be spotted by a careful reader; an opaque embedding cannot. This makes the taste layer auditable in principle, though the closed-source obfuscation limits how far the audit can reach."	harness-engineering::dd15::analysis
"Command Code's relationship to OpenCode (DD-03)?"	"Strong architectural resemblance: same tool vocabulary (read_file/edit_file), same explore/plan subagent pattern, same React+Ink TUI, same checkpoint/undo. Code is obfuscated so fork vs. reimplementation is unproven. npm packages (command-opencode-plugin, commandcode-go-opencode-provider) connect the two ecosystems by exposing Command Code's hosted API as a provider inside OpenCode."	harness-engineering::dd15::analysis
"How many core tools does Command Code expose, and what are the bundled design skills?"	"~22 core agentic tools (read_file, edit_file, write_file, grep, glob, shell_command, monitor_command, explore, plan, todo_write, web_search, web_fetch, diagnostics, ask_user_question, enter_plan_mode, exit_plan_mode). Plus ~16 bundled design-skill verbs (checkup, smell, review, deslop, typeset, recolor, motion) — making it the most opinionated design-aware harness in the roster."	harness-engineering::dd15::recall
"What is Command Code's rubric score and where does it win/lose?"	"31/60. WINS on Module 4 Memory (4/5): the taste system is a novel learned-memory layer. LOSES on Module 11 Observability (2/5): OpenTelemetry is built in but the obfuscation makes custom instrumentation impossible. LOSES on Module 12 Prompt (3/5): the taste profile is prompt-shaped but not auditable in its effect on the model's behavior. Closed-source distribution is the structural cost across the lower scores."	harness-engineering::dd15::analysis
"Describe Command Code's permission model and its escape hatch."	"Modes: default, plan (read-only exploration), acceptEdits. Escape hatch: dangerouslySkipPermissions. Sandbox via COMMANDCODE_SANDBOX env var. Permission flow objects (PermissionRequest, PermissionResponse, PermissionDecision) with allowedCategories allow-listing. Shell tools (shell_command, monitor_command) are the gated surface. Standard model — but it does NOT cover the taste layer's two novel surfaces (exfiltration, poisoning)."	harness-engineering::dd15::recall
"Explain the static-memory vs. learned-memory distinction in Command Code's architecture."	"STATIC memory (AGENTS.md, COMMANDCODE.md): what you wrote — the project's explicit conventions. LEARNED memory (.commandcode/taste/taste.md): what the system inferred from your behavior — the behavioral residue of every accept/reject/edit. The two compose: a new contributor reads AGENTS.md; the system has already absorbed the team's taste. Same compounding insight as Hermes's skills, applied to preferences instead of procedures."	harness-engineering::dd15::analysis
"What defense does Module 4.3 imply for Command Code's taste layer, and why is it missing as-built?"	"Module 4.3's defense is harness-managed learning with VALIDATION BEFORE PERSISTENCE — the same fix as Hermes's skill-store write gating. As-built, the taste loop has NO validation gate between 'the model inferred a preference' and 'the preference is persisted.' A poisoned diff becomes a poisoned preference becomes every future output shaped by the poison. The fix is a write-validation gate on the taste layer."	harness-engineering::dd15::application
"Why is the closed-source audit gap a structural cost, not just a convenience issue?"	"Obfuscated TypeScript means no INDEPENDENT security audit is possible. The permission model and sandbox mode exist but cannot be VERIFIED without source. OpenTelemetry is built in but the obfuscation makes custom instrumentation impossible. You are trusting the vendor's CLAIM about what the harness does and does not do — including what the taste sync actually transmits. This is why Module 11 (Observability) scores 2/5 and why the 'open-source the harness' fix is item #1."	harness-engineering::dd15::analysis
"What is the 'taste push / taste pull' sharing mechanism and what does it imply?"	"The separate `taste` npm package (Apache-2.0) provides Git-style sharing of preference profiles across machines and teams. Implies: (a) a team can converge on a shared taste profile — useful for consistency; (b) a poisoned profile can be SHARED — one compromised machine can propagate a poisoned taste to the whole team via taste push; (c) the sharing layer is a propagation vector for preference poisoning, compounding the surface."	harness-engineering::dd15::application
"How does Command Code's memory system handle long sessions (compaction)?"	"First-class memory with explicit compaction: MemorySelector, MemoryFile, CompactMode, CompactAgent, summarizeAndCompact, compactionCount. Long sessions get SUMMARIZED rather than truncated. Session/project state persists under .commandcode/projects/. The taste profile (.commandcode/taste/) is a separate LEARNED layer on top of this static memory + compaction system."	harness-engineering::dd15::recall
"What is the architect's verdict on when to build on Command Code?"	"BUILD ON IT when personalization is the primary value and you trust the hosted model — the diff-driven taste loop is genuinely novel and no other harness learns from accept/reject behavior. DO NOT BUILD ON IT for security-sensitive codebases without understanding what leaves your machine (the hosted sync is an exfiltration surface) and without acknowledging the closed-source audit gap (you are trusting the vendor's claim). The taste layer's compound-poisoning surface requires a write-validation gate that is missing as-built."	harness-engineering::dd15::application
"Why is 'the hosted model is just a convenience' an anti-pattern?"	"The hosted model concentrates capability (one well-trained model serves all users) AND concentrates your proprietary signal on someone else's server. For a proprietary codebase with distinctive conventions, the taste profile is a distilled representation of how you want code written — and that representation is valuable. Cure: understand what leaves the machine before enabling the sync, and do not deploy on codebases where the preference profile is itself the IP."	harness-engineering::dd15::analysis
"What are the 3 things to fix in Command Code, per the deep-dive?"	"(1) OPEN-SOURCE THE HARNESS: obfuscated TypeScript means no audit, no custom observability, no community trust. (2) LOCAL TASTE MODEL: the hosted sync is a data-exfiltration surface — run taste-1 locally or document exactly what leaves the machine. (3) ADD HARNESS-MANAGED LEARNING VALIDATION: prevent poisoned preferences from compounding (same fix as Hermes's write gating, Module 4.3)."	harness-engineering::dd15::recall