npm - akemon - Versions diffs - 0.3.5 → 0.3.7 - Mend

akemon 0.3.5 → 0.3.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (54) hide show

package/DATA_POLICY.md +128 -0
package/README.md +156 -19
package/TRADEMARK.md +74 -0
package/dist/akemon-home.js +56 -0
package/dist/akemon-message.js +107 -0
package/dist/best-effort.js +8 -0
package/dist/cli.js +1411 -132
package/dist/cognitive-artifact-store.js +101 -0
package/dist/cognitive-event-log.js +47 -0
package/dist/config.js +45 -9
package/dist/context.js +27 -6
package/dist/core/contracts/layers.js +1 -0
package/dist/core/contracts/permission.js +1 -0
package/dist/core/contracts/workspace.js +1 -0
package/dist/core-cognitive-module.js +768 -0
package/dist/engine-peripheral.js +127 -26
package/dist/engine-routing.js +58 -17
package/dist/interactive-session.js +361 -0
package/dist/local-interconnect.js +156 -0
package/dist/local-registry.js +178 -0
package/dist/mcp-server.js +4 -1
package/dist/memory-proposal.js +379 -0
package/dist/memory-recorder.js +368 -0
package/dist/orphan-scan.js +36 -24
package/dist/passive-reflection-cognitive-module.js +172 -0
package/dist/peripheral-registry.js +235 -0
package/dist/permission-audit.js +132 -0
package/dist/relay-client.js +68 -9
package/dist/relay-mode.js +34 -0
package/dist/relay-peripheral.js +139 -49
package/dist/runtime-platform.js +122 -0
package/dist/secretariat/client.js +87 -0
package/dist/self.js +15 -6
package/dist/server.js +3695 -439
package/dist/social-discovery.js +231 -0
package/dist/software-agent-peripheral.js +314 -235
package/dist/software-agent-result-cli.js +69 -0
package/dist/software-agent-stream-cli.js +23 -0
package/dist/software-agent-transport.js +177 -0
package/dist/task-module.js +243 -0
package/dist/task-registry.js +756 -0
package/dist/vendor/xterm/addon-fit.js +2 -0
package/dist/vendor/xterm/addon-search.js +2 -0
package/dist/vendor/xterm/addon-web-links.js +2 -0
package/dist/vendor/xterm/xterm.css +285 -0
package/dist/vendor/xterm/xterm.js +2 -0
package/dist/work-memory.js +339 -0
package/dist/workbench-peripheral-guide.js +79 -0
package/dist/workbench-session.js +1074 -0
package/dist/workbench.html +4011 -0
package/package.json +11 -4
package/scripts/build.cjs +24 -0
package/scripts/check-architecture-baseline.cjs +68 -0
package/scripts/test.cjs +38 -0

package/dist/workbench.html ADDED Viewed

@@ -0,0 +1,4011 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Akemon Workbench</title>
+<link rel="stylesheet" href="/vendor/xterm/xterm.css">
+<style>
+*, *::before, *::after { box-sizing: border-box; }
+html, body { height: 100%; }
+body {
+  margin: 0;
+  background: #f8f7f6;
+  color: #1a1a1a;
+  font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  overflow: hidden;
+}
+button, input, select, textarea {
+  font: inherit;
+}
+.app {
+  display: grid;
+  grid-template-rows: 54px minmax(0, 1fr) 30px;
+  height: 100vh;
+}
+.topbar {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 14px;
+  padding: 0 14px;
+  background: #ffffff;
+  border-bottom: 1px solid #e0ddd8;
+}
+.brand {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  min-width: 168px;
+}
+.brand-title {
+  font-size: 15px;
+  font-weight: 650;
+}
+.brand-subtitle {
+  color: #888480;
+  font-size: 12px;
+}
+.page-tabs {
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 4px;
+  overflow-x: auto;
+  scrollbar-width: none;
+}
+.page-tabs::-webkit-scrollbar {
+  display: none;
+}
+.page-tab {
+  height: 34px;
+  min-width: 86px;
+  border: 1px solid transparent;
+  background: transparent;
+  color: #555250;
+  border-radius: 7px;
+  padding: 0 12px;
+  cursor: pointer;
+  font-size: 13px;
+  font-weight: 600;
+}
+.page-tab:hover {
+  background: #f0eeeb;
+}
+.page-tab.active {
+  background: #e8f0e4;
+  border-color: #9cc498;
+  color: #2d6f3e;
+}
+.start-form {
+  display: grid;
+  grid-template-columns: minmax(120px, 1fr) minmax(96px, 150px);
+  gap: 10px;
+  align-items: end;
+  min-width: 0;
+}
+.start-form .field-wide {
+  grid-column: 1 / -1;
+}
+.start-form .checkbox-field {
+  align-self: center;
+}
+.start-form .btn-primary {
+  justify-self: start;
+}
+.field {
+  min-width: 0;
+}
+.field input,
+.field select,
+.token-input {
+  width: 100%;
+  height: 32px;
+  border: 1px solid #d0ccc5;
+  background: #ffffff;
+  color: #1a1a1a;
+  border-radius: 6px;
+  padding: 0 9px;
+  outline: none;
+}
+.field input:focus,
+.field select:focus,
+.token-input:focus {
+  border-color: #4a8f4a;
+}
+.checkbox-field {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  color: #666360;
+  font-size: 12px;
+  white-space: nowrap;
+}
+.btn {
+  height: 32px;
+  border: 1px solid #d0ccc5;
+  background: #f0eeeb;
+  color: #333130;
+  border-radius: 6px;
+  padding: 0 12px;
+  cursor: pointer;
+}
+.btn:hover {
+  background: #e5e2de;
+}
+.btn-primary {
+  background: #3a8a52;
+  border-color: #2e7a42;
+  color: #ffffff;
+}
+.btn-primary:hover {
+  background: #4a9a62;
+}
+.btn-danger {
+  background: #dc4840;
+  border-color: #c43830;
+  color: #ffffff;
+}
+.btn-danger:hover {
+  background: #e05850;
+}
+.auth-strip {
+  display: none;
+  align-items: center;
+  gap: 8px;
+  min-width: 280px;
+}
+.auth-strip.show {
+  display: flex;
+}
+.auth-message {
+  color: #9a3a30;
+  font-size: 12px;
+  white-space: nowrap;
+}
+.layout {
+  min-width: 0;
+  min-height: 0;
+  display: block;
+  overflow: hidden;
+  background: #fafaf9;
+}
+.page-view {
+  min-width: 0;
+  min-height: 0;
+  height: 100%;
+  overflow: hidden;
+  display: none;
+}
+.page-view.active {
+  display: grid;
+}
+.sessions-layout {
+  min-width: 0;
+  min-height: 0;
+  height: 100%;
+  display: grid;
+  grid-template-columns: minmax(320px, 420px) minmax(0, 1fr);
+  overflow: hidden;
+}
+.start-panel {
+  min-width: 0;
+  min-height: 0;
+  display: grid;
+  grid-template-rows: 40px minmax(0, 1fr);
+  border-right: 1px solid #e0ddd8;
+  background: #f4f3f1;
+  overflow: hidden;
+}
+.start-panel-body {
+  min-height: 0;
+  overflow: auto;
+  padding: 14px;
+}
+.sidebar {
+  min-height: 0;
+  display: grid;
+  grid-template-rows: 40px minmax(0, 1fr);
+  background: #ffffff;
+  overflow: hidden;
+}
+.sidebar-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 0 12px;
+  border-bottom: 1px solid #e0ddd8;
+}
+.sidebar-title {
+  color: #555250;
+  font-size: 12px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.sidebar-actions {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+.sidebar-actions .btn {
+  width: auto;
+  padding: 4px 7px;
+  font-size: 12px;
+}
+.session-list {
+  min-height: 0;
+  overflow: auto;
+  overscroll-behavior: contain;
+  padding: 8px;
+}
+.session-item {
+  width: 100%;
+  border: 1px solid transparent;
+  background: transparent;
+  color: inherit;
+  text-align: left;
+  border-radius: 7px;
+  padding: 9px;
+  cursor: pointer;
+}
+.session-item:hover {
+  background: #edecea;
+}
+.session-item.active {
+  background: #e8f0e4;
+  border-color: #9cc498;
+}
+.session-line {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+.session-name {
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  font-size: 13px;
+  font-weight: 600;
+}
+.session-meta {
+  margin-top: 4px;
+  color: #888480;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 11px;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+.status-pill {
+  border: 1px solid #d0ccc5;
+  border-radius: 999px;
+  color: #555250;
+  font-size: 11px;
+  padding: 2px 7px;
+  line-height: 1.2;
+}
+.status-running {
+  color: #2a7a3a;
+  border-color: #8cc498;
+  background: #edf7ee;
+}
+.status-ended {
+  color: #8a7540;
+  border-color: #d4c498;
+  background: #faf5ea;
+}
+.status-failed {
+  color: #9a3a30;
+  border-color: #e0aaa4;
+  background: #fff5f3;
+}
+.empty {
+  color: #999690;
+  padding: 18px 10px;
+  font-size: 13px;
+}
+.session-history-note {
+  color: #888480;
+  padding: 8px 9px;
+  font-size: 12px;
+  line-height: 1.35;
+}
+.main {
+  min-width: 0;
+  min-height: 0;
+  height: 100%;
+  display: grid;
+  grid-template-rows: 40px minmax(0, 1fr);
+  background: #fafaf9;
+  overflow: hidden;
+}
+.session-toolbar {
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 0 12px;
+  border-bottom: 1px solid #e0ddd8;
+  background: #f6f5f3;
+}
+.active-summary {
+  min-width: 0;
+  flex: 1 1 auto;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  color: #333130;
+  font-size: 13px;
+}
+.active-command {
+  min-width: 120px;
+  flex: 1 1 auto;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  color: #666360;
+}
+.toolbar-actions {
+  flex: 0 0 auto;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.toolbar-select {
+  height: 32px;
+  border: 1px solid #d0ccc5;
+  background: #ffffff;
+  color: #333130;
+  border-radius: 6px;
+  padding: 0 8px;
+  outline: none;
+}
+.terminal-session-select {
+  flex: 0 1 360px;
+  width: min(34vw, 360px);
+  min-width: 190px;
+}
+.terminal-page,
+.terminal-wrap,
+#terminal {
+  width: 100%;
+}
+.terminal-wrap {
+  min-width: 0;
+  min-height: 0;
+  display: grid;
+  grid-template-rows: minmax(0, 1fr);
+  padding: 8px 14px 8px 8px;
+  position: relative;
+  overflow: hidden;
+  background: #ffffff;
+}
+#terminal {
+  min-width: 0;
+  min-height: 0;
+  height: 100%;
+  width: 100%;
+  overflow: hidden;
+  background: #ffffff;
+}
+#terminal .xterm {
+  min-width: 0;
+  height: 100%;
+  width: 100%;
+}
+.chat-panel {
+  min-width: 0;
+  min-height: 0;
+  height: 100%;
+  display: grid;
+  grid-template-rows: 40px minmax(0, 1fr) auto;
+  border-left: 0;
+  background: #f4f3f1;
+  overflow: hidden;
+}
+.chat-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  padding: 0 12px;
+  border-bottom: 1px solid #e0ddd8;
+}
+.chat-title {
+  color: #555250;
+  font-size: 12px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.chat-head-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+}
+.chat-meta {
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  color: #888480;
+  font-size: 12px;
+}
+.chat-clear {
+  width: auto;
+  padding: 4px 7px;
+  font-size: 12px;
+}
+.chat-messages {
+  min-height: 0;
+  overflow: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 10px;
+}
+.chat-empty {
+  color: #999690;
+  padding: 8px 2px;
+  font-size: 13px;
+}
+.chat-message {
+  max-width: 100%;
+  border: 1px solid #e0ddd8;
+  border-radius: 7px;
+  background: #ffffff;
+  padding: 8px 9px;
+}
+.chat-message.user {
+  align-self: flex-end;
+  background: #e8f0e4;
+  border-color: #9cc498;
+}
+.chat-message.error {
+  border-color: #e0aaa4;
+  background: #fff5f3;
+}
+.chat-message-role {
+  margin-bottom: 4px;
+  color: #77736f;
+  font-size: 11px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.chat-message-text {
+  color: #333130;
+  font-size: 13px;
+  line-height: 1.4;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+.chat-message-task {
+  margin-top: 8px;
+  padding-top: 7px;
+  border-top: 1px solid #ececec;
+  color: #66615c;
+  font-size: 12px;
+  line-height: 1.35;
+}
+.memory-proposal {
+  margin-top: 9px;
+  padding-top: 8px;
+  border-top: 1px solid #e0ddd8;
+}
+.memory-proposal-title {
+  color: #4b5a42;
+  font-size: 12px;
+  font-weight: 650;
+}
+.memory-proposal-text {
+  margin-top: 5px;
+  color: #333130;
+  font-size: 12px;
+  line-height: 1.4;
+  white-space: pre-wrap;
+}
+.memory-proposal-actions {
+  display: flex;
+  gap: 6px;
+  margin-top: 8px;
+}
+.memory-proposal-actions .btn {
+  width: auto;
+  padding: 5px 8px;
+  font-size: 12px;
+}
+.memory-proposal-status {
+  margin-top: 6px;
+  color: #77736f;
+  font-size: 12px;
+}
+.cm-panel {
+  min-width: 0;
+  min-height: 0;
+  height: 100%;
+  display: grid;
+  grid-template-rows: 40px minmax(0, 1fr);
+  border-top: 0;
+  background: #f7f6f4;
+  overflow: hidden;
+}
+.activity-panel {
+  min-width: 0;
+  min-height: 0;
+  height: 100%;
+  display: grid;
+  grid-template-rows: 40px 38px minmax(0, 1fr);
+  background: #f7f6f4;
+  overflow: hidden;
+}
+.activity-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  padding: 0 12px;
+  border-bottom: 1px solid #e0ddd8;
+}
+.activity-title {
+  color: #555250;
+  font-size: 12px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.activity-controls {
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.activity-filter {
+  height: 28px;
+  min-width: 112px;
+  border: 1px solid #d9d5cf;
+  border-radius: 6px;
+  background: #fff;
+  color: #343230;
+  font-size: 12px;
+  padding: 0 8px;
+}
+.activity-search {
+  min-width: 160px;
+}
+.activity-refresh {
+  width: auto;
+  padding: 4px 7px;
+  font-size: 12px;
+}
+.activity-overview {
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  overflow-x: auto;
+  padding: 5px 12px;
+  border-bottom: 1px solid #e0ddd8;
+}
+.activity-metric {
+  flex: 0 0 auto;
+  display: inline-flex;
+  align-items: baseline;
+  gap: 5px;
+  border: 1px solid #e0ddd8;
+  border-radius: 999px;
+  background: #fff;
+  padding: 4px 8px;
+}
+.activity-metric-label {
+  color: #77736f;
+  font-size: 11px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.activity-metric-value {
+  color: #333130;
+  font-size: 12px;
+  font-weight: 700;
+}
+.activity-body {
+  min-width: 0;
+  min-height: 0;
+  display: grid;
+  grid-template-columns: minmax(280px, 0.9fr) minmax(360px, 1.1fr);
+  overflow: hidden;
+}
+.activity-items {
+  min-height: 0;
+  overflow: auto;
+  padding: 10px;
+  border-right: 1px solid #e0ddd8;
+}
+.activity-empty {
+  color: #999690;
+  padding: 8px 2px;
+  font-size: 13px;
+}
+.activity-group + .activity-group {
+  margin-top: 12px;
+}
+.activity-group-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  margin: 2px 2px 7px;
+  color: #77736f;
+  font-size: 11px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.activity-group-count {
+  color: #999690;
+  font-weight: 600;
+}
+.activity-item {
+  border: 1px solid #e0ddd8;
+  border-radius: 7px;
+  background: #ffffff;
+  padding: 10px;
+  text-align: left;
+  width: 100%;
+  display: block;
+  cursor: pointer;
+  color: inherit;
+  font: inherit;
+}
+.activity-item + .activity-item {
+  margin-top: 8px;
+}
+.activity-item:hover,
+.activity-item.selected {
+  border-color: #b8b1a8;
+  background: #fbfaf8;
+}
+.activity-item-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  margin-bottom: 6px;
+}
+.activity-item-title {
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  color: #333130;
+  font-size: 13px;
+  font-weight: 650;
+}
+.activity-item-meta {
+  color: #77736f;
+  font-size: 11px;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+.activity-item-summary {
+  margin-top: 6px;
+  color: #555250;
+  font-size: 13px;
+  line-height: 1.4;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+.activity-detail {
+  min-width: 0;
+  min-height: 0;
+  overflow: auto;
+  padding: 14px;
+}
+.activity-detail-empty {
+  color: #999690;
+  font-size: 13px;
+  padding: 4px 2px;
+}
+.activity-detail-card {
+  max-width: 920px;
+}
+.activity-detail-head {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 12px;
+}
+.activity-detail-title {
+  color: #292725;
+  font-size: 18px;
+  font-weight: 700;
+  line-height: 1.25;
+  overflow-wrap: anywhere;
+}
+.activity-detail-summary {
+  margin-top: 10px;
+  color: #47433f;
+  font-size: 14px;
+  line-height: 1.45;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+.activity-detail-kicker {
+  color: #77736f;
+  font-size: 12px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  margin-bottom: 5px;
+}
+.activity-detail-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 8px;
+  margin-top: 14px;
+}
+.activity-detail-field {
+  min-width: 0;
+  border: 1px solid #e0ddd8;
+  border-radius: 7px;
+  background: #fff;
+  padding: 9px;
+}
+.activity-detail-label {
+  color: #77736f;
+  font-size: 11px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.activity-detail-value {
+  margin-top: 5px;
+  color: #333130;
+  font-size: 13px;
+  line-height: 1.35;
+  overflow-wrap: anywhere;
+}
+.activity-detail-section {
+  margin-top: 14px;
+}
+.activity-detail-section + .activity-detail-section {
+  padding-top: 4px;
+}
+.activity-detail-section-title {
+  color: #555250;
+  font-size: 12px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.activity-detail-text {
+  margin-top: 6px;
+  color: #333130;
+  font-size: 14px;
+  line-height: 1.45;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+.activity-timeline {
+  display: grid;
+  gap: 8px;
+  margin-top: 8px;
+}
+.activity-timeline-item {
+  width: 100%;
+  min-width: 0;
+  border: 1px solid #e0ddd8;
+  border-radius: 7px;
+  background: #fff;
+  color: inherit;
+  cursor: pointer;
+  font: inherit;
+  padding: 9px;
+  text-align: left;
+}
+.activity-timeline-item:hover {
+  border-color: #b8b1a8;
+  background: #fbfaf8;
+}
+.activity-timeline-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+.activity-timeline-title {
+  min-width: 0;
+  color: #333130;
+  font-size: 13px;
+  font-weight: 650;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.activity-timeline-time {
+  flex: 0 0 auto;
+  color: #77736f;
+  font-size: 11px;
+}
+.activity-timeline-summary {
+  margin-top: 5px;
+  color: #555250;
+  font-size: 12px;
+  line-height: 1.35;
+  overflow-wrap: anywhere;
+  white-space: pre-wrap;
+}
+.activity-timeline-empty {
+  color: #999690;
+  font-size: 13px;
+  padding: 3px 0;
+}
+.activity-technical {
+  margin-top: 14px;
+}
+.activity-technical summary {
+  color: #555250;
+  cursor: pointer;
+  font-size: 12px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.activity-detail-pre {
+  margin-top: 6px;
+  padding: 10px;
+  border: 1px solid #e0ddd8;
+  border-radius: 7px;
+  background: #fff;
+  color: #333130;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 12px;
+  line-height: 1.45;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+.cm-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 12px;
+  border-bottom: 1px solid #e0ddd8;
+}
+.cm-title {
+  color: #555250;
+  font-size: 12px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.cm-items {
+  min-height: 0;
+  overflow: auto;
+  padding: 8px;
+}
+.cm-empty {
+  color: #999690;
+  padding: 8px 2px;
+  font-size: 13px;
+}
+.cm-item {
+  border: 1px solid #e0ddd8;
+  border-radius: 7px;
+  background: #ffffff;
+  padding: 8px;
+}
+.cm-item + .cm-item {
+  margin-top: 8px;
+}
+.cm-item-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  margin-bottom: 6px;
+}
+.cm-item-kind {
+  color: #555250;
+  font-size: 11px;
+  font-weight: 650;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.cm-item-time {
+  color: #999690;
+  font-size: 11px;
+  white-space: nowrap;
+}
+.chat-form {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: end;
+  gap: 8px;
+  padding: 8px;
+  border-top: 1px solid #e0ddd8;
+  background: #ffffff;
+}
+.chat-form textarea {
+  width: 100%;
+  height: 128px;
+  min-height: 96px;
+  max-height: 220px;
+  resize: vertical;
+  border: 1px solid #d0ccc5;
+  background: #ffffff;
+  color: #1a1a1a;
+  border-radius: 6px;
+  padding: 8px 9px;
+  outline: none;
+}
+.chat-form textarea:focus {
+  border-color: #4a8f4a;
+}
+.chat-form .btn {
+  width: 68px;
+}
+.statusbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 0 12px;
+  border-top: 1px solid #e0ddd8;
+  background: #f6f5f3;
+  color: #888480;
+  font-size: 12px;
+}
+.status-error {
+  color: #c43830;
+}
+.search-bar {
+  display: none;
+  position: absolute;
+  top: 6px;
+  right: 14px;
+  z-index: 10;
+  gap: 4px;
+  align-items: center;
+  background: #ffffff;
+  border: 1px solid #d0ccc5;
+  border-radius: 6px;
+  padding: 4px 6px;
+  box-shadow: 0 2px 8px rgba(0,0,0,0.08);
+}
+.search-bar.open {
+  display: flex;
+}
+.search-bar input {
+  width: 180px;
+  height: 26px;
+  border: 1px solid #d0ccc5;
+  background: #f8f7f6;
+  color: #1a1a1a;
+  border-radius: 4px;
+  padding: 0 7px;
+  font: 12px/1 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  outline: none;
+}
+.search-bar input:focus {
+  border-color: #4a8f4a;
+}
+.search-bar button {
+  height: 26px;
+  border: 1px solid #d0ccc5;
+  background: #f0eeeb;
+  color: #333130;
+  border-radius: 4px;
+  padding: 0 7px;
+  cursor: pointer;
+  font-size: 12px;
+}
+.search-bar button:hover {
+  background: #e5e2de;
+}
+@media (max-width: 1200px) {
+  .sessions-layout {
+    grid-template-columns: minmax(300px, 380px) minmax(0, 1fr);
+  }
+}
+@media (max-width: 980px) {
+  .app {
+    grid-template-rows: auto minmax(0, 1fr) 30px;
+  }
+  .topbar {
+    grid-template-columns: 1fr;
+    align-items: stretch;
+    padding: 10px;
+  }
+  .brand {
+    min-width: 0;
+  }
+  .page-tabs {
+    justify-content: flex-start;
+  }
+  .start-form {
+    grid-template-columns: 1fr 1fr;
+  }
+  .sessions-layout {
+    grid-template-columns: minmax(0, 1fr);
+    grid-template-rows: auto minmax(0, 1fr);
+  }
+  .start-panel {
+    border-right: 0;
+    border-bottom: 1px solid #e0ddd8;
+  }
+  .start-panel-body {
+    max-height: 280px;
+  }
+  .chat-form {
+    grid-template-columns: minmax(0, 1fr);
+  }
+  .chat-form .btn {
+    width: 100%;
+  }
+  .main {
+    grid-template-rows: auto minmax(0, 1fr);
+  }
+  .session-toolbar {
+    align-items: stretch;
+    flex-direction: column;
+    height: auto;
+    padding: 8px;
+  }
+  .active-summary,
+  .toolbar-actions {
+    width: 100%;
+  }
+  .terminal-session-select {
+    width: 100%;
+    min-width: 0;
+  }
+  .activity-head {
+    height: auto;
+    align-items: stretch;
+    flex-direction: column;
+    padding: 8px;
+  }
+  .activity-panel {
+    grid-template-rows: auto auto minmax(0, 1fr);
+  }
+  .activity-controls {
+    width: 100%;
+    flex-wrap: wrap;
+  }
+  .activity-filter {
+    flex: 1 1 130px;
+    min-width: 0;
+  }
+  .activity-body {
+    grid-template-columns: minmax(0, 1fr);
+    grid-template-rows: minmax(180px, 0.55fr) minmax(220px, 0.45fr);
+  }
+  .activity-items {
+    border-right: 0;
+    border-bottom: 1px solid #e0ddd8;
+  }
+  .activity-detail-grid {
+    grid-template-columns: minmax(0, 1fr);
+  }
+}
+</style>
+</head>
+<body>
+<div class="app">
+  <header class="topbar">
+    <div class="brand">
+      <div class="brand-title">Akemon Workbench</div>
+      <div class="brand-subtitle">local</div>
+    </div>
+    <nav class="page-tabs" id="page-tabs" aria-label="Workbench pages">
+      <button class="page-tab active" type="button" data-page-tab="terminal">Terminal</button>
+      <button class="page-tab" type="button" data-page-tab="sessions">Sessions</button>
+      <button class="page-tab" type="button" data-page-tab="activity">Activity</button>
+      <button class="page-tab" type="button" data-page-tab="akemon">Akemon</button>
+      <button class="page-tab" type="button" data-page-tab="cm">CM</button>
+    </nav>
+    <div class="auth-strip" id="auth-strip">
+      <input class="token-input" id="token-input" placeholder="owner token">
+      <button class="btn" id="token-save" type="button">Use</button>
+      <span class="auth-message" id="auth-message"></span>
+    </div>
+  </header>
+  <div class="layout">
+    <section class="page-view active terminal-page" data-page-panel="terminal">
+      <main class="main">
+        <div class="session-toolbar">
+          <div class="active-summary">
+            <select class="toolbar-select terminal-session-select" id="terminal-session-select" title="Session">
+              <option value="">No sessions</option>
+            </select>
+            <span class="status-pill" id="active-status">idle</span>
+            <span class="active-command" id="active-command">No active session</span>
+          </div>
+          <div class="toolbar-actions">
+            <select class="toolbar-select" id="active-input-mode" title="Input mode">
+              <option value="line">line</option>
+              <option value="tui">tui</option>
+            </select>
+            <button class="btn" id="resize" type="button">Resize</button>
+            <button class="btn btn-danger" id="stop" type="button">Stop</button>
+          </div>
+        </div>
+        <div class="terminal-wrap">
+          <div class="search-bar" id="search-bar">
+            <input id="search-input" placeholder="Search...">
+            <button id="search-prev" type="button">&#x25B2;</button>
+            <button id="search-next" type="button">&#x25BC;</button>
+            <button id="search-close" type="button">&#x2715;</button>
+          </div>
+          <div id="terminal"></div>
+        </div>
+      </main>
+    </section>
+    <section class="page-view sessions-page" data-page-panel="sessions">
+      <div class="sessions-layout">
+        <section class="start-panel">
+          <div class="sidebar-head">
+            <div class="sidebar-title">New Session</div>
+          </div>
+          <div class="start-panel-body">
+            <form class="start-form" id="start-form">
+              <div class="field">
+                <select id="tool">
+                  <option value="codex">codex</option>
+                  <option value="claude">claude</option>
+                  <option value="cursor">cursor</option>
+                  <option value="shell">shell</option>
+                  <option value="custom">custom command</option>
+                </select>
+              </div>
+              <div class="field">
+                <select id="input-mode">
+                  <option value="auto">auto input</option>
+                  <option value="line">line</option>
+                  <option value="tui">tui</option>
+                </select>
+              </div>
+              <div class="field field-wide"><input id="command" placeholder="command"></div>
+              <div class="field field-wide"><input id="args" placeholder="args"></div>
+              <div class="field field-wide"><input id="workdir" placeholder="workdir"></div>
+              <div class="field field-wide"><input id="label" placeholder="label"></div>
+              <label class="checkbox-field"><input type="checkbox" id="allow-outside"> outside</label>
+              <button class="btn btn-primary" type="submit">Start</button>
+            </form>
+          </div>
+        </section>
+        <section class="sidebar">
+          <div class="sidebar-head">
+            <div class="sidebar-title">Sessions</div>
+            <div class="sidebar-actions">
+              <button class="btn" id="session-history-toggle" type="button">History</button>
+              <button class="btn" id="refresh" type="button">Refresh</button>
+            </div>
+          </div>
+          <div class="session-list" id="session-list">
+            <div class="empty">No sessions.</div>
+          </div>
+        </section>
+      </div>
+    </section>
+    <section class="page-view activity-page" data-page-panel="activity">
+      <section class="activity-panel">
+        <div class="activity-head">
+          <div class="activity-title">Activity</div>
+          <div class="activity-controls">
+            <select class="activity-filter" id="activity-status-filter" aria-label="Activity status">
+              <option value="">All status</option>
+              <option value="pending">Pending</option>
+              <option value="running">Running</option>
+              <option value="waiting">Waiting</option>
+              <option value="succeeded">Succeeded</option>
+              <option value="failed">Failed</option>
+              <option value="info">Info</option>
+            </select>
+            <select class="activity-filter" id="activity-route-filter" aria-label="Activity route">
+              <option value="">All routes</option>
+              <option value="core_cm">Core CM</option>
+              <option value="interactive-session">Interactive</option>
+              <option value="software-agent">Software Agent</option>
+              <option value="relay-order">Relay Order</option>
+              <option value="user-task">User Task</option>
+              <option value="relay-task">Relay Task</option>
+              <option value="memory_cm">Memory CM</option>
+            </select>
+            <input class="activity-filter activity-search" id="activity-search" aria-label="Search activity" placeholder="Search">
+            <button class="btn activity-refresh" id="activity-refresh" type="button">Refresh</button>
+          </div>
+        </div>
+        <div class="activity-overview" id="activity-overview"></div>
+        <div class="activity-body">
+          <div class="activity-items" id="activity-items">
+            <div class="activity-empty">No activity yet.</div>
+          </div>
+          <div class="activity-detail" id="activity-detail">
+            <div class="activity-detail-empty">No task selected.</div>
+          </div>
+        </div>
+      </section>
+    </section>
+    <section class="page-view akemon-page" data-page-panel="akemon">
+      <aside class="chat-panel">
+        <div class="chat-head">
+          <div class="chat-title">Akemon</div>
+          <div class="chat-head-actions">
+            <div class="chat-meta" id="chat-meta"></div>
+            <button class="btn chat-clear" id="chat-clear" type="button">Clear</button>
+          </div>
+        </div>
+        <div class="chat-messages" id="chat-messages">
+          <div class="chat-empty">No messages.</div>
+        </div>
+        <form class="chat-form" id="chat-form">
+          <textarea id="chat-input" placeholder="Message Akemon"></textarea>
+          <button class="btn btn-primary" id="chat-send" type="submit">Send</button>
+        </form>
+      </aside>
+    </section>
+    <section class="page-view cm-page" data-page-panel="cm">
+      <section class="cm-panel">
+        <div class="cm-head">
+          <div class="cm-title">CM</div>
+        </div>
+        <div class="cm-items" id="cm-items">
+          <div class="cm-empty">No CM items yet.</div>
+        </div>
+      </section>
+    </section>
+  </div>
+  <footer class="statusbar">
+    <span id="status-text">Disconnected</span>
+    <span id="size-text">0x0</span>
+    <span id="debug-text"></span>
+  </footer>
+</div>
+<script src="/vendor/xterm/xterm.js"></script>
+<script src="/vendor/xterm/addon-fit.js"></script>
+<script src="/vendor/xterm/addon-web-links.js"></script>
+<script src="/vendor/xterm/addon-search.js"></script>
+<script>
+const TOKEN_STORAGE_KEY = "akemon.workbench.ownerToken";
+const PAGE_STORAGE_KEY = "akemon.workbench.activePage";
+const CHAT_CONVERSATION_KEY = "akemon.workbench.chatConversation";
+const CHAT_HISTORY_PREFIX = "akemon.workbench.chatHistory.";
+const CHAT_HISTORY_LIMIT = 50;
+const ACTIVE_CHAT_TASK_PREFIX = "akemon.workbench.activeChatTask.";
+const CM_ITEMS_PREFIX = "akemon.workbench.cmItems.";
+const CM_ITEMS_LIMIT = 30;
+const FONT_SIZE = 13;
+const LINE_HEIGHT = 1.25;
+const CHAT_REQUEST_TIMEOUT_MS = 8 * 60 * 1000 + 15 * 1000;
+const CHAT_ACTIVE_TASK_RECOVERY_MS = 30 * 60 * 1000;
+const TERMINAL_RESPONSE_BUFFER_LIMIT = 160;
+const state = {
+  token: "",
+  sessions: [],
+  activeId: "",
+  streamAbort: null,
+  streamRetryTimer: 0,
+  term: null,
+  fitAddon: null,
+  searchAddon: null,
+  lastResize: { cols: 100, rows: 30 },
+  sessionItems: new Map(),
+  lastCursorControl: "",
+  terminalResponseBuffer: "",
+  wheelScrollRemainder: 0,
+  agentName: "",
+  chatConversationId: "",
+  chatHistory: [],
+  cmItems: [],
+  activityTasks: [],
+  activitySelectedTaskId: "",
+  activitySelectedTask: null,
+  activityTimelineTasks: [],
+  activityTimelineParentId: "",
+  activityTimelineRequestId: 0,
+  chatBusy: false,
+  activeChatTaskId: "",
+  activeChatRequestId: "",
+  completedChatTaskIds: new Set(),
+  chatComposing: false,
+  chatCompositionEndedAt: 0,
+  pageUnloading: false,
+  showSessionHistory: false,
+  activePage: "terminal",
+  resizeFrame: 0,
+  activationRequestId: 0,
+};
+const el = {
+  pageTabs: Array.from(document.querySelectorAll("[data-page-tab]")),
+  pagePanels: Array.from(document.querySelectorAll("[data-page-panel]")),
+  authStrip: document.getElementById("auth-strip"),
+  tokenInput: document.getElementById("token-input"),
+  tokenSave: document.getElementById("token-save"),
+  authMessage: document.getElementById("auth-message"),
+  startForm: document.getElementById("start-form"),
+  tool: document.getElementById("tool"),
+  inputMode: document.getElementById("input-mode"),
+  command: document.getElementById("command"),
+  args: document.getElementById("args"),
+  workdir: document.getElementById("workdir"),
+  label: document.getElementById("label"),
+  allowOutside: document.getElementById("allow-outside"),
+  list: document.getElementById("session-list"),
+  terminal: document.getElementById("terminal"),
+  statusText: document.getElementById("status-text"),
+  sizeText: document.getElementById("size-text"),
+  debugText: document.getElementById("debug-text"),
+  terminalSessionSelect: document.getElementById("terminal-session-select"),
+  activeStatus: document.getElementById("active-status"),
+  activeCommand: document.getElementById("active-command"),
+  sessionHistoryToggle: document.getElementById("session-history-toggle"),
+  refresh: document.getElementById("refresh"),
+  resize: document.getElementById("resize"),
+  stop: document.getElementById("stop"),
+  activeInputMode: document.getElementById("active-input-mode"),
+  searchBar: document.getElementById("search-bar"),
+  searchInput: document.getElementById("search-input"),
+  searchPrev: document.getElementById("search-prev"),
+  searchNext: document.getElementById("search-next"),
+  searchClose: document.getElementById("search-close"),
+  activityItems: document.getElementById("activity-items"),
+  activityDetail: document.getElementById("activity-detail"),
+  activityStatusFilter: document.getElementById("activity-status-filter"),
+  activityRouteFilter: document.getElementById("activity-route-filter"),
+  activitySearch: document.getElementById("activity-search"),
+  activityOverview: document.getElementById("activity-overview"),
+  activityRefresh: document.getElementById("activity-refresh"),
+  cmItems: document.getElementById("cm-items"),
+  chatMeta: document.getElementById("chat-meta"),
+  chatMessages: document.getElementById("chat-messages"),
+  chatForm: document.getElementById("chat-form"),
+  chatInput: document.getElementById("chat-input"),
+  chatSend: document.getElementById("chat-send"),
+  chatClear: document.getElementById("chat-clear"),
+};
+function initToken() {
+  const hash = new URLSearchParams(location.hash.slice(1));
+  const tokenFromHash = hash.get("token");
+  if (tokenFromHash) {
+    localStorage.setItem(TOKEN_STORAGE_KEY, tokenFromHash);
+    history.replaceState(null, "", location.pathname + location.search);
+  }
+  state.token = localStorage.getItem(TOKEN_STORAGE_KEY) || "";
+  setAuthVisible(!state.token, state.token ? "" : "Owner token required");
+  if (!state.token) setStatus("Owner token required", true);
+}
+function setStatus(text, error) {
+  el.statusText.textContent = text;
+  el.statusText.classList.toggle("status-error", error === true);
+}
+function setAuthVisible(show, message) {
+  el.authStrip.classList.toggle("show", show);
+  el.authMessage.textContent = message || "";
+  if (show) el.tokenInput.focus();
+}
+function setActivePage(page) {
+  const nextPage = ["terminal", "sessions", "activity", "akemon", "cm"].includes(page) ? page : "terminal";
+  state.activePage = nextPage;
+  el.pageTabs.forEach((tab) => {
+    const active = tab.dataset.pageTab === nextPage;
+    tab.classList.toggle("active", active);
+    tab.setAttribute("aria-selected", active ? "true" : "false");
+  });
+  el.pagePanels.forEach((panel) => {
+    panel.classList.toggle("active", panel.dataset.pagePanel === nextPage);
+  });
+  try {
+    localStorage.setItem(PAGE_STORAGE_KEY, nextPage);
+  } catch {
+    // Page choice is best-effort UI state.
+  }
+  if (nextPage === "terminal") {
+    requestTerminalResize(true, true);
+    setTimeout(() => requestTerminalResize(true, true), 60);
+    restoreTerminalFocus(false);
+  } else {
+    toggleSearch(false);
+  }
+  if (nextPage === "activity") refreshActivity({ quiet: true }).catch((error) => setStatus(error.message, true));
+}
+function initPageTabs() {
+  el.pageTabs.forEach((tab) => {
+    tab.addEventListener("click", () => setActivePage(tab.dataset.pageTab));
+  });
+  let page = "terminal";
+  try {
+    page = localStorage.getItem(PAGE_STORAGE_KEY) || page;
+  } catch {
+    // Page choice is best-effort UI state.
+  }
+  setActivePage(page);
+}
+function clearOwnerToken(message) {
+  localStorage.removeItem(TOKEN_STORAGE_KEY);
+  state.token = "";
+  if (state.streamAbort) state.streamAbort.abort();
+  clearStreamRetry();
+  state.sessions = [];
+  state.activeId = "";
+  renderSessions();
+  updateActiveHeader();
+  setAuthVisible(true, message || "Owner token required");
+  setStatus(message || "Owner token required", true);
+}
+function requireOwnerToken() {
+  if (state.token) return true;
+  setAuthVisible(true, "Owner token required");
+  setStatus("Owner token required", true);
+  return false;
+}
+function authHeaders(extra) {
+  const headers = Object.assign({}, extra || {});
+  if (state.token) headers.Authorization = "Bearer " + state.token;
+  return headers;
+}
+async function api(path, options) {
+  const init = options || {};
+  const headers = authHeaders(init.headers);
+  if (init.body !== undefined && !headers["Content-Type"]) {
+    headers["Content-Type"] = "application/json";
+  }
+  const res = await fetch(path, Object.assign({}, init, { headers }));
+  const text = await res.text();
+  let data = {};
+  try { data = text ? JSON.parse(text) : {}; }
+  catch { data = { output: text }; }
+  if (!res.ok) {
+    if (res.status === 401 || res.status === 403) {
+      const message = "Owner token rejected";
+      clearOwnerToken(message);
+      throw new Error(message);
+    }
+    throw new Error(data.error || text || "HTTP " + res.status);
+  }
+  return data;
+}
+function randomId(prefix) {
+  if (window.crypto && typeof window.crypto.randomUUID === "function") return window.crypto.randomUUID();
+  return (prefix || "id") + "_" + Date.now() + "_" + Math.random().toString(16).slice(2);
+}
+function chatConversationId() {
+  let id = localStorage.getItem(CHAT_CONVERSATION_KEY) || "";
+  if (!id) {
+    id = "workbench_" + Date.now() + "_" + Math.random().toString(16).slice(2, 10);
+    localStorage.setItem(CHAT_CONVERSATION_KEY, id);
+  }
+  state.chatConversationId = id;
+  return id;
+}
+function chatHistoryKey() {
+  return CHAT_HISTORY_PREFIX + chatConversationId();
+}
+function activeChatTaskKey() {
+  return ACTIVE_CHAT_TASK_PREFIX + chatConversationId();
+}
+function cmItemsKey() {
+  return CM_ITEMS_PREFIX + chatConversationId();
+}
+function normalizeCmItem(record) {
+  if (!record || typeof record !== "object") return null;
+  const type = typeof record.type === "string" ? record.type : "notice";
+  const title = typeof record.title === "string" ? record.title : "CM item";
+  const text = typeof record.text === "string" ? record.text : "";
+  const memoryProposal = record.memoryProposal && typeof record.memoryProposal === "object"
+    ? record.memoryProposal
+    : null;
+  if (!text && !memoryProposal) return null;
+  return {
+    id: typeof record.id === "string" && record.id ? record.id : randomId("cm"),
+    type,
+    title,
+    text,
+    status: typeof record.status === "string" ? record.status : "pending",
+    ts: typeof record.ts === "string" ? record.ts : new Date().toISOString(),
+    eventIds: record.eventIds && typeof record.eventIds === "object" ? record.eventIds : null,
+    memoryProposal,
+  };
+}
+function loadCmItems() {
+  try {
+    const raw = localStorage.getItem(cmItemsKey());
+    const parsed = raw ? JSON.parse(raw) : [];
+    state.cmItems = Array.isArray(parsed)
+      ? parsed.map(normalizeCmItem).filter(Boolean).slice(-CM_ITEMS_LIMIT)
+      : [];
+  } catch {
+    state.cmItems = [];
+  }
+  renderCmItems();
+}
+function saveCmItems() {
+  try {
+    const records = state.cmItems.slice(-CM_ITEMS_LIMIT);
+    state.cmItems = records;
+    localStorage.setItem(cmItemsKey(), JSON.stringify(records));
+  } catch {
+    // Local CM items are best-effort UI state.
+  }
+}
+function renderCmItems() {
+  el.cmItems.textContent = "";
+  if (!state.cmItems.length) {
+    const empty = document.createElement("div");
+    empty.className = "cm-empty";
+    empty.textContent = "No CM items yet.";
+    el.cmItems.appendChild(empty);
+    return;
+  }
+  state.cmItems.forEach((item) => {
+    el.cmItems.appendChild(renderCmItem(item));
+  });
+  el.cmItems.scrollTop = el.cmItems.scrollHeight;
+}
+function appendCmItem(item) {
+  const normalized = normalizeCmItem(Object.assign({
+    id: randomId("cm"),
+    ts: new Date().toISOString(),
+    status: "pending",
+  }, item));
+  if (!normalized) return;
+  state.cmItems.push(normalized);
+  saveCmItems();
+  renderCmItems();
+}
+async function refreshActivity(options) {
+  if (!state.token) {
+    if (!options || options.quiet !== true) requireOwnerToken();
+    return;
+  }
+  const data = await api(activityListPath(), { method: "GET" });
+  state.activityTasks = Array.isArray(data.tasks) ? data.tasks : [];
+  reconcileActiveChatTaskFromTasks(state.activityTasks);
+  reconcileActivitySelection();
+  renderActivity();
+  await renderSelectedActivityDetail({ quiet: options?.quiet === true });
+  if (!options || options.quiet !== true) setStatus("Activity refreshed");
+}
+function activityListPath() {
+  const params = new URLSearchParams();
+  params.set("limit", "50");
+  if (el.activityRouteFilter.value !== "interactive-session") params.set("visibility", "primary");
+  if (el.activityStatusFilter.value) params.set("status", el.activityStatusFilter.value);
+  if (el.activityRouteFilter.value) params.set("route", el.activityRouteFilter.value);
+  return "/self/tasks?" + params.toString();
+}
+function renderActivity() {
+  el.activityItems.textContent = "";
+  renderActivityOverview();
+  const visibleTasks = activityVisibleTasks();
+  if (!visibleTasks.length) {
+    const empty = document.createElement("div");
+    empty.className = "activity-empty";
+    empty.textContent = activityEmptyText();
+    el.activityItems.appendChild(empty);
+    return;
+  }
+  activityTaskGroups(visibleTasks).forEach((group) => {
+    const section = document.createElement("div");
+    section.className = "activity-group";
+    const head = document.createElement("div");
+    head.className = "activity-group-head";
+    const label = document.createElement("span");
+    label.textContent = group.label;
+    const count = document.createElement("span");
+    count.className = "activity-group-count";
+    count.textContent = String(group.tasks.length);
+    head.appendChild(label);
+    head.appendChild(count);
+    section.appendChild(head);
+    group.tasks.forEach((task) => {
+      section.appendChild(renderActivityTask(task));
+    });
+    el.activityItems.appendChild(section);
+  });
+}
+function activityVisibleTasks() {
+  return activityBaseTasks().filter((task) => activityMatchesSearch(task));
+}
+function activityBaseTasks() {
+  return state.activityTasks.filter((task) => !activityShouldHideTask(task));
+}
+function activitySearchTerm() {
+  return (el.activitySearch.value || "").trim().toLowerCase();
+}
+function activityMatchesSearch(task) {
+  const term = activitySearchTerm();
+  if (!term) return true;
+  const view = taskSurfaceView(task);
+  const text = [
+    task.taskId,
+    view?.title,
+    view?.summary,
+    view?.nextAction,
+    view?.ownerStatus,
+    view?.stage?.label,
+    task.title,
+    task.objective,
+    task.summary,
+    task.ownerStatus,
+    task.nextAction,
+    activityStageLabel(task.stage),
+    activityStatusLabel(task.status, task),
+    activityRouteLabel(task),
+    activityRelatedLabel(task),
+    activityListSummary(task),
+  ].filter(Boolean).join(" ").toLowerCase();
+  return text.includes(term);
+}
+function reconcileActivitySelection() {
+  const visibleTasks = activityVisibleTasks();
+  const selected = visibleTasks.find((task) => task.taskId === state.activitySelectedTaskId);
+  if (!selected) {
+    state.activitySelectedTaskId = visibleTasks[0]?.taskId || "";
+    state.activitySelectedTask = visibleTasks[0] || null;
+  } else {
+    state.activitySelectedTask = selected;
+  }
+}
+function renderActivityOverview() {
+  el.activityOverview.textContent = "";
+  const counts = activityStatusCounts(activityBaseTasks());
+  [
+    ["Open", counts.open],
+    ["Running", counts.running],
+    ["Waiting", counts.waiting],
+    ["Failed", counts.failed],
+    ["Done", counts.done],
+  ].forEach(([labelText, valueText]) => {
+    const metric = document.createElement("div");
+    metric.className = "activity-metric";
+    const label = document.createElement("span");
+    label.className = "activity-metric-label";
+    label.textContent = labelText;
+    const value = document.createElement("span");
+    value.className = "activity-metric-value";
+    value.textContent = String(valueText);
+    metric.appendChild(label);
+    metric.appendChild(value);
+    el.activityOverview.appendChild(metric);
+  });
+}
+function activityStatusCounts(tasks) {
+  const counts = { open: 0, running: 0, waiting: 0, failed: 0, done: 0 };
+  tasks.forEach((task) => {
+    if (task.status === "running" || task.status === "pending") {
+      counts.running += 1;
+      counts.open += 1;
+    } else if (task.status === "waiting") {
+      counts.waiting += 1;
+      counts.open += 1;
+    } else if (task.status === "failed") {
+      counts.failed += 1;
+      counts.open += 1;
+    } else if (task.status === "succeeded" || task.status === "info") {
+      counts.done += 1;
+    }
+  });
+  return counts;
+}
+function activityTaskGroups(tasks) {
+  const groups = [
+    { key: "attention", label: "Needs attention", tasks: [] },
+    { key: "active", label: "Active", tasks: [] },
+    { key: "done", label: "Done", tasks: [] },
+    { key: "other", label: "Other", tasks: [] },
+  ];
+  const byKey = Object.fromEntries(groups.map((group) => [group.key, group]));
+  tasks.forEach((task) => {
+    byKey[activityTaskGroupKey(task)].tasks.push(task);
+  });
+  return groups.filter((group) => group.tasks.length);
+}
+function activityTaskGroupKey(task) {
+  if (task.status === "failed" || task.status === "waiting") return "attention";
+  if (task.status === "running" || task.status === "pending") return "active";
+  if (task.status === "succeeded" || task.status === "info") return "done";
+  return "other";
+}
+function activityEmptyText() {
+  if (!state.activityTasks.length) return "No activity yet.";
+  if (activitySearchTerm()) return "No matching activity.";
+  if (el.activityStatusFilter.value || el.activityRouteFilter.value) return "No activity in this view.";
+  return "No activity yet.";
+}
+function activityShouldHideTask(task) {
+  if (el.activityRouteFilter.value || el.activityStatusFilter.value) return false;
+  return task?.visibility === "technical" || activityIsNoisyTerminalControl(task);
+}
+function activityIsNoisyTerminalControl(task) {
+  return (task?.route === "interactive-session" || task?.source === "workbench_http" || readActivityDataText(task, "source") === "workbench_http")
+    && task?.status === "succeeded"
+    && readActivityDataText(task, "capability") === "resize_session";
+}
+function renderActivityTask(task) {
+  const box = document.createElement("button");
+  box.type = "button";
+  box.className = "activity-item";
+  if (task.taskId && task.taskId === state.activitySelectedTaskId) box.classList.add("selected");
+  box.dataset.taskId = task.taskId || "";
+  box.addEventListener("click", () => selectActivityTask(task.taskId));
+  const head = document.createElement("div");
+  head.className = "activity-item-head";
+  const title = document.createElement("div");
+  title.className = "activity-item-title";
+  title.textContent = activityTaskTitle(task);
+  const status = document.createElement("span");
+  status.className = activityStatusClass(task.status);
+  status.textContent = activityStatusLabel(task.status, task);
+  head.appendChild(title);
+  head.appendChild(status);
+  box.appendChild(head);
+  const meta = document.createElement("div");
+  meta.className = "activity-item-meta";
+  meta.textContent = [
+    activityRouteLabel(task),
+    activityRelatedLabel(task),
+    formatShortTime(task.updatedAt || task.createdAt),
+  ].filter(Boolean).join(" · ");
+  box.appendChild(meta);
+  const summaryText = activityListSummary(task);
+  if (summaryText) {
+    const summary = document.createElement("div");
+    summary.className = "activity-item-summary";
+    summary.textContent = summaryText;
+    box.appendChild(summary);
+  }
+  return box;
+}
+async function selectActivityTask(taskId, fallbackTask) {
+  if (!taskId) return;
+  state.activitySelectedTaskId = taskId;
+  state.activitySelectedTask = state.activityTasks.find((task) => task.taskId === taskId) || fallbackTask || null;
+  renderActivity();
+  renderActivityDetail(state.activitySelectedTask, { loading: true });
+  try {
+    const data = await api("/self/tasks/" + encodeURIComponent(taskId), { method: "GET" });
+    if (state.activitySelectedTaskId !== taskId) return;
+    state.activitySelectedTask = data.task || state.activitySelectedTask;
+    await renderSelectedActivityDetail();
+  } catch (error) {
+    if (state.activitySelectedTaskId !== taskId) return;
+    setStatus(error.message, true);
+    renderActivityDetail(state.activitySelectedTask);
+  }
+}
+async function renderSelectedActivityDetail(options) {
+  const task = state.activitySelectedTask;
+  state.activityTimelineTasks = [];
+  state.activityTimelineParentId = activityTimelineParentId(task);
+  if (!task) {
+    renderActivityDetail(null);
+    return;
+  }
+  const parentTaskId = state.activityTimelineParentId;
+  if (!parentTaskId || !state.token) {
+    renderActivityDetail(task);
+    return;
+  }
+  renderActivityDetail(task, { timelineLoading: true });
+  try {
+    const timelineTasks = await fetchActivityTimelineTasks(parentTaskId, task.taskId);
+    if (state.activitySelectedTaskId !== task.taskId || state.activityTimelineParentId !== parentTaskId) return;
+    state.activityTimelineTasks = timelineTasks;
+    renderActivityDetail(state.activitySelectedTask);
+  } catch (error) {
+    if (options?.quiet === true) {
+      renderActivityDetail(state.activitySelectedTask);
+      return;
+    }
+    setStatus(error.message, true);
+    renderActivityDetail(state.activitySelectedTask);
+  }
+}
+async function fetchActivityTimelineTasks(parentTaskId, selectedTaskId) {
+  const requestId = ++state.activityTimelineRequestId;
+  const params = new URLSearchParams();
+  params.set("visibility", "technical");
+  params.set("parentTaskId", parentTaskId);
+  params.set("limit", "30");
+  const data = await api("/self/tasks?" + params.toString(), { method: "GET" });
+  if (requestId !== state.activityTimelineRequestId) return [];
+  const tasks = Array.isArray(data.tasks) ? data.tasks : [];
+  return tasks.filter((task) => task.taskId !== selectedTaskId);
+}
+function activityStatusClass(status) {
+  if (status === "running" || status === "waiting" || status === "pending") return "status-pill status-running";
+  if (status === "failed") return "status-pill status-failed";
+  return "status-pill status-ended";
+}
+function activityStatusLabel(status, task) {
+  const view = taskSurfaceView(task);
+  if (view?.stage?.label) return view.stage.label;
+  const stage = activityStageLabel(task?.stage);
+  if (stage) return stage;
+  if (task?.ownerStatus) return task.ownerStatus;
+  if (status === "pending") return "Queued";
+  if (status === "running") return "Running";
+  if (status === "waiting") {
+    const retryAt = readActivityDataText(task, "nextRetryAt");
+    return retryAt ? "Retry waiting" : "Waiting";
+  }
+  if (status === "succeeded") return "Done";
+  if (status === "failed") return "Failed";
+  if (status === "info") return "Info";
+  return "Queued";
+}
+function activityStageLabel(stage) {
+  const labels = {
+    queued: "Queued",
+    framing: "Framing",
+    dispatching: "Dispatching",
+    executing: "Executing",
+    observing: "Observing",
+    reviewing: "Reviewing",
+    done: "Done",
+    blocked: "Blocked",
+  };
+  return labels[stage] || "";
+}
+function activityRouteLabel(task) {
+  const route = task?.route || task?.source || "";
+  const labels = {
+    core_cm: "Akemon",
+    "interactive-session": "Terminal",
+    "software-agent": "Software agent",
+    "relay-order": "Order",
+    "user-task": "Scheduled task",
+    "relay-task": "Relay task",
+    memory_cm: "Memory",
+    relay_order: "Order",
+    owner_recurring_task: "Scheduled task",
+    relay_platform_task: "Relay task",
+    local_chat: "Akemon",
+    local_chat_command: "Command",
+    workbench_http: "Terminal",
+  };
+  return labels[route] || prettifyActivityToken(route || "task");
+}
+function activityTaskTitle(task) {
+  const view = taskSurfaceView(task);
+  if (view?.title) return view.title;
+  if (task?.title) return task.title;
+  const terminalTitle = interactiveSessionActionTitle(task);
+  if (terminalTitle) return terminalTitle;
+  const related = activityRelatedLabel(task);
+  const route = activityRouteLabel(task);
+  if (related) return `${route}: ${related}`;
+  return task.objective || task.summary || route || "Task";
+}
+function activityRelatedLabel(task) {
+  const product = readActivityDataText(task, "productName");
+  const order = readActivityDataText(task, "orderId");
+  if (product && order) return `${product} (${shortActivityId(order)})`;
+  if (product) return product;
+  if (order) return `Order ${shortActivityId(order)}`;
+  const session = readActivityDataText(task, "sessionId");
+  if (session) return `Session ${shortActivityId(session)}`;
+  const softwareId = readActivityDataText(task, "softwareAgentId");
+  if (softwareId) return prettifyActivityToken(softwareId);
+  const taskKey = readActivityDataText(task, "taskKey");
+  if (taskKey) return taskKey;
+  const relayTaskType = readActivityDataText(task, "relayTaskType");
+  if (relayTaskType) return prettifyActivityToken(relayTaskType);
+  return "";
+}
+function activityListSummary(task) {
+  const view = taskSurfaceView(task);
+  const terminalSummary = interactiveSessionActionSummary(task);
+  if (terminalSummary) return terminalSummary;
+  if (view?.summary) return view.summary;
+  if (view?.nextAction && task.status !== "succeeded") return view.nextAction;
+  if (task.nextAction && task.status !== "succeeded") return task.nextAction;
+  const error = readActivityDataText(task, "error");
+  if (error) return `Error: ${error}`;
+  const retryAt = readActivityDataText(task, "nextRetryAt");
+  if (retryAt) return `Next retry: ${formatDateTime(retryAt)}`;
+  const output = readActivityDataText(task, "outputSummary");
+  if (output) return output;
+  return task.summary || task.objective || "";
+}
+function renderActivityDetail(task, options) {
+  el.activityDetail.textContent = "";
+  if (!task) {
+    const empty = document.createElement("div");
+    empty.className = "activity-detail-empty";
+    empty.textContent = "No task selected.";
+    el.activityDetail.appendChild(empty);
+    return;
+  }
+  const card = document.createElement("div");
+  card.className = "activity-detail-card";
+  const head = document.createElement("div");
+  head.className = "activity-detail-head";
+  const titleBlock = document.createElement("div");
+  const kicker = document.createElement("div");
+  kicker.className = "activity-detail-kicker";
+  kicker.textContent = activityRouteLabel(task);
+  const title = document.createElement("div");
+  title.className = "activity-detail-title";
+  title.textContent = task.title || interactiveSessionActionTitle(task) || task.objective || activityTaskTitle(task);
+  titleBlock.appendChild(kicker);
+  titleBlock.appendChild(title);
+  const status = document.createElement("span");
+  status.className = activityStatusClass(task.status);
+  status.textContent = options?.loading ? "Loading" : activityStatusLabel(task.status, task);
+  head.appendChild(titleBlock);
+  head.appendChild(status);
+  card.appendChild(head);
+  const stateText = activityStateText(task);
+  if (stateText) {
+    const summary = document.createElement("div");
+    summary.className = "activity-detail-summary";
+    summary.textContent = stateText;
+    card.appendChild(summary);
+  }
+  card.appendChild(renderActivityDetailGroup("Current state", activityCurrentFields(task)));
+  const relatedFields = activityRelatedFields(task);
+  if (relatedFields.length) card.appendChild(renderActivityDetailGroup("Related", relatedFields));
+  const dispatchText = activityDispatchText(task);
+  if (dispatchText) card.appendChild(renderActivityTextSection("Dispatch records", dispatchText));
+  const reviewText = activityReviewText(task);
+  if (reviewText) card.appendChild(renderActivityTextSection("Review records", reviewText));
+  const followUpText = activityFollowUpText(task);
+  if (followUpText) card.appendChild(renderActivityTextSection("Queued follow-ups", followUpText));
+  const resultText = activityResultText(task);
+  if (resultText) card.appendChild(renderActivityTextSection("Result", resultText));
+  const retryAt = readActivityDataText(task, "nextRetryAt");
+  if (retryAt) card.appendChild(renderActivityTextSection("Next retry", formatDateTime(retryAt)));
+  const timelineTasks = activityTimelineTasksFor(task);
+  if (timelineTasks.length || options?.timelineLoading) {
+    card.appendChild(renderActivityTimeline(timelineTasks, options?.timelineLoading));
+  }
+  card.appendChild(renderActivityTechnicalDetails(task));
+  el.activityDetail.appendChild(card);
+}
+function activityTimelineParentId(task) {
+  if (!task) return "";
+  if (task.parentTaskId) return task.parentTaskId;
+  const sessionId = readActivityDataText(task, "sessionId");
+  if ((task.route === "interactive-session" || task.source === "workbench_http") && sessionId) {
+    return `interactive-session:${sessionId}`;
+  }
+  return task.taskId || "";
+}
+function activityTimelineTasksFor(task) {
+  const parentTaskId = activityTimelineParentId(task);
+  if (!parentTaskId || state.activityTimelineParentId !== parentTaskId) return [];
+  return state.activityTimelineTasks;
+}
+function activityStateText(task) {
+  const view = taskSurfaceView(task);
+  const terminalSummary = interactiveSessionActionSummary(task);
+  if (terminalSummary) return terminalSummary;
+  if (view?.stage?.description) return view.stage.description;
+  const stageText = activityStageText(task);
+  if (stageText) return stageText;
+  if (task.status === "waiting") {
+    const retryAt = readActivityDataText(task, "nextRetryAt");
+    if (retryAt) return `Waiting until ${formatDateTime(retryAt)} before retrying.`;
+    return "Waiting for another system or retry window.";
+  }
+  if (task.status === "running") return "Currently being worked on.";
+  if (task.status === "pending") return "Queued and not started yet.";
+  if (task.status === "succeeded") return "Finished successfully.";
+  if (task.status === "failed") return "Stopped with an error.";
+  return task.summary || "";
+}
+function activityStageText(task) {
+  if (!task?.stage) return "";
+  const summary = task.summary || task.nextAction || "";
+  const texts = {
+    queued: "Queued and waiting to start.",
+    framing: "Akemon is framing the owner request.",
+    dispatching: "Akemon is dispatching work to a capability.",
+    executing: "Execution is in progress.",
+    observing: "Akemon is observing the execution result.",
+    reviewing: "Akemon is reviewing the result for the owner report.",
+    done: "Finished.",
+    blocked: "Blocked.",
+  };
+  const text = texts[task.stage] || "";
+  if (!text) return "";
+  return summary && summary !== text ? `${text} ${summary}` : text;
+}
+function interactiveSessionActionTitle(task) {
+  if (task?.route !== "interactive-session") return "";
+  const label = interactiveSessionCapabilityLabel(readActivityDataText(task, "capability"));
+  if (!label) return "";
+  const related = activityRelatedLabel(task);
+  return related ? `${label}: ${related}` : label;
+}
+function interactiveSessionActionSummary(task) {
+  if (task?.route !== "interactive-session") return "";
+  const capability = readActivityDataText(task, "capability");
+  const session = readActivityDataText(task, "sessionId");
+  const target = session ? ` for ${shortActivityId(session)}` : "";
+  if (task.status === "failed") {
+    const error = readActivityDataText(task, "error");
+    return error ? `${interactiveSessionCapabilityLabel(capability) || "Terminal action"} failed: ${error}` : `${interactiveSessionCapabilityLabel(capability) || "Terminal action"} failed.`;
+  }
+  if (capability === "resize_session") return `Terminal size updated${target}.`;
+  if (capability === "start_session") return `Terminal session started${target}.`;
+  if (capability === "send_input") return `Input sent to terminal${target}.`;
+  if (capability === "stop_session") return `Terminal session stopped${target}.`;
+  if (capability === "inspect_session") return `Terminal session inspected${target}.`;
+  if (capability === "set_input_mode") return `Terminal input mode changed${target}.`;
+  if (capability === "list_sessions") return "Terminal sessions listed.";
+  return "";
+}
+function interactiveSessionCapabilityLabel(capability) {
+  const labels = {
+    resize_session: "Resize terminal",
+    start_session: "Start terminal",
+    send_input: "Send input",
+    stop_session: "Stop terminal",
+    inspect_session: "Inspect terminal",
+    set_input_mode: "Input mode",
+    list_sessions: "List sessions",
+  };
+  return labels[capability] || "";
+}
+function activityCurrentFields(task) {
+  const view = taskSurfaceView(task);
+  const counts = view?.counts || {};
+  return [
+    { label: "State", value: activityStatusLabel(task.status, task) },
+    { label: "Stage", value: view?.stage?.label || activityStageLabel(task.stage) },
+    { label: "Kind", value: activityRouteLabel(task) },
+    { label: "Visibility", value: task.visibility === "technical" ? "Technical event" : "Primary task" },
+    { label: "Dispatches", value: counts.dispatches ? String(counts.dispatches) : (activityDispatchRecords(task).length ? String(activityDispatchRecords(task).length) : "") },
+    { label: "Reviews", value: counts.reviews ? String(counts.reviews) : (activityReviewRecords(task).length ? String(activityReviewRecords(task).length) : "") },
+    { label: "Follow-ups", value: counts.followUps ? String(counts.followUps) : (activityFollowUps(task).length ? String(activityFollowUps(task).length) : "") },
+    { label: "Next", value: view?.nextAction || task.nextAction },
+    { label: "Updated", value: formatDateTime(task.updatedAt) },
+    { label: "Started", value: formatDateTime(task.createdAt) },
+    { label: "Finished", value: formatDateTime(task.completedAt) },
+  ].filter((field) => field.value);
+}
+function activityRelatedFields(task) {
+  return [
+    { label: "Object", value: activityRelatedLabel(task) },
+    { label: "Order", value: readActivityDataText(task, "orderId") },
+    { label: "Product", value: readActivityDataText(task, "productName") || readActivityDataText(task, "productId") },
+    { label: "Session", value: readActivityDataText(task, "sessionId") },
+    { label: "Conversation", value: task.conversationId },
+    { label: "Parent", value: task.parentTaskId },
+    { label: "Software Ledger", value: readActivityDataText(task, "taskRecordPath") },
+  ].filter((field) => field.value);
+}
+function activityResultText(task) {
+  const view = taskSurfaceView(task);
+  if (view?.report?.text) return view.report.text;
+  const error = readActivityDataText(task, "error");
+  if (error) return `Error: ${error}`;
+  const output = readActivityDataText(task, "outputSummary");
+  if (output) return output;
+  if (task.status === "failed") return task.summary || "No error detail recorded.";
+  if (task.status === "succeeded") return task.summary || "No result detail recorded.";
+  return "";
+}
+function activityDispatchRecords(task) {
+  const view = taskSurfaceView(task);
+  if (Array.isArray(view?.dispatches)) {
+    return view.dispatches.map((record) => ({
+      target: typeof record.targetPeripheral === "string" ? record.targetPeripheral : "",
+      capability: typeof record.capability === "string" ? record.capability : "",
+      brief: typeof record.brief === "string" ? record.brief : "",
+      expectedDeliverable: typeof record.expectedDeliverable === "string" ? record.expectedDeliverable : "",
+      createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
+    })).filter((record) => record.target || record.capability);
+  }
+  const records = Array.isArray(task?.data?.dispatchRecords) ? task.data.dispatchRecords : [];
+  return records.map((record) => {
+    if (!record || typeof record !== "object") return null;
+    const target = typeof record.targetPeripheral === "string" ? record.targetPeripheral : "";
+    const capability = typeof record.capability === "string" ? record.capability : "";
+    if (!target && !capability) return null;
+    return {
+      target,
+      capability,
+      brief: typeof record.brief === "string" ? record.brief : "",
+      expectedDeliverable: typeof record.expectedDeliverable === "string" ? record.expectedDeliverable : "",
+      createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
+    };
+  }).filter(Boolean);
+}
+function activityDispatchText(task) {
+  const records = activityDispatchRecords(task);
+  if (!records.length) return "";
+  return records.slice(-5).map((record) => {
+    const time = record.createdAt ? formatShortTime(record.createdAt) : "";
+    const target = [record.target, record.capability].filter(Boolean).join(".");
+    const head = [target, time].filter(Boolean).join(" ");
+    const details = [record.brief, record.expectedDeliverable].filter(Boolean).join("\n");
+    return details ? `${head}\n${details}` : head;
+  }).join("\n\n");
+}
+function activityReviewRecords(task) {
+  const view = taskSurfaceView(task);
+  if (Array.isArray(view?.reviews)) {
+    return view.reviews.map((record) => ({
+      resultQuality: typeof record.resultQuality === "string" ? record.resultQuality : "",
+      completionDecision: typeof record.completionDecision === "string" ? record.completionDecision : "",
+      followUpNeeded: record.followUpNeeded === true,
+      reportText: typeof record.reportText === "string" ? record.reportText : "",
+      summary: typeof record.summary === "string" ? record.summary : "",
+      createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
+      memoryProposalRefs: Array.isArray(record.memoryProposalRefs) ? record.memoryProposalRefs : [],
+    })).filter((record) => record.resultQuality || record.completionDecision || record.reportText);
+  }
+  const records = Array.isArray(task?.data?.reviewRecords) ? task.data.reviewRecords : [];
+  return records.map((record) => {
+    if (!record || typeof record !== "object") return null;
+    const resultQuality = typeof record.resultQuality === "string" ? record.resultQuality : "";
+    const completionDecision = typeof record.completionDecision === "string" ? record.completionDecision : "";
+    const reportText = typeof record.reportText === "string" ? record.reportText : "";
+    if (!resultQuality && !completionDecision && !reportText) return null;
+    return {
+      resultQuality,
+      completionDecision,
+      followUpNeeded: record.followUpNeeded === true,
+      reportText,
+      summary: typeof record.summary === "string" ? record.summary : "",
+      createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
+      memoryProposalRefs: Array.isArray(record.memoryProposalRefs) ? record.memoryProposalRefs : [],
+    };
+  }).filter(Boolean);
+}
+function activityReviewText(task) {
+  const records = activityReviewRecords(task);
+  if (!records.length) return "";
+  return records.slice(-5).map((record) => {
+    const time = record.createdAt ? formatShortTime(record.createdAt) : "";
+    const decision = [
+      record.resultQuality ? prettifyActivityToken(record.resultQuality) : "",
+      record.completionDecision ? prettifyActivityToken(record.completionDecision) : "",
+      record.followUpNeeded ? "Follow-up needed" : "",
+    ].filter(Boolean).join(" · ");
+    const head = [decision, time].filter(Boolean).join(" ");
+    const memoryRefs = record.memoryProposalRefs.length
+      ? `Memory proposals: ${record.memoryProposalRefs.map((item) => (
+          item && typeof item === "object" && typeof item.memoryProposalId === "string" ? item.memoryProposalId : ""
+        )).filter(Boolean).join(", ")}`
+      : "";
+    return [head, record.summary, memoryRefs, record.reportText].filter(Boolean).join("\n");
+  }).join("\n\n");
+}
+function activityFollowUps(task) {
+  const view = taskSurfaceView(task);
+  if (Array.isArray(view?.followUps)) {
+    return view.followUps.map((item) => ({
+      kind: typeof item.kind === "string" ? item.kind : "note",
+      text: typeof item.text === "string" ? item.text.trim() : "",
+      createdAt: typeof item.createdAt === "string" ? item.createdAt : "",
+    })).filter((item) => item.text);
+  }
+  const items = Array.isArray(task?.data?.followUps) ? task.data.followUps : [];
+  return items.map((item) => {
+    if (!item || typeof item !== "object") return null;
+    const text = typeof item.text === "string" ? item.text.trim() : "";
+    if (!text) return null;
+    const kind = typeof item.kind === "string" ? item.kind : "note";
+    const createdAt = typeof item.createdAt === "string" ? item.createdAt : "";
+    return { kind, text, createdAt };
+  }).filter(Boolean);
+}
+function activityFollowUpText(task) {
+  const items = activityFollowUps(task);
+  if (!items.length) return "";
+  return items.slice(-5).map((item) => {
+    const time = item.createdAt ? formatShortTime(item.createdAt) : "";
+    const prefix = [prettifyActivityToken(item.kind), time].filter(Boolean).join(" ");
+    return prefix ? `${prefix}: ${item.text}` : item.text;
+  }).join("\n");
+}
+function renderActivityDetailGroup(titleText, fields) {
+  const section = document.createElement("div");
+  section.className = "activity-detail-section";
+  const title = document.createElement("div");
+  title.className = "activity-detail-section-title";
+  title.textContent = titleText;
+  const grid = document.createElement("div");
+  grid.className = "activity-detail-grid";
+  fields.forEach((field) => {
+    grid.appendChild(renderActivityDetailField(field.label, field.value));
+  });
+  section.appendChild(title);
+  section.appendChild(grid);
+  return section;
+}
+function renderActivityDetailField(labelText, valueText) {
+  const field = document.createElement("div");
+  field.className = "activity-detail-field";
+  const label = document.createElement("div");
+  label.className = "activity-detail-label";
+  label.textContent = labelText;
+  const value = document.createElement("div");
+  value.className = "activity-detail-value";
+  value.textContent = valueText;
+  field.appendChild(label);
+  field.appendChild(value);
+  return field;
+}
+function renderActivityTextSection(titleText, bodyText) {
+  const section = document.createElement("div");
+  section.className = "activity-detail-section";
+  const title = document.createElement("div");
+  title.className = "activity-detail-section-title";
+  title.textContent = titleText;
+  const body = document.createElement("div");
+  body.className = "activity-detail-text";
+  body.textContent = bodyText;
+  section.appendChild(title);
+  section.appendChild(body);
+  return section;
+}
+function renderActivityTimeline(tasks, loading) {
+  const section = document.createElement("div");
+  section.className = "activity-detail-section";
+  const title = document.createElement("div");
+  title.className = "activity-detail-section-title";
+  title.textContent = "Timeline";
+  const list = document.createElement("div");
+  list.className = "activity-timeline";
+  if (loading) {
+    const empty = document.createElement("div");
+    empty.className = "activity-timeline-empty";
+    empty.textContent = "Loading related events.";
+    list.appendChild(empty);
+  } else {
+    tasks.slice()
+      .sort((a, b) => activityTimestamp(a) - activityTimestamp(b))
+      .forEach((task) => list.appendChild(renderActivityTimelineItem(task)));
+  }
+  section.appendChild(title);
+  section.appendChild(list);
+  return section;
+}
+function renderActivityTimelineItem(task) {
+  const item = document.createElement("button");
+  item.type = "button";
+  item.className = "activity-timeline-item";
+  item.addEventListener("click", () => selectActivityTask(task.taskId, task));
+  const row = document.createElement("div");
+  row.className = "activity-timeline-row";
+  const title = document.createElement("div");
+  title.className = "activity-timeline-title";
+  title.textContent = task.title || activityTaskTitle(task);
+  const time = document.createElement("div");
+  time.className = "activity-timeline-time";
+  time.textContent = formatShortTime(task.updatedAt || task.createdAt);
+  row.appendChild(title);
+  row.appendChild(time);
+  item.appendChild(row);
+  const summaryText = activityListSummary(task);
+  if (summaryText) {
+    const summary = document.createElement("div");
+    summary.className = "activity-timeline-summary";
+    summary.textContent = summaryText;
+    item.appendChild(summary);
+  }
+  return item;
+}
+function activityTimestamp(task) {
+  const raw = task?.createdAt || task?.updatedAt || "";
+  const value = Date.parse(raw);
+  return Number.isFinite(value) ? value : 0;
+}
+function renderActivityTechnicalDetails(task) {
+  const details = document.createElement("details");
+  details.className = "activity-technical";
+  const summary = document.createElement("summary");
+  summary.textContent = "Technical details";
+  details.appendChild(summary);
+  details.appendChild(renderActivityDetailField("Task ID", task.taskId || ""));
+  if (task.route) details.appendChild(renderActivityDetailField("Route", task.route));
+  if (task.source) details.appendChild(renderActivityDetailField("Source", task.source));
+  if (task.refs && task.refs.length) {
+    details.appendChild(renderActivityPreBlock("Refs", JSON.stringify(task.refs, null, 2)));
+  }
+  if (task.data && Object.keys(task.data).length) {
+    details.appendChild(renderActivityPreBlock("Data", JSON.stringify(task.data, null, 2)));
+  }
+  return details;
+}
+function renderActivityPreBlock(titleText, bodyText) {
+  const section = document.createElement("div");
+  section.className = "activity-detail-section";
+  const title = document.createElement("div");
+  title.className = "activity-detail-section-title";
+  title.textContent = titleText;
+  const body = document.createElement("pre");
+  body.className = "activity-detail-pre";
+  body.textContent = bodyText;
+  section.appendChild(title);
+  section.appendChild(body);
+  return section;
+}
+function readActivityDataText(task, key) {
+  const value = task?.data?.[key];
+  if (typeof value === "string" && value.trim()) return value.trim();
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "";
+}
+function shortActivityId(value) {
+  const text = String(value || "");
+  if (text.length <= 18) return text;
+  return `${text.slice(0, 8)}...${text.slice(-6)}`;
+}
+function prettifyActivityToken(value) {
+  const text = String(value || "").trim();
+  if (!text) return "";
+  return text
+    .replace(/[_:-]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function formatDateTime(value) {
+  const time = Date.parse(value || "");
+  if (!Number.isFinite(time)) return "";
+  return new Date(time).toLocaleString([], {
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+function renderCmItem(item) {
+  const box = document.createElement("div");
+  box.className = "cm-item";
+  box.dataset.cmItemId = item.id;
+  const head = document.createElement("div");
+  head.className = "cm-item-head";
+  const kind = document.createElement("div");
+  kind.className = "cm-item-kind";
+  kind.textContent = item.title || item.type;
+  const time = document.createElement("div");
+  time.className = "cm-item-time";
+  time.textContent = formatShortTime(item.ts);
+  head.appendChild(kind);
+  head.appendChild(time);
+  box.appendChild(head);
+  if (item.text && !item.memoryProposal) {
+    const text = document.createElement("div");
+    text.className = "memory-proposal-text";
+    text.textContent = item.text;
+    box.appendChild(text);
+  }
+  if (item.memoryProposal) {
+    box.appendChild(renderMemoryProposal(item.memoryProposal, { readonly: item.status !== "pending" }));
+  }
+  return box;
+}
+function formatShortTime(value) {
+  const time = Date.parse(value || "");
+  if (!Number.isFinite(time)) return "";
+  return new Date(time).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+}
+function normalizeChatHistoryRecord(record) {
+  if (!record || typeof record !== "object") return null;
+  const role = record.role === "user" ? "user" : "akemon";
+  const text = typeof record.text === "string" ? record.text : "";
+  const memoryProposal = record.memoryProposal && typeof record.memoryProposal === "object"
+    ? record.memoryProposal
+    : null;
+  const task = record.task && typeof record.task === "object" ? record.task : null;
+  if (!text && !memoryProposal) return null;
+  return {
+    role,
+    text,
+    error: record.error === true,
+    memoryProposal,
+    task,
+    ts: typeof record.ts === "string" ? record.ts : "",
+  };
+}
+function loadChatHistory() {
+  try {
+    const raw = localStorage.getItem(chatHistoryKey());
+    const parsed = raw ? JSON.parse(raw) : [];
+    state.chatHistory = Array.isArray(parsed)
+      ? parsed.map(normalizeChatHistoryRecord).filter(Boolean).slice(-CHAT_HISTORY_LIMIT)
+      : [];
+  } catch {
+    state.chatHistory = [];
+  }
+  renderChatHistory();
+}
+function saveChatHistory() {
+  try {
+    const records = state.chatHistory.slice(-CHAT_HISTORY_LIMIT);
+    state.chatHistory = records;
+    localStorage.setItem(chatHistoryKey(), JSON.stringify(records));
+  } catch {
+    // Local history is best-effort UI state.
+  }
+}
+function renderChatHistory() {
+  el.chatMessages.textContent = "";
+  if (!state.chatHistory.length) {
+    const empty = document.createElement("div");
+    empty.className = "chat-empty";
+    empty.textContent = "No messages.";
+    el.chatMessages.appendChild(empty);
+    return;
+  }
+  state.chatHistory.forEach((record) => {
+    appendChatMessage(record.role, record.text, record.error, {
+      fromHistory: true,
+      memoryProposal: record.memoryProposal,
+      task: record.task,
+    });
+  });
+}
+function clearChatHistory() {
+  state.chatHistory = [];
+  try {
+    localStorage.removeItem(chatHistoryKey());
+  } catch {
+    // Local history is best-effort UI state.
+  }
+  renderChatHistory();
+  setStatus("Chat cleared");
+}
+function updateStoredMemoryProposalStatus(proposalId, statusText) {
+  let updated = false;
+  for (let i = state.chatHistory.length - 1; i >= 0; i -= 1) {
+    const proposal = state.chatHistory[i].memoryProposal;
+    if (!proposal || typeof proposal !== "object") continue;
+    if ((proposalId && proposal.id === proposalId) || (!proposalId && !updated)) {
+      proposal.uiStatus = statusText;
+      updated = true;
+      if (proposalId) break;
+    }
+  }
+  if (updated) saveChatHistory();
+}
+function updateStoredCmMemoryProposalStatus(proposalId, statusText) {
+  let updated = false;
+  for (let i = state.cmItems.length - 1; i >= 0; i -= 1) {
+    const item = state.cmItems[i];
+    const proposal = item && item.memoryProposal;
+    if (!proposal || typeof proposal !== "object") continue;
+    if ((proposalId && proposal.id === proposalId) || (!proposalId && !updated)) {
+      proposal.uiStatus = statusText;
+      item.status = /ignored/i.test(statusText) ? "ignored" : "accepted";
+      updated = true;
+      if (proposalId) break;
+    }
+  }
+  if (updated) {
+    saveCmItems();
+    renderCmItems();
+  }
+}
+function taskSurfaceView(task) {
+  return task && task.view && typeof task.view === "object" ? task.view : null;
+}
+function rememberAgentName(agentName) {
+  if (typeof agentName !== "string" || !agentName.trim()) return;
+  state.agentName = agentName.trim();
+  el.chatMeta.textContent = state.agentName;
+}
+function isChatTaskActive(task) {
+  if (!task || typeof task !== "object") return false;
+  if (task.stage === "done" || task.stage === "blocked") return false;
+  if (task.status === "succeeded" || task.status === "failed" || task.status === "info") return false;
+  return true;
+}
+function isStaleChatTask(task) {
+  if (!task || typeof task !== "object") return false;
+  const createdAt = typeof task.createdAt === "string" ? Date.parse(task.createdAt) : NaN;
+  if (!Number.isFinite(createdAt)) return false;
+  return Date.now() - createdAt > CHAT_ACTIVE_TASK_RECOVERY_MS;
+}
+function isRecoverableChatTask(task) {
+  if (!isChatTaskActive(task)) return false;
+  if (isStaleChatTask(task)) return false;
+  const data = task.data && typeof task.data === "object" ? task.data : {};
+  return task.route === "core_cm"
+    && data.source === "local_chat"
+    && task.conversationId === chatConversationId();
+}
+function persistActiveChatTask(record) {
+  if (!record || !record.taskId) return;
+  try {
+    localStorage.setItem(activeChatTaskKey(), JSON.stringify({
+      taskId: record.taskId,
+      requestId: record.requestId || "",
+      conversationId: chatConversationId(),
+      startedAt: record.startedAt || new Date().toISOString(),
+    }));
+  } catch {
+    // Active task recovery is best-effort UI state.
+  }
+}
+function loadPersistedActiveChatTask() {
+  try {
+    const raw = localStorage.getItem(activeChatTaskKey());
+    const parsed = raw ? JSON.parse(raw) : null;
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.taskId !== "string" || !parsed.taskId) return null;
+    const startedAt = typeof parsed.startedAt === "string" ? parsed.startedAt : "";
+    const ageMs = Date.now() - Date.parse(startedAt || "0");
+    if (Number.isFinite(ageMs) && ageMs > CHAT_ACTIVE_TASK_RECOVERY_MS) {
+      localStorage.removeItem(activeChatTaskKey());
+      return null;
+    }
+    return {
+      taskId: parsed.taskId,
+      requestId: typeof parsed.requestId === "string" ? parsed.requestId : "",
+      startedAt,
+    };
+  } catch {
+    return null;
+  }
+}
+function clearPersistedActiveChatTask(taskId) {
+  try {
+    const active = loadPersistedActiveChatTask();
+    if (!active || !taskId || active.taskId === taskId) {
+      localStorage.removeItem(activeChatTaskKey());
+    }
+  } catch {
+    // Active task recovery is best-effort UI state.
+  }
+}
+function restoreActiveChatTask(record, options) {
+  if (!record || !record.taskId) return;
+  state.activeChatTaskId = record.taskId;
+  state.activeChatRequestId = record.requestId || "";
+  setChatBusy(true);
+  if (!options || options.status !== false) {
+    setStatus("Akemon is still handling the previous request");
+  }
+}
+function clearActiveChatTask(taskId, options) {
+  if (taskId && state.activeChatTaskId && state.activeChatTaskId !== taskId) return;
+  const clearedTaskId = state.activeChatTaskId || taskId || "";
+  state.activeChatTaskId = "";
+  state.activeChatRequestId = "";
+  setChatBusy(false);
+  clearPersistedActiveChatTask(clearedTaskId);
+  if (!options || options.status !== false) setStatus("Akemon is ready");
+}
+function restoreActiveChatTaskFromStorage() {
+  const active = loadPersistedActiveChatTask();
+  if (!active) return;
+  restoreActiveChatTask(active, { status: false });
+}
+function reconcileActiveChatTaskFromTasks(tasks) {
+  if (!Array.isArray(tasks)) return;
+  if (state.activeChatTaskId) {
+    const current = tasks.find((task) => task && task.taskId === state.activeChatTaskId);
+    if (current && (isStaleChatTask(current) || !isChatTaskActive(current))) {
+      clearActiveChatTask(current.taskId, { status: false });
+    }
+    return;
+  }
+  const active = tasks.find(isRecoverableChatTask);
+  if (active) {
+    persistActiveChatTask({ taskId: active.taskId, requestId: "", startedAt: active.createdAt || active.updatedAt });
+    restoreActiveChatTask({ taskId: active.taskId, requestId: "" }, { status: false });
+  }
+}
+async function refreshActiveChatTask(options) {
+  if (!state.token || !state.activeChatTaskId) return;
+  const taskId = state.activeChatTaskId;
+  try {
+    const data = await api("/self/tasks/" + encodeURIComponent(taskId), { method: "GET" });
+    const task = data.task || null;
+    if (task && isStaleChatTask(task)) {
+      clearActiveChatTask(taskId, { status: false });
+      if (!options || options.quiet !== true) setStatus("Akemon is ready");
+      return;
+    }
+    if (!task || !isChatTaskActive(task)) {
+      if (task) completeActiveChatTaskFromTask(task, { quiet: options?.quiet === true });
+      clearActiveChatTask(taskId, { status: options?.quiet === true ? false : true });
+      if (task && (!options || options.quiet !== true)) refreshActivity({ quiet: true }).catch(() => {});
+    } else if (!options || options.quiet !== true) {
+      setStatus(chatTaskSummary(task) || "Akemon is handling the request");
+    }
+  } catch (error) {
+    if (!options || options.quiet !== true) throw error;
+  }
+}
+function setChatBusy(busy) {
+  state.chatBusy = busy;
+  el.chatSend.disabled = false;
+  el.chatSend.textContent = busy ? "Queue" : "Send";
+}
+function chatTaskSummary(task) {
+  if (!task || typeof task !== "object") return "";
+  const view = taskSurfaceView(task);
+  const stage = view?.stage?.label || activityStageLabel(task.stage) || activityStatusLabel(task.status, task);
+  const summary = view?.summary || view?.nextAction || task.summary || task.nextAction || "";
+  return [stage, summary].filter(Boolean).join(" - ");
+}
+function appendChatMessage(role, text, error, options) {
+  options = options || {};
+  const empty = el.chatMessages.querySelector(".chat-empty");
+  if (empty) empty.remove();
+  const item = document.createElement("div");
+  item.className = "chat-message " + (role === "user" ? "user" : "akemon") + (error ? " error" : "");
+  const label = document.createElement("div");
+  label.className = "chat-message-role";
+  label.textContent = role === "user" ? "You" : "Akemon";
+  const body = document.createElement("div");
+  body.className = "chat-message-text";
+  body.textContent = text || "";
+  item.appendChild(label);
+  item.appendChild(body);
+  const taskText = chatTaskSummary(options.task);
+  if (taskText) {
+    const task = document.createElement("div");
+    task.className = "chat-message-task";
+    task.textContent = taskText;
+    item.appendChild(task);
+  }
+  el.chatMessages.appendChild(item);
+  el.chatMessages.scrollTop = el.chatMessages.scrollHeight;
+  if (options.memoryProposal && !options.fromHistory) {
+    appendCmItem({
+      type: "memory_proposal",
+      title: "Memory CM",
+      text: memoryProposalText(options.memoryProposal),
+      memoryProposal: options.memoryProposal,
+      eventIds: options.eventIds || null,
+    });
+  }
+  if (!options.fromHistory) {
+    state.chatHistory.push({
+      role: role === "user" ? "user" : "akemon",
+      text: text || "",
+      error: error === true,
+      task: options.task || null,
+      ts: new Date().toISOString(),
+    });
+    saveChatHistory();
+  }
+  return item;
+}
+function renderMemoryProposal(proposal, options) {
+  options = options || {};
+  const box = document.createElement("div");
+  box.className = "memory-proposal";
+  box.dataset.proposalId = proposal.id || "";
+  const title = document.createElement("div");
+  title.className = "memory-proposal-title";
+  title.textContent = "Memory suggestion";
+  box.appendChild(title);
+  const text = document.createElement("div");
+  text.className = "memory-proposal-text";
+  text.textContent = memoryProposalText(proposal);
+  box.appendChild(text);
+  const status = document.createElement("div");
+  status.className = "memory-proposal-status";
+  if (proposal.uiStatus) {
+    status.textContent = proposal.uiStatus;
+  }
+  if (!options.readonly && !proposal.uiStatus) {
+    const actions = document.createElement("div");
+    actions.className = "memory-proposal-actions";
+    const remember = document.createElement("button");
+    remember.className = "btn btn-primary";
+    remember.type = "button";
+    remember.textContent = "Remember";
+    remember.addEventListener("click", () => handleMemoryProposalAction(proposal, "accept", box));
+    const ignore = document.createElement("button");
+    ignore.className = "btn";
+    ignore.type = "button";
+    ignore.textContent = "Ignore";
+    ignore.addEventListener("click", () => handleMemoryProposalAction(proposal, "reject", box));
+    actions.appendChild(remember);
+    actions.appendChild(ignore);
+    box.appendChild(actions);
+  } else if (options.readonly && !status.textContent) {
+    status.textContent = "From local chat history.";
+  }
+  box.appendChild(status);
+  return box;
+}
+function memoryProposalText(proposal) {
+  const lines = [];
+  if (proposal.summary) lines.push(proposal.summary);
+  if (Array.isArray(proposal.self) && proposal.self.length) {
+    lines.push("Akemon can remember: " + proposal.self.join("; "));
+  }
+  if (Array.isArray(proposal.work) && proposal.work.length) {
+    lines.push("Work memory: " + proposal.work.join("; "));
+  }
+  if (!lines.length) return "Akemon found something that may be useful to remember.";
+  return lines.join("\n");
+}
+async function handleMemoryProposalAction(proposal, action, box) {
+  if (state.chatBusy) return;
+  const buttons = box.querySelectorAll("button");
+  buttons.forEach((button) => { button.disabled = true; });
+  const status = box.querySelector(".memory-proposal-status");
+  if (status) status.textContent = action === "accept" ? "Remembering..." : "Ignoring...";
+  setStatus(action === "accept" ? "Saving memory" : "Ignoring memory suggestion");
+  try {
+    const command = action === "accept"
+      ? `/memory accept ${proposal.id || "latest"} all`
+      : `/memory reject ${proposal.id || "latest"}`;
+    const result = await sendAkemonMessage(command);
+    const statusText = action === "accept" ? "Remembered." : "Ignored.";
+    if (status) status.textContent = statusText;
+    updateStoredMemoryProposalStatus(proposal.id || "", statusText);
+    updateStoredCmMemoryProposalStatus(proposal.id || "", statusText);
+    appendChatMessage("akemon", result.output, false, { task: result.task });
+    result.cmItems.forEach((item) => appendCmItem(item));
+    setStatus(action === "accept" ? "Memory saved" : "Memory suggestion ignored");
+  } catch (error) {
+    buttons.forEach((button) => { button.disabled = false; });
+    const message = friendlyChatError(error);
+    if (status) status.textContent = message;
+    setStatus(message, true);
+  }
+}
+function createAkemonChatMessage(text, options) {
+  options = options || {};
+  const message = {
+    schemaVersion: 1,
+    type: "akemon.message",
+    id: randomId("msg"),
+    source: { kind: "owner", id: "owner", transport: "local" },
+    target: { kind: "agent", id: state.agentName, transport: "local" },
+    createdAt: new Date().toISOString(),
+    conversationId: chatConversationId(),
+    memoryScope: "owner",
+    permissions: {},
+    transport: "local",
+    payload: {
+      text,
+      format: "text",
+      kind: "chat",
+    },
+  };
+  if (options.followUpForTaskId) {
+    message.metadata = { followUpForTaskId: options.followUpForTaskId };
+  }
+  return message;
+}
+function localChatTaskIdFromMessage(message) {
+  const suffix = message && message.id ? message.id : (message && message.conversationId ? message.conversationId : "local_" + Date.now());
+  return "task_" + String(suffix).replace(/[^a-zA-Z0-9_.:-]/g, "_");
+}
+async function ensureAgentName() {
+  if (state.agentName) return;
+  await refreshSessions({ quiet: true });
+  if (!state.agentName) throw new Error("Akemon name unavailable");
+}
+async function sendAkemonMessage(text, options) {
+  return sendAkemonMessageEnvelope(createAkemonChatMessage(text, options));
+}
+async function sendAkemonMessageEnvelope(message, options) {
+  options = options || {};
+  if (!requireOwnerToken()) throw new Error("Owner token required");
+  await ensureAgentName();
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), CHAT_REQUEST_TIMEOUT_MS);
+  try {
+    const data = await api("/self/message", {
+      method: "POST",
+      body: JSON.stringify(Object.assign({ message }, options.wait === false ? { wait: false } : {})),
+      signal: controller.signal,
+    });
+    const task = data.task || null;
+    const taskView = data.taskView || task?.view || null;
+    if (task && taskView && !task.view) task.view = taskView;
+    return {
+      accepted: data.accepted === true,
+      queued: data.queued === true,
+      async: data.async === true,
+      wait: data.wait,
+      output: normalizeAkemonOutput(data.output || (data.response && data.response.payload && data.response.payload.text) || ""),
+      memoryProposal: data.memoryProposal || null,
+      eventIds: data.eventIds || null,
+      cmItems: Array.isArray(data.cmItems) ? data.cmItems : [],
+      task,
+      taskView,
+    };
+  } catch (error) {
+    if (error && error.name === "AbortError") {
+      throw new Error("Akemon did not answer before the local request timed out.");
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function normalizeAkemonOutput(output) {
+  const text = String(output || "").trim();
+  if (!text) return "Akemon did not return any text for this message.";
+  const engineError = text.match(/^I could not complete the Core CM response because the engine returned an error:\s*(.+)$/i);
+  if (engineError) return `Akemon could not get a usable engine response: ${engineError[1]}`;
+  if (/engine returned an empty response/i.test(text)) {
+    return "Akemon's engine returned an empty response. Try sending the request again.";
+  }
+  return text;
+}
+function friendlyChatError(error) {
+  const name = error && error.name ? error.name : "";
+  const message = error && error.message ? error.message : String(error || "");
+  if (name === "AbortError" || /timed out|timeout/i.test(message)) {
+    return "Akemon took too long to answer. I restored your draft so you can try again.";
+  }
+  if (/Owner token required/i.test(message)) {
+    return "Owner token required. Paste the owner token and try again.";
+  }
+  if (/Owner token rejected/i.test(message)) {
+    return "Owner token rejected. Paste the current owner token and try again.";
+  }
+  if (/Failed to fetch|NetworkError|Load failed|fetch/i.test(message)) {
+    return "I could not reach the local Akemon service. Check that the 4321 service is running, then try again.";
+  }
+  return message || "Akemon could not send this message.";
+}
+function chatTaskReportText(task) {
+  if (!task || typeof task !== "object") return "";
+  const view = taskSurfaceView(task);
+  const reviews = Array.isArray(view?.reviews) ? view.reviews : [];
+  const latestReview = reviews.length ? reviews[reviews.length - 1] : null;
+  const data = task.data && typeof task.data === "object" ? task.data : {};
+  return (view?.report && view.report.text)
+    || (latestReview && latestReview.reportText)
+    || (typeof data.reportText === "string" ? data.reportText : "")
+    || task.summary
+    || task.nextAction
+    || "";
+}
+function completeActiveChatTaskFromTask(task, options) {
+  options = options || {};
+  if (!task || !task.taskId || state.completedChatTaskIds.has(task.taskId)) return;
+  state.completedChatTaskIds.add(task.taskId);
+  const failed = task.status === "failed" || task.stage === "blocked";
+  const output = normalizeAkemonOutput(chatTaskReportText(task));
+  appendChatMessage("akemon", output, failed, { task });
+  if (failed) setStatus("Akemon task stopped", true);
+  else if (!options.quiet) setStatus("Akemon replied");
+  refreshActivity({ quiet: true }).catch(() => {});
+  refreshSessions({ quiet: true }).catch(() => {});
+}
+async function watchActiveChatTask(taskId, requestId) {
+  if (!taskId) return;
+  for (;;) {
+    if (!state.activeChatTaskId || state.activeChatTaskId !== taskId) return;
+    if (requestId && state.activeChatRequestId && state.activeChatRequestId !== requestId) return;
+    try {
+      const data = await api("/self/tasks/" + encodeURIComponent(taskId), { method: "GET" });
+      const task = data.task || null;
+      if (task && isStaleChatTask(task)) {
+        clearActiveChatTask(taskId, { status: false });
+        setStatus("Akemon is ready");
+        return;
+      }
+      if (task && !isChatTaskActive(task)) {
+        completeActiveChatTaskFromTask(task);
+        clearActiveChatTask(taskId, { status: false });
+        return;
+      }
+      if (task) setStatus(chatTaskSummary(task) || "Akemon is handling the request");
+    } catch (error) {
+      if (!state.pageUnloading) setStatus(friendlyChatError(error), true);
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+}
+async function submitChat(event) {
+  event.preventDefault();
+  const draft = el.chatInput.value;
+  const text = draft.trim();
+  if (!text) return;
+  el.chatInput.value = "";
+  const isFollowUp = state.chatBusy && !!state.activeChatTaskId;
+  appendChatMessage("user", text);
+  if (isFollowUp) {
+    setStatus("Queueing follow-up");
+    try {
+      const result = await sendAkemonMessage(text, { followUpForTaskId: state.activeChatTaskId });
+      appendChatMessage("akemon", result.output, false, { task: result.task });
+      refreshActivity({ quiet: true }).catch(() => {});
+      setStatus("Follow-up queued");
+    } catch (error) {
+      if (state.pageUnloading) return;
+      if (!el.chatInput.value.trim()) el.chatInput.value = draft;
+      const message = friendlyChatError(error);
+      appendChatMessage("akemon", message, true);
+      setStatus(message, true);
+    } finally {
+      if (!state.pageUnloading) el.chatInput.focus();
+    }
+    return;
+  }
+  const message = createAkemonChatMessage(text);
+  const requestId = message.id;
+  state.activeChatTaskId = localChatTaskIdFromMessage(message);
+  state.activeChatRequestId = requestId;
+  persistActiveChatTask({
+    taskId: state.activeChatTaskId,
+    requestId,
+    startedAt: message.createdAt,
+  });
+  setChatBusy(true);
+  setStatus("Akemon is framing the request");
+  let keepActiveTask = false;
+  try {
+    const result = await sendAkemonMessageEnvelope(message, { wait: false });
+    if (result.async || result.accepted) {
+      const taskId = result.task?.taskId || state.activeChatTaskId;
+      state.activeChatTaskId = taskId;
+      persistActiveChatTask({
+        taskId,
+        requestId,
+        startedAt: message.createdAt,
+      });
+      keepActiveTask = true;
+      setStatus(chatTaskSummary(result.task) || "Akemon is handling the request");
+      watchActiveChatTask(taskId, requestId).catch((error) => {
+        if (!state.pageUnloading) setStatus(friendlyChatError(error), true);
+      });
+      refreshActivity({ quiet: true }).catch(() => {});
+      return;
+    }
+    appendChatMessage("akemon", result.output, false, {
+      memoryProposal: result.memoryProposal,
+      eventIds: result.eventIds,
+      task: result.task,
+    });
+    result.cmItems.forEach((item) => appendCmItem(item));
+    refreshActivity({ quiet: true }).catch(() => {});
+    setStatus("Akemon replied");
+    refreshSessions({ quiet: true }).catch(() => {});
+  } catch (error) {
+    if (state.pageUnloading) return;
+    if (!el.chatInput.value.trim()) el.chatInput.value = draft;
+    const message = friendlyChatError(error);
+    appendChatMessage("akemon", message, true);
+    setStatus(message, true);
+  } finally {
+    if (!keepActiveTask && !state.pageUnloading && state.activeChatRequestId === requestId) {
+      clearActiveChatTask(state.activeChatTaskId, { status: false });
+    }
+    if (!state.pageUnloading) el.chatInput.focus();
+  }
+}
+function createTerminal() {
+  if (!window.Terminal) {
+    setStatus("xterm failed to load", true);
+    return null;
+  }
+  const term = new Terminal({
+    cursorBlink: false,
+    cursorInactiveStyle: "block",
+    cursorStyle: "block",
+    convertEol: true,
+    fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+    fontSize: FONT_SIZE,
+    lineHeight: LINE_HEIGHT,
+    scrollback: 5000,
+    theme: {
+      background: "#ffffff",
+      foreground: "#1a1a1a",
+      cursor: "#3a8a52",
+      cursorAccent: "#ffffff",
+      selectionBackground: "#c8e0c4",
+      selectionForeground: "#1a1a1a",
+      black: "#1a1a1a",
+      red: "#c43830",
+      green: "#2a7a3a",
+      yellow: "#8a6d10",
+      blue: "#2060a8",
+      magenta: "#8a3a8a",
+      cyan: "#1a7a7a",
+      white: "#d0ccc5",
+      brightBlack: "#666360",
+      brightRed: "#e05040",
+      brightGreen: "#3a9a4a",
+      brightYellow: "#a08520",
+      brightBlue: "#3080c8",
+      brightMagenta: "#a050a0",
+      brightCyan: "#2a9a9a",
+      brightWhite: "#f8f7f6",
+    },
+  });
+  if (window.FitAddon) {
+    state.fitAddon = new FitAddon.FitAddon();
+    term.loadAddon(state.fitAddon);
+  }
+  if (window.WebLinksAddon) {
+    term.loadAddon(new WebLinksAddon.WebLinksAddon());
+  }
+  if (window.SearchAddon) {
+    state.searchAddon = new SearchAddon.SearchAddon();
+    term.loadAddon(state.searchAddon);
+  }
+  term.open(el.terminal);
+  state.term = term;
+  el.terminal.addEventListener("pointerdown", focusTerminalForPointer, true);
+  el.terminal.addEventListener("mousedown", focusTerminalForPointer, true);
+  el.terminal.addEventListener("click", () => refreshTerminal());
+  if (typeof term.attachCustomKeyEventHandler === "function") {
+    term.attachCustomKeyEventHandler((event) => {
+      if (event.type !== "keydown" || event.key !== "Enter" || !event.shiftKey) return true;
+      const session = activeSession();
+      if (!state.activeId || !session || session.status !== "running" || session.inputMode !== "tui") return true;
+      event.preventDefault();
+      sendInput(state.activeId, "\n").catch((error) => setStatus(error.message, true));
+      return false;
+    });
+  }
+  if (typeof term.attachCustomWheelEventHandler === "function") {
+    term.attachCustomWheelEventHandler((event) => handleTerminalWheel(event));
+  }
+  term.onData((data) => {
+    if (!state.activeId) return;
+    const session = activeSession();
+    if (!session || session.status !== "running") return;
+    const input = filterTerminalControlResponses(data);
+    if (!input) return;
+    sendInput(state.activeId, input).catch((error) => setStatus(error.message, true));
+  });
+  term.onResize((dims) => syncTerminalSize(dims, true));
+  resizeTerminal(false, true);
+  requestTerminalResize(false, true);
+  setTimeout(() => requestTerminalResize(false, true), 60);
+  return term;
+}
+function updateStartFormHints() {
+  if (el.tool.value === "custom") {
+    el.command.placeholder = "cmd required";
+  } else {
+    el.command.placeholder = "cmd override";
+  }
+  if (el.inputMode.value === "auto") {
+    el.inputMode.title = (el.tool.value === "codex" || el.tool.value === "cursor")
+      ? "auto: tui"
+      : "auto: line";
+  }
+}
+function resizeTerminal(send, force) {
+  if (!state.term) return;
+  if (!isTerminalRenderable()) return;
+  if (state.fitAddon) {
+    state.fitAddon.fit();
+  }
+  syncTerminalSize({ cols: state.term.cols, rows: state.term.rows }, send, force);
+}
+function syncTerminalSize(dims, send, force) {
+  if (!dims || !Number.isFinite(dims.cols) || !Number.isFinite(dims.rows)) return;
+  const changed = dims.cols !== state.lastResize.cols || dims.rows !== state.lastResize.rows;
+  state.lastResize = dims;
+  el.sizeText.textContent = dims.cols + "x" + dims.rows;
+  const session = activeSession();
+  if (send !== false && session && session.status === "running" && (changed || force === true)) {
+    api("/self/workbench/sessions/" + encodeURIComponent(session.sessionId) + "/resize", {
+      method: "POST",
+      body: JSON.stringify(dims),
+    }).catch((error) => setStatus(error.message, true));
+  }
+}
+function requestTerminalResize(send, force) {
+  const shouldSend = send !== false;
+  if (state.resizeFrame) cancelAnimationFrame(state.resizeFrame);
+  state.resizeFrame = requestAnimationFrame(() => {
+    state.resizeFrame = 0;
+    resizeTerminal(shouldSend, force);
+  });
+}
+function isTerminalRenderable() {
+  if (document.hidden) return false;
+  const rect = el.terminal.getBoundingClientRect();
+  return rect.width > 0 && rect.height > 0;
+}
+function isFormControlFocused() {
+  const active = document.activeElement;
+  if (!active) return false;
+  return active.tagName === "INPUT" || active.tagName === "SELECT" || active.tagName === "TEXTAREA";
+}
+function restoreTerminalFocus(force) {
+  if (!state.term || !isTerminalRenderable()) return;
+  if (!force && isFormControlFocused()) return;
+  const refresh = () => {
+    if (!state.term || !isTerminalRenderable()) return;
+    ensureTerminalCursorVisible();
+    state.term.focus();
+    state.term.refresh(0, Math.max(0, state.term.rows - 1));
+  };
+  refresh();
+  requestAnimationFrame(refresh);
+}
+function handleTerminalWheel(event) {
+  if (!state.term) return true;
+  if (event.ctrlKey) return true;
+  const lines = terminalWheelLines(event);
+  event.preventDefault();
+  event.stopPropagation();
+  if (lines !== 0) state.term.scrollLines(lines);
+  return false;
+}
+function terminalWheelLines(event) {
+  const linePixels = Math.max(1, FONT_SIZE * LINE_HEIGHT);
+  let delta = event.deltaY || 0;
+  if (event.deltaMode === 1) {
+    delta = event.deltaY;
+  } else if (event.deltaMode === 2) {
+    delta = event.deltaY * Math.max(1, Math.floor((state.term ? state.term.rows : 24) * 0.8));
+  } else {
+    delta = event.deltaY / linePixels;
+  }
+  state.wheelScrollRemainder += delta;
+  const whole = state.wheelScrollRemainder < 0
+    ? Math.ceil(state.wheelScrollRemainder)
+    : Math.floor(state.wheelScrollRemainder);
+  if (whole !== 0) state.wheelScrollRemainder -= whole;
+  return whole;
+}
+function focusTerminalForPointer() {
+  if (!state.term || !isTerminalRenderable()) return;
+  ensureTerminalCursorVisible();
+  state.term.focus();
+}
+function filterTerminalControlResponses(data) {
+  let text = state.terminalResponseBuffer + data;
+  state.terminalResponseBuffer = "";
+  let output = "";
+  let index = 0;
+  while (index < text.length) {
+    const oscStart = text.indexOf("\x1b]", index);
+    const csiStart = text.indexOf("\x1b[", index);
+    const start = minPositiveIndex(oscStart, csiStart);
+    if (start === -1) {
+      output += text.slice(index);
+      break;
+    }
+    output += text.slice(index, start);
+    if (start === oscStart) {
+      const parsed = readOscSequence(text, start);
+      if (!parsed) return bufferTerminalResponseRemainder(text, start, output);
+      if (!isColorQueryResponse(parsed.sequence)) output += parsed.sequence;
+      index = parsed.end;
+      continue;
+    }
+    const parsed = readCsiSequence(text, start);
+    if (!parsed) return bufferTerminalResponseRemainder(text, start, output);
+    if (!isTerminalGeneratedCsiResponse(parsed.sequence)) output += parsed.sequence;
+    index = parsed.end;
+  }
+  return output;
+}
+function minPositiveIndex(left, right) {
+  if (left === -1) return right;
+  if (right === -1) return left;
+  return Math.min(left, right);
+}
+function readOscSequence(text, start) {
+  const belEnd = text.indexOf("\x07", start);
+  const stEnd = text.indexOf("\x1b\\", start);
+  const hasBel = belEnd !== -1 && (stEnd === -1 || belEnd < stEnd);
+  const end = hasBel ? belEnd : stEnd;
+  if (end === -1) return null;
+  return {
+    sequence: text.slice(start, end + (hasBel ? 1 : 2)),
+    end: end + (hasBel ? 1 : 2),
+  };
+}
+function readCsiSequence(text, start) {
+  for (let i = start + 2; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    if (code >= 0x40 && code <= 0x7e) {
+      return { sequence: text.slice(start, i + 1), end: i + 1 };
+    }
+  }
+  return null;
+}
+function bufferTerminalResponseRemainder(text, start, output) {
+  state.terminalResponseBuffer = text.slice(start);
+  if (state.terminalResponseBuffer.length > TERMINAL_RESPONSE_BUFFER_LIMIT) {
+    output += state.terminalResponseBuffer;
+    state.terminalResponseBuffer = "";
+  }
+  return output;
+}
+function isColorQueryResponse(sequence) {
+  return /^\x1b\](10|11|12);rgb:[0-9a-f]{1,4}\/[0-9a-f]{1,4}\/[0-9a-f]{1,4}(\x07|\x1b\\)$/i.test(sequence);
+}
+function isTerminalGeneratedCsiResponse(sequence) {
+  return /^\x1b\[(\?|>)?[0-9;]*c$/.test(sequence)
+    || /^\x1b\[\??[0-9]+;[0-9]+R$/.test(sequence)
+    || /^\x1b\[\??[0-9;]*n$/.test(sequence);
+}
+function shouldForceTerminalCursor() {
+  const session = activeSession();
+  return !!session && (session.tool === "shell" || session.tool === "custom");
+}
+function ensureTerminalCursorVisible() {
+  if (!state.term || !shouldForceTerminalCursor()) return;
+  state.term.write("\x1b[?25h");
+  state.lastCursorControl = "forced visible";
+  updateDebugText();
+}
+function trackCursorControl(chunk) {
+  if (typeof chunk !== "string") return;
+  if (chunk.includes("\x1b[?25l")) state.lastCursorControl = "hidden by output";
+  if (chunk.includes("\x1b[?25h")) state.lastCursorControl = "shown by output";
+  updateDebugText();
+}
+function writeTerminalOutput(chunk) {
+  if (!state.term || !chunk) return;
+  trackCursorControl(chunk);
+  state.term.write(chunk);
+}
+function updateDebugText() {
+  if (!el.debugText) return;
+  el.debugText.textContent = state.lastCursorControl ? "cursor: " + state.lastCursorControl : "";
+}
+function refreshTerminal() {
+  if (!state.term || !isTerminalRenderable()) return;
+  const refresh = () => {
+    if (state.term && isTerminalRenderable()) state.term.refresh(0, Math.max(0, state.term.rows - 1));
+  };
+  refresh();
+  requestAnimationFrame(refresh);
+}
+function activeSession() {
+  return state.sessions.find((session) => session.sessionId === state.activeId) || null;
+}
+function sessionSelectLabel(session) {
+  const name = session.label || session.tool || session.sessionId;
+  return "[" + session.status + "] " + name;
+}
+function renderTerminalSessionSelect() {
+  const select = el.terminalSessionSelect;
+  if (!select) return;
+  const sessions = visibleSessionList();
+  select.textContent = "";
+  if (!sessions.length) {
+    const option = document.createElement("option");
+    option.value = "";
+    option.textContent = "No sessions";
+    select.appendChild(option);
+    select.disabled = true;
+    return;
+  }
+  select.disabled = false;
+  for (const session of sessions) {
+    const option = document.createElement("option");
+    option.value = session.sessionId;
+    option.textContent = sessionSelectLabel(session);
+    option.title = session.commandLineDisplay || session.sessionId;
+    select.appendChild(option);
+  }
+  if (state.activeId && sessions.some((session) => session.sessionId === state.activeId)) {
+    select.value = state.activeId;
+  }
+}
+function updateActiveHeader() {
+  const session = activeSession();
+  renderTerminalSessionSelect();
+  if (!session) {
+    el.activeStatus.textContent = "idle";
+    el.activeStatus.className = "status-pill";
+    el.activeCommand.textContent = "No active session";
+    el.activeInputMode.disabled = true;
+    el.activeInputMode.value = "line";
+    return;
+  }
+  el.activeStatus.textContent = session.status;
+  el.activeStatus.className = "status-pill " + (session.status === "running" ? "status-running" : "status-ended");
+  el.activeCommand.textContent = (session.commandLineDisplay || session.sessionId) + " [" + (session.inputMode || "line") + "]";
+  el.activeInputMode.disabled = session.status !== "running";
+  el.activeInputMode.value = session.inputMode || "line";
+}
+function renderSessions() {
+  const visibleSessions = visibleSessionList();
+  const hiddenCount = Math.max(0, state.sessions.length - visibleSessions.length);
+  el.sessionHistoryToggle.textContent = state.showSessionHistory ? "Active" : "History";
+  el.sessionHistoryToggle.title = state.showSessionHistory
+    ? "Show only active and recent sessions"
+    : "Show all completed sessions";
+  if (!visibleSessions.length) {
+    state.sessionItems.clear();
+    el.list.innerHTML = "";
+    const empty = document.createElement("div");
+    empty.className = "empty";
+    empty.textContent = state.sessions.length ? "No active sessions." : "No sessions.";
+    el.list.appendChild(empty);
+    if (hiddenCount > 0) el.list.appendChild(renderSessionHistoryNote(hiddenCount));
+    updateActiveHeader();
+    return;
+  }
+  const seen = new Set();
+  const empty = el.list.querySelector(".empty");
+  if (empty) empty.remove();
+  for (const note of el.list.querySelectorAll(".session-history-note")) note.remove();
+  for (const session of visibleSessions) {
+    seen.add(session.sessionId);
+    let item = state.sessionItems.get(session.sessionId);
+    if (!item) {
+      item = document.createElement("button");
+      item.type = "button";
+      item.innerHTML = [
+        '<div class="session-line">',
+        '<span class="session-name"></span>',
+        '<span class="status-pill"></span>',
+        '</div>',
+        '<div class="session-meta"></div>',
+      ].join("");
+      item.addEventListener("click", () => showSessionInTerminal(session.sessionId));
+      state.sessionItems.set(session.sessionId, item);
+    }
+    item.className = "session-item" + (session.sessionId === state.activeId ? " active" : "");
+    item.querySelector(".session-name").textContent = session.label || session.tool || session.sessionId;
+    const pill = item.querySelector(".status-pill");
+    pill.textContent = session.status;
+    pill.className = "status-pill";
+    if (session.status === "running") pill.classList.add("status-running");
+    else pill.classList.add("status-ended");
+    item.querySelector(".session-meta").textContent = (session.inputMode || "line") + " · " + (session.commandLineDisplay || session.sessionId);
+    if (item.parentNode !== el.list) el.list.appendChild(item);
+  }
+  for (const [sessionId, item] of state.sessionItems) {
+    if (seen.has(sessionId)) continue;
+    item.remove();
+    state.sessionItems.delete(sessionId);
+  }
+  for (const session of visibleSessions) {
+    const item = state.sessionItems.get(session.sessionId);
+    if (item && item.parentNode === el.list && el.list.lastElementChild !== item) el.list.appendChild(item);
+  }
+  if (hiddenCount > 0 && !state.showSessionHistory) el.list.appendChild(renderSessionHistoryNote(hiddenCount));
+  updateActiveHeader();
+}
+function visibleSessionList() {
+  if (state.showSessionHistory) return state.sessions;
+  const visibleIds = new Set();
+  const recentCompleted = [];
+  for (const session of state.sessions) {
+    if (session.status === "running" || session.sessionId === state.activeId) {
+      visibleIds.add(session.sessionId);
+      continue;
+    }
+    if (recentCompleted.length < 5) recentCompleted.push(session.sessionId);
+  }
+  recentCompleted.forEach((sessionId) => visibleIds.add(sessionId));
+  return state.sessions.filter((session) => visibleIds.has(session.sessionId));
+}
+function renderSessionHistoryNote(hiddenCount) {
+  const note = document.createElement("div");
+  note.className = "session-history-note";
+  note.textContent = hiddenCount + " older completed session" + (hiddenCount === 1 ? " is" : "s are") + " hidden.";
+  return note;
+}
+function mergeSession(snapshot) {
+  const index = state.sessions.findIndex((session) => session.sessionId === snapshot.sessionId);
+  if (index === -1) state.sessions.unshift(snapshot);
+  else state.sessions[index] = Object.assign({}, state.sessions[index], snapshot);
+}
+async function refreshSessions(options) {
+  if (!state.token) {
+    if (!options || options.quiet !== true) requireOwnerToken();
+    return;
+  }
+  const previousActiveId = state.activeId;
+  const data = await api("/self/workbench/sessions", { method: "GET" });
+  rememberAgentName(data.agentName);
+  state.sessions = Array.isArray(data.sessions) ? data.sessions : [];
+  const serverActiveId = typeof data.activeSessionId === "string" ? data.activeSessionId : "";
+  if (serverActiveId && state.sessions.some((session) => session.sessionId === serverActiveId)) {
+    state.activeId = serverActiveId;
+  }
+  if (!state.activeId && state.sessions[0]) state.activeId = state.sessions[0].sessionId;
+  if (state.activeId && !activeSession()) state.activeId = "";
+  if (!state.activeId && state.sessions[0]) state.activeId = state.sessions[0].sessionId;
+  renderSessions();
+  if (state.activeId && state.activeId !== previousActiveId) {
+    await activateSession(state.activeId);
+  } else {
+    updateActiveHeader();
+  }
+  setStatus("Connected");
+}
+async function activateSession(sessionId, keepStream) {
+  const activationRequestId = ++state.activationRequestId;
+  state.activeId = sessionId;
+  renderSessions();
+  let syncedSession = null;
+  try {
+    syncedSession = await syncActiveSession(sessionId);
+  } catch (error) {
+    if (isCurrentActivation(sessionId, activationRequestId)) setStatus(error.message, true);
+  }
+  if (!isCurrentActivation(sessionId, activationRequestId)) {
+    return;
+  }
+  if (syncedSession) {
+    mergeSession(syncedSession);
+    renderSessions();
+  }
+  if (!state.term) createTerminal();
+  const session = activeSession();
+  if (state.term) {
+    resizeTerminal(true, true);
+    state.terminalResponseBuffer = "";
+    state.wheelScrollRemainder = 0;
+    state.term.reset();
+    if (session && session.tail) writeTerminalOutput(session.tail);
+    restoreTerminalFocus(true);
+    requestTerminalResize(true, true);
+    setTimeout(() => requestTerminalResize(true, true), 60);
+  }
+  updateActiveHeader();
+  if (!keepStream) startStream(sessionId);
+}
+async function showSessionInTerminal(sessionId) {
+  try {
+    await activateSession(sessionId);
+    setActivePage("terminal");
+  } catch (error) {
+    setStatus(error.message, true);
+  }
+}
+function isCurrentActivation(sessionId, activationRequestId) {
+  return state.activationRequestId === activationRequestId && state.activeId === sessionId;
+}
+async function syncActiveSession(sessionId) {
+  if (!state.token || !sessionId) return;
+  const data = await api("/self/workbench/sessions/" + encodeURIComponent(sessionId) + "/activate", {
+    method: "POST",
+  });
+  return data && data.session ? data.session : null;
+}
+function clearStreamRetry() {
+  if (!state.streamRetryTimer) return;
+  clearTimeout(state.streamRetryTimer);
+  state.streamRetryTimer = 0;
+}
+function shouldReconnectStream(sessionId, controller) {
+  if (controller.signal.aborted) return false;
+  if (state.streamAbort !== controller || state.activeId !== sessionId) return false;
+  const session = activeSession();
+  return !session || session.status === "running";
+}
+function scheduleStreamReconnect(sessionId, controller, attempt) {
+  if (!shouldReconnectStream(sessionId, controller)) return;
+  const delay = Math.min(30000, 1000 * Math.pow(2, Math.min(attempt, 5)));
+  clearStreamRetry();
+  setStatus("Stream disconnected; retry " + (attempt + 1) + " in " + Math.round(delay / 1000) + "s", true);
+  state.streamRetryTimer = setTimeout(() => {
+    state.streamRetryTimer = 0;
+    if (shouldReconnectStream(sessionId, controller)) startStream(sessionId, attempt + 1);
+  }, delay);
+}
+function startStream(sessionId, attempt) {
+  clearStreamRetry();
+  if (state.streamAbort) state.streamAbort.abort();
+  const controller = new AbortController();
+  state.streamAbort = controller;
+  const retryAttempt = attempt || 0;
+  if (retryAttempt > 0) setStatus("Reconnecting stream " + sessionId + " (attempt " + retryAttempt + ")");
+  fetch("/self/workbench/sessions/" + encodeURIComponent(sessionId) + "/stream", {
+    method: "GET",
+    headers: authHeaders(),
+    signal: controller.signal,
+  }).then(async (res) => {
+    if (!res.ok) {
+      const error = new Error("stream HTTP " + res.status);
+      error.status = res.status;
+      throw error;
+    }
+    if (!res.body) throw new Error("stream body unavailable");
+    setStatus("Streaming " + sessionId);
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (;;) {
+      const result = await reader.read();
+      if (result.done) break;
+      buffer += decoder.decode(result.value, { stream: true });
+      const parts = buffer.split("\n\n");
+      buffer = parts.pop() || "";
+      for (const part of parts) handleSseBlock(part);
+    }
+    scheduleStreamReconnect(sessionId, controller, retryAttempt);
+  }).catch((error) => {
+    if (controller.signal.aborted) return;
+    if (error.status === 401 || error.status === 403) {
+      clearOwnerToken("Owner token rejected");
+      return;
+    }
+    if (error.status === 404) {
+      setStatus("Stream session not found", true);
+      return;
+    }
+    setStatus(error.message, true);
+    scheduleStreamReconnect(sessionId, controller, retryAttempt);
+  });
+}
+function handleSseBlock(block) {
+  const lines = block.split(/\r?\n/);
+  let eventName = "message";
+  let dataText = "";
+  for (const line of lines) {
+    if (line.startsWith("event:")) eventName = line.slice(6).trim();
+    else if (line.startsWith("data:")) dataText += line.slice(5).trim();
+  }
+  if (!dataText) return;
+  let data;
+  try { data = JSON.parse(dataText); }
+  catch { return; }
+  if (data.snapshot) {
+    mergeSession(data.snapshot);
+    renderSessions();
+  }
+  if (eventName === "output" && data.sessionId === state.activeId && state.term) {
+    const chunk = data.chunk || "";
+    writeTerminalOutput(chunk);
+  }
+  if (eventName === "exit") {
+    setStatus("Session ended");
+  }
+}
+async function sendInput(sessionId, input) {
+  await api("/self/workbench/sessions/" + encodeURIComponent(sessionId) + "/input", {
+    method: "POST",
+    body: JSON.stringify({ input }),
+  });
+}
+function splitArgs(input) {
+  const tokens = [];
+  let current = "";
+  let quote = "";
+  let escaping = false;
+  for (const char of input) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = "";
+      else current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (escaping) throw new Error("Trailing escape in args");
+  if (quote) throw new Error("Unterminated quote in args");
+  if (current) tokens.push(current);
+  return tokens;
+}
+async function startSession(event) {
+  event.preventDefault();
+  if (!requireOwnerToken()) return;
+  if (!state.term) createTerminal();
+  resizeTerminal(false);
+  const request = {
+    tool: el.tool.value,
+    args: splitArgs(el.args.value.trim()),
+    cols: state.term ? state.term.cols : state.lastResize.cols,
+    rows: state.term ? state.term.rows : state.lastResize.rows,
+  };
+  if (el.command.value.trim()) request.command = el.command.value.trim();
+  if (el.workdir.value.trim()) request.workdir = el.workdir.value.trim();
+  if (el.label.value.trim()) request.label = el.label.value.trim();
+  if (el.allowOutside.checked) request.allowOutsideWorkdir = true;
+  if (el.inputMode.value === "line" || el.inputMode.value === "tui") request.inputMode = el.inputMode.value;
+  const data = await api("/self/workbench/sessions", {
+    method: "POST",
+    body: JSON.stringify(request),
+  });
+  mergeSession(data.session);
+  renderSessions();
+  await activateSession(data.session.sessionId);
+  setActivePage("terminal");
+  setStatus("Started " + data.session.sessionId);
+}
+async function setActiveInputMode() {
+  if (!state.activeId) return;
+  const inputMode = el.activeInputMode.value === "tui" ? "tui" : "line";
+  const data = await api("/self/workbench/sessions/" + encodeURIComponent(state.activeId) + "/input-mode", {
+    method: "POST",
+    body: JSON.stringify({ inputMode }),
+  });
+  mergeSession(data.session);
+  renderSessions();
+  updateActiveHeader();
+  setStatus("Input mode: " + inputMode);
+}
+async function stopActive() {
+  if (!state.activeId) return;
+  const data = await api("/self/workbench/sessions/" + encodeURIComponent(state.activeId) + "/stop", {
+    method: "POST",
+  });
+  mergeSession(data.session);
+  renderSessions();
+  setStatus("Stopped " + state.activeId);
+}
+el.tokenSave.addEventListener("click", () => {
+  const token = el.tokenInput.value.trim();
+  if (!token) return;
+  localStorage.setItem(TOKEN_STORAGE_KEY, token);
+  state.token = token;
+  setAuthVisible(false, "");
+  refreshSessions().catch((error) => setStatus(error.message, true));
+});
+el.startForm.addEventListener("submit", (event) => {
+  startSession(event).catch((error) => setStatus(error.message, true));
+});
+el.tool.addEventListener("change", updateStartFormHints);
+el.sessionHistoryToggle.addEventListener("click", () => {
+  state.showSessionHistory = !state.showSessionHistory;
+  renderSessions();
+});
+el.refresh.addEventListener("click", () => refreshSessions().catch((error) => setStatus(error.message, true)));
+el.resize.addEventListener("click", () => resizeTerminal(true, true));
+el.stop.addEventListener("click", () => stopActive().catch((error) => setStatus(error.message, true)));
+el.terminalSessionSelect.addEventListener("change", () => {
+  const sessionId = el.terminalSessionSelect.value;
+  if (!sessionId || sessionId === state.activeId) return;
+  activateSession(sessionId).catch((error) => setStatus(error.message, true));
+});
+el.activityRefresh.addEventListener("click", () => refreshActivity().catch((error) => setStatus(error.message, true)));
+el.activitySearch.addEventListener("input", () => {
+  reconcileActivitySelection();
+  renderActivity();
+  renderSelectedActivityDetail({ quiet: true }).catch((error) => setStatus(error.message, true));
+});
+el.activityStatusFilter.addEventListener("change", () => {
+  state.activitySelectedTaskId = "";
+  refreshActivity().catch((error) => setStatus(error.message, true));
+});
+el.activityRouteFilter.addEventListener("change", () => {
+  state.activitySelectedTaskId = "";
+  refreshActivity().catch((error) => setStatus(error.message, true));
+});
+el.activeInputMode.addEventListener("change", () => {
+  setActiveInputMode().catch((error) => setStatus(error.message, true));
+});
+el.chatForm.addEventListener("submit", (event) => {
+  submitChat(event).catch((error) => {
+    const message = friendlyChatError(error);
+    appendChatMessage("akemon", message, true);
+    setStatus(message, true);
+    setChatBusy(false);
+  });
+});
+el.chatClear.addEventListener("click", clearChatHistory);
+function isChatInputComposing(event) {
+  return event.isComposing
+    || state.chatComposing
+    || event.keyCode === 229
+    || Date.now() - state.chatCompositionEndedAt < 50;
+}
+el.chatInput.addEventListener("compositionstart", () => {
+  state.chatComposing = true;
+});
+el.chatInput.addEventListener("compositionend", () => {
+  state.chatComposing = false;
+  state.chatCompositionEndedAt = Date.now();
+});
+el.chatInput.addEventListener("keydown", (event) => {
+  if (event.key === "Enter" && !event.shiftKey) {
+    if (isChatInputComposing(event)) return;
+    event.preventDefault();
+    el.chatForm.requestSubmit();
+  }
+});
+let resizeTimer = 0;
+function scheduleTerminalResize() {
+  clearTimeout(resizeTimer);
+  resizeTimer = setTimeout(() => requestTerminalResize(true), 80);
+}
+window.addEventListener("resize", scheduleTerminalResize);
+window.addEventListener("pagehide", () => {
+  state.pageUnloading = true;
+});
+window.addEventListener("beforeunload", () => {
+  state.pageUnloading = true;
+});
+window.addEventListener("pageshow", () => {
+  state.pageUnloading = false;
+});
+if (window.ResizeObserver) {
+  const terminalObserver = new ResizeObserver(scheduleTerminalResize);
+  terminalObserver.observe(el.terminal);
+  terminalObserver.observe(el.terminal.parentElement);
+}
+function toggleSearch(open) {
+  el.searchBar.classList.toggle("open", open);
+  if (open) {
+    el.searchInput.focus();
+    el.searchInput.select();
+  } else {
+    el.searchInput.value = "";
+    if (state.searchAddon) state.searchAddon.clearDecorations();
+    if (state.term) state.term.focus();
+  }
+}
+el.searchClose.addEventListener("click", () => toggleSearch(false));
+el.searchNext.addEventListener("click", () => {
+  if (state.searchAddon && el.searchInput.value) state.searchAddon.findNext(el.searchInput.value);
+});
+el.searchPrev.addEventListener("click", () => {
+  if (state.searchAddon && el.searchInput.value) state.searchAddon.findPrevious(el.searchInput.value);
+});
+el.searchInput.addEventListener("keydown", (e) => {
+  if (e.key === "Enter") {
+    if (state.searchAddon && el.searchInput.value) {
+      if (e.shiftKey) state.searchAddon.findPrevious(el.searchInput.value);
+      else state.searchAddon.findNext(el.searchInput.value);
+    }
+    e.preventDefault();
+  }
+  if (e.key === "Escape") {
+    toggleSearch(false);
+    e.preventDefault();
+  }
+});
+document.addEventListener("keydown", (e) => {
+  if ((e.metaKey || e.ctrlKey) && e.key === "f") {
+    e.preventDefault();
+    toggleSearch(true);
+  }
+});
+loadChatHistory();
+loadCmItems();
+restoreActiveChatTaskFromStorage();
+initPageTabs();
+initToken();
+updateStartFormHints();
+createTerminal();
+refreshSessions({ quiet: true }).catch((error) => setStatus(error.message, true));
+refreshActivity({ quiet: true }).catch(() => {});
+refreshActiveChatTask({ quiet: true }).catch(() => {});
+setInterval(() => {
+  if (state.token) refreshSessions({ quiet: true }).catch(() => {});
+  if (state.token && state.activeChatTaskId) refreshActiveChatTask({ quiet: true }).catch(() => {});
+  if (state.token && state.activePage === "activity") refreshActivity({ quiet: true }).catch(() => {});
+}, 5000);
+</script>
+</body>
+</html>