ticlawk 0.1.17-dev.2 → 0.1.17-dev.20

package/src/runtimes/pi/index.mjs

@@ -6,8 +6,7 @@
 
 import { basename } from 'node:path';
 import { buildAgentRuntimeEnv } from '../../core/runtime-env.mjs';
-import { getGoalTaskProtocolOverlayKey } from '../_shared/goal-task-protocol.mjs';
-import { buildStandingPrompt } from '../_shared/standing-prompt.mjs';
+import { buildRuntimeBaseInstructions } from '../_shared/runtime-base-instructions.mjs';
 import { ensureAgentHome } from '../../core/agent-home.mjs';
 import {
   buildPiImagesFromInbound,
@@ -19,18 +18,15 @@ import {
   requirePiPath,
   runPiPrompt,
 } from './session.mjs';
-import { emitWorkerEventBestEffort } from '../../core/events/worker-events.mjs';
+import { emitWorkerEvent } from '../../core/events/worker-events.mjs';
 import {
   shouldStreamRuntime,
+  createDeltaAggregator,
   reportSubprocessFailure,
   terminalRuntimeFailure,
   updateBindingRuntimeMeta,
-  resolveRuntimeSessionScope,
-  buildRuntimeSessionMetaPatch,
 } from '../../core/runtime-support.mjs';
 
-const standingPromptSeen = new Set();
-
 export const piRuntime = {
   name: 'pi',
 
@@ -42,8 +38,7 @@ export const piRuntime = {
       images: opts.images,
       piPath,
       agentEnv,
-      standingPrompt: opts.standingPrompt || null,
-      forceStandingPrompt: Boolean(opts.forceStandingPrompt),
+      runtimeBaseInstructions: opts.runtimeBaseInstructions || null,
       timeoutMs: opts.timeoutMs,
     });
   },
@@ -56,8 +51,7 @@ export const piRuntime = {
       images: opts.images,
       piPath,
       agentEnv,
-      standingPrompt: opts.standingPrompt || null,
-      forceStandingPrompt: Boolean(opts.forceStandingPrompt),
+      runtimeBaseInstructions: opts.runtimeBaseInstructions || null,
       timeoutMs: opts.timeoutMs,
       onEvent: opts.onEvent,
     });
@@ -134,39 +128,46 @@ export const piRuntime = {
       message = captionText || 'Please analyze the attached image(s).';
     }
 
-    const sessionScope = resolveRuntimeSessionScope(meta, inbound);
-    const shouldRotate = sessionScope.shouldRotate;
-    const targetSessionId = shouldRotate ? null : sessionScope.sessionId;
+    const shouldRotate = !meta.sessionId || meta.rotatePending;
+    const deltaAggregator = createDeltaAggregator({
+      flushDelta: async ({ text, sessionId, cwd }) => {
+        await emitWorkerEvent({
+          adapter,
+          binding,
+          agent: this.name,
+          sessionId: sessionId || meta.sessionId || binding.id,
+          cwd: cwd || agentHome,
+          replyToMessageId: inbound.messageId || null,
+          event: {
+            hook_event_name: 'worker.message.delta',
+            worker_event_name: 'worker.message.delta',
+            delta: text,
+          },
+          logger: ctx.logger,
+        });
+      },
+    });
 
     try {
       const runtimePiPath = requirePiPath(meta.piPath || meta.runtimePath);
       const runtimePiVersion = getPiRuntimeHealth(runtimePiPath).version || meta.piVersion || null;
       const agentEnv = buildAgentRuntimeEnv({
         agentId: binding.id,
-        sessionId: targetSessionId,
+        sessionId: meta.sessionId,
         hostId: binding.runtime_host_id,
-        conversationId: inbound.conversationId,
-        messageId: inbound.messageId,
-        target: inbound.envelopeTarget,
       });
-      const standingPrompt = buildStandingPrompt({ agentId: binding.id, inbound });
-      const protocolOverlayKey = getGoalTaskProtocolOverlayKey({ agentId: binding.id, inbound });
-      const standingPromptSeenKey = targetSessionId
-        ? `${binding.id}|${targetSessionId}|${protocolOverlayKey}`
-        : null;
-      const forceStandingPrompt = Boolean(standingPromptSeenKey && !standingPromptSeen.has(standingPromptSeenKey));
+      const runtimeBaseInstructions = buildRuntimeBaseInstructions({ agentId: binding.id });
       const result = shouldStreamRuntime(this.name, this)
-        ? await this.runTurnStream({ sessionId: targetSessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, {
-            standingPrompt,
-            forceStandingPrompt,
+        ? await this.runTurnStream({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, {
+            runtimeBaseInstructions,
             images,
             onEvent: async (event) => {
               if (event?.type === 'turn.started') {
-                emitWorkerEventBestEffort({
+                await emitWorkerEvent({
                   adapter,
                   binding,
                   agent: this.name,
-                  sessionId: event.sessionId || targetSessionId || binding.id,
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
                   cwd: agentHome,
                   replyToMessageId: inbound.messageId || null,
                   event: {
@@ -175,29 +176,31 @@ export const piRuntime = {
                   },
                   logger: ctx.logger,
                 });
+              } else if (event?.type === 'message.delta' && event.text) {
+                deltaAggregator.push(event.text, {
+                  sessionId: event.sessionId || meta.sessionId || binding.id,
+                  cwd: agentHome,
+                });
               }
             },
           })
-        : await this.runTurn({ sessionId: targetSessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, { images, standingPrompt, forceStandingPrompt });
+        : await this.runTurn({ sessionId: shouldRotate ? null : meta.sessionId, cwd: agentHome, piPath: runtimePiPath, agentEnv }, message, { images, runtimeBaseInstructions });
 
-      const observedSessionId = result?.sessionId || targetSessionId;
-      if (observedSessionId) {
-        standingPromptSeen.add(`${binding.id}|${observedSessionId}|${protocolOverlayKey}`);
-      }
+      await deltaAggregator.flush();
       const nextBinding = await updateBindingRuntimeMeta(ctx, binding, {
-        ...buildRuntimeSessionMetaPatch(meta, sessionScope, {
-          sessionId: result?.sessionId,
-          path: result?.path,
-        }),
+        sessionId: result?.sessionId || meta.sessionId,
+        path: result?.path || meta.path || null,
         runtimePath: runtimePiPath,
         piPath: runtimePiPath,
         piVersion: runtimePiVersion,
+        rotatePending: false,
+        lastRotatedAt: shouldRotate ? new Date().toISOString() : meta.lastRotatedAt,
       }, { status: 'connected' });
-      emitWorkerEventBestEffort({
+      await emitWorkerEvent({
         adapter,
         binding: nextBinding,
         agent: this.name,
-        sessionId: result?.sessionId || targetSessionId || binding.id,
+        sessionId: result?.sessionId || meta.sessionId || binding.id,
         cwd: result?.cwd || agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -208,11 +211,12 @@ export const piRuntime = {
       });
       return true;
     } catch (err) {
-      emitWorkerEventBestEffort({
+      await deltaAggregator.flush().catch(() => {});
+      await emitWorkerEvent({
         adapter,
         binding,
         agent: this.name,
-        sessionId: targetSessionId || binding.id,
+        sessionId: meta.sessionId || binding.id,
         cwd: agentHome,
         replyToMessageId: inbound.messageId || null,
         event: {
@@ -238,6 +242,24 @@ export const piRuntime = {
     }
   },
 
+  async reconcileAfterRestart(binding, ctx) {
+    const meta = binding.runtimeMeta || {};
+    await emitWorkerEvent({
+      adapter: ctx.adapter,
+      binding,
+      agent: this.name,
+      sessionId: meta.sessionId || binding.id,
+      cwd: ensureAgentHome(binding.id) || '',
+      event: {
+        hook_event_name: 'Stop',
+        worker_event_name: 'worker.turn.complete',
+        reason: 'connector.restart.reconcile',
+      },
+      logger: ctx.logger,
+    });
+    return 1;
+  },
+
   sessionsDir: PI_SESSIONS_DIR,
   maxAgeMs: PI_MAX_AGE_MS,
 };

package/src/runtimes/pi/session.mjs

@@ -196,16 +196,13 @@ export function runPiPrompt({
   images = [],
   piPath = null,
   agentEnv = null,
-  standingPrompt = null,
-  forceStandingPrompt = false,
+  runtimeBaseInstructions = null,
   timeoutMs = Number(process.env.PI_RUN_TIMEOUT_MS || DEFAULT_PI_RUN_TIMEOUT_MS),
   onEvent,
 }) {
-  // pi has no documented system-prompt flag. Prepend on first turn, and
-  // let callers force one resumed-session injection for a newly selected
-  // protocol overlay.
-  const finalMessage = standingPrompt && (!sessionId || forceStandingPrompt)
-    ? `${standingPrompt}\n\n---\n\n${message}`
+  // pi has no documented system-prompt flag — prepend on first turn.
+  const finalMessage = runtimeBaseInstructions && !sessionId
+    ? `${runtimeBaseInstructions}\n\n---\n\n${message}`
     : message;
   return new Promise((resolve, reject) => {
     const startedAt = Date.now();
@@ -223,13 +220,12 @@ export function runPiPrompt({
     let activeSessionFile = null;
     let finalText = '';
     let settled = false;
+    let eventChain = Promise.resolve();
     const pending = new Map();
 
     const emit = (event) => {
       if (typeof onEvent !== 'function') return;
-      void Promise.resolve()
-        .then(() => onEvent(event))
-        .catch(() => {});
+      eventChain = eventChain.then(() => onEvent(event)).catch(() => {});
     };
 
     const settle = (fn, value) => {
@@ -241,7 +237,7 @@ export function runPiPrompt({
       }
       pending.clear();
       try { child.kill('SIGTERM'); } catch {}
-      fn(value);
+      eventChain.catch(() => {}).finally(() => fn(value));
     };
 
     const sendRaw = (payload) => {
@@ -309,6 +305,7 @@ export function runPiPrompt({
           const delta = extractDeltaFromEvent(event);
           if (delta) {
             finalText += delta;
+            emit({ type: 'message.delta', sessionId: activeSessionId, text: delta });
           }
           return;
         }

package/ticlawk.mjs

@@ -211,6 +211,35 @@ async function recoverAllRuntimes(runtimeList, adapter) {
   }
 }
 
+async function reconcileBindingsAfterRestart(runtimes, adapter) {
+  const hostId = getHostId();
+  for (const binding of listBindings({ adapter: adapter.id })) {
+    if (!belongsToRuntimeHost(binding, hostId)) {
+      logger.debugError('core', 'binding.reconcile-host-mismatch', {
+        bindingId: binding.id,
+        adapter: binding.adapter,
+        hostId,
+        runtime_host_id: getBindingRuntimeHostId(binding),
+      });
+      continue;
+    }
+    const runtime = binding.runtime ? runtimes[binding.runtime] : null;
+    if (typeof runtime?.reconcileAfterRestart !== 'function') continue;
+    try {
+      await runtime.reconcileAfterRestart(binding, {
+        adapter,
+        logger,
+      });
+    } catch (err) {
+      logger.debugError('startup', 'reconcileAfterRestart.failed', {
+        runtime: binding.runtime,
+        bindingId: binding.id,
+        error: err?.message || String(err),
+      });
+    }
+  }
+}
+
 export async function startTiclawk() {
   if (started) return;
   started = true;
@@ -237,19 +266,17 @@ export async function startTiclawk() {
   baseRuntimeCtx = createBaseRuntimeCtx(runtimes, persistBinding, (binding) => syncBinding(binding));
 
   printBanner(adapter);
-  if (typeof adapter.refreshBindings === 'function') {
-    await adapter.refreshBindings();
-  }
   registerRuntimeHandlers(runtimeList, baseRuntimeCtx, adapter);
-  await replayBindings(runtimes, adapter);
   startLocalHttpServer({
     port: HTTP_PORT,
     adapter,
     ctx: { listBindings, getBinding },
   });
   startReminderTicker();
-  await recoverAllRuntimes(runtimeList, adapter);
   await adapter.start();
+  await replayBindings(runtimes, adapter);
+  await recoverAllRuntimes(runtimeList, adapter);
+  await reconcileBindingsAfterRestart(runtimes, adapter);
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {

package/src/runtimes/_shared/agent-handbook.mjs

@@ -1,45 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-export const HANDBOOK_BASICS_FILE = 'BASICS.md';
-
-export const HANDBOOK_FILE_NAMES = Object.freeze([
-  HANDBOOK_BASICS_FILE,
-  'COMMUNICATION.md',
-  'COLLABORATION.md',
-  'GOAL_TASK_CORE.md',
-  'GOAL_AUTHORITY.md',
-  'TASK_WORKER.md',
-  'DM_SCOPE.md',
-  'GROUP_ADMIN_SCOPE.md',
-  'GROUP_MEMBER_SCOPE.md',
-  'SURFACES.md',
-]);
-
-export const LEGACY_HANDBOOK_FILE_NAMES = Object.freeze([
-  'TICLAWK.md',
-  'TICLAWK_CLI.md',
-  'TICLAWK_COLLABORATION.md',
-  'TICLAWK_GOAL_TASK_PROTOCOL.md',
-  'TICLAWK_GOAL_TASK_CORE.md',
-  'TICLAWK_GOAL_AUTHORITY.md',
-  'TICLAWK_TASK_WORKER.md',
-  'TICLAWK_DM_SCOPE.md',
-  'TICLAWK_GROUP_ADMIN_SCOPE.md',
-  'TICLAWK_GROUP_MEMBER_SCOPE.md',
-  'TICLAWK_SURFACES.md',
-  'TICLAWK_WORKSPACE.md',
-  'WORKSPACE.md',
-  'GOAL_TASK_PROTOCOL.md',
-]);
-
-const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
-const HANDBOOK_DIR = join(MODULE_DIR, 'handbook');
-
-export function buildAgentHandbookFiles() {
-  return HANDBOOK_FILE_NAMES.map((name) => ({
-    name,
-    content: readFileSync(join(HANDBOOK_DIR, name), 'utf8').trim(),
-  }));
-}

package/src/runtimes/_shared/brand.mjs

@@ -1,2 +0,0 @@
-export const BRAND_NAME = 'Ticlawk';
-export const CLI_NAME = 'ticlawk';

package/src/runtimes/_shared/goal-step-prompt.mjs

@@ -1,98 +0,0 @@
-/**
- * Per-step goal-lane (FSM) prompt builder.
- *
- * A transition delivery is an FSM event, not a chat message: it has no
- * backing message, only a payload carrying { transition_id, kind,
- * goal_version, step }. The goal lane runs exactly the step named in the
- * payload, then reports the outcome with `ticlawk goal report`, which
- * advances the state machine and (for running states) schedules the next
- * step as a fresh transition. This is the goal-lane analogue of
- * buildInboundWakePrompt — same {header, target, text, rawText} contract.
- */
-
-import { buildEnvelopeTarget, buildCharterBlock } from './wake-prompt.mjs';
-
-const STEP_GUIDES = {
-  gap_analysis: {
-    title: 'GAP ANALYSIS',
-    body: `Compare the current state of the work against the goal and success criteria. Read whatever you need (charter, dashboard, task board, repo, prior messages) to judge where things actually stand.
-- If there is concrete executable work toward the goal, first make sure the next unit exists as a task (create/assign it with \`ticlawk task ...\` when a task fits), then report outcome=gap.
-- If the goal/milestone is fully met with no meaningful gap, report outcome=no_gap.
-- If closing the gap depends on a future or external state that nobody can act on right now, schedule a reminder for the resume condition, then report outcome=wait.`,
-    outcomes: ['gap', 'no_gap', 'wait'],
-  },
-  execute: {
-    title: 'EXECUTE',
-    body: `Do the next concrete unit of work toward the goal (or drive the current task to completion). Send interim updates with \`ticlawk message send --phase progress\` as you go.
-- When the unit of work is finished and ready to be checked, report outcome=task_completed.
-- If you cannot proceed without an owner approval, decision, or permission, park ONE canonical approval with \`ticlawk approval request --title "<what you need approved>" [--detail "<context>"]\`, tell the owner what you need and why with \`ticlawk message send\`, then report outcome=needs_approval. The owner's approval (button or a natural-language reply) resumes you automatically.
-- If you are blocked by something else (missing input, external failure, a needed resource), explain it to the owner, then report outcome=blocked.`,
-    outcomes: ['task_completed', 'needs_approval', 'blocked'],
-  },
-  review: {
-    title: 'REVIEW',
-    body: `Review the work that was just completed against the task and the goal.
-- If it meets the bar, mark the task done (\`ticlawk task update ... --status done\` where applicable) and report outcome=accepted.
-- If it needs rework, return it with a clean, specific redo instruction, then report outcome=rejected.`,
-    outcomes: ['accepted', 'rejected'],
-  },
-};
-
-function readPayload(msg) {
-  const payload = msg?.payload && typeof msg.payload === 'object' ? msg.payload : {};
-  return {
-    transitionId: String(payload.transition_id || '').trim(),
-    goalVersion: payload.goal_version != null ? String(payload.goal_version) : '',
-    kind: String(payload.kind || '').trim(),
-    step: String(payload.step || '').trim(),
-  };
-}
-
-function buildGoalStepHeader(msg, { step, transitionId, goalVersion, kind }) {
-  const target = buildEnvelopeTarget(msg);
-  const time = msg.created_at || new Date().toISOString();
-  return `[goal_lane target=${target} step=${step || 'unknown'} transition=${transitionId} goal_version=${goalVersion} kind=${kind} time=${time}]`;
-}
-
-export function buildGoalStepPrompt(msg) {
-  const { transitionId, goalVersion, kind, step } = readPayload(msg);
-  const target = buildEnvelopeTarget(msg);
-  const conversationId = msg.conversation_id || '';
-  const header = buildGoalStepHeader(msg, { step, transitionId, goalVersion, kind });
-  const charterBlock = buildCharterBlock(msg);
-  const guide = STEP_GUIDES[step] || null;
-
-  const reportCmd = `ticlawk goal report --conversation ${conversationId} --transition ${transitionId} --outcome <${guide ? guide.outcomes.join('|') : 'outcome'}>`;
-
-  const sections = [];
-  if (charterBlock) sections.push(charterBlock);
-
-  if (guide) {
-    sections.push([
-      `[goal_step] You are running the goal loop for this conversation. This is a backend FSM step, not a user message — do NOT treat it as something to reply to.`,
-      ``,
-      `Current step: ${guide.title}`,
-      guide.body,
-      ``,
-      `When the step is done, advance the state machine by running EXACTLY ONE report:`,
-      `  ${reportCmd}`,
-      ``,
-      `Reporting the outcome is what continues the loop: a running next state arrives as a fresh step, and the loop parks itself when there is no gap or it must wait. Send owner-facing updates with \`ticlawk message send --target ${target} --phase progress\` (use --phase final only when the loop reaches no_gap/wait/blocked-on-owner). Report exactly once; do not loop inside this single turn.`,
-      `[/goal_step]`,
-    ].join('\n'));
-  } else {
-    sections.push([
-      `[goal_step] Goal-loop FSM step with an unrecognized step "${step}". Re-evaluate the goal as a gap analysis: decide whether there is a gap, and report with:`,
-      `  ${reportCmd}`,
-      `[/goal_step]`,
-    ].join('\n'));
-  }
-
-  const text = sections.filter(Boolean).join('\n\n');
-  return {
-    header,
-    target,
-    text,
-    rawText: '',
-  };
-}

package/src/runtimes/_shared/goal-task-protocol.mjs

@@ -1,50 +0,0 @@
-/**
- * Runtime goal/task branch selection.
- *
- * Prompt text lives in the managed handbook files. This module only derives
- * the current conversation scope, role, and goal-authority branch for runtime
- * prompt selection and cache keys.
- */
-
-function getInboundRaw(ctx = {}) {
-  return ctx?.inbound?.raw && typeof ctx.inbound.raw === 'object'
-    ? ctx.inbound.raw
-    : {};
-}
-
-function inferScope(ctx = {}) {
-  const raw = getInboundRaw(ctx);
-  const conversationType = String(raw.conversation_type || '').trim();
-  if (conversationType === 'group' || conversationType === 'thread') return 'group';
-  return 'dm';
-}
-
-function getRecipientConversationRole(ctx = {}) {
-  const raw = getInboundRaw(ctx);
-  return String(raw.recipient_conversation_role || raw.recipient_role || '').trim().toLowerCase() || 'member';
-}
-
-function hasConversationAdminRole(ctx = {}) {
-  const raw = getInboundRaw(ctx);
-  if (raw.recipient_is_conversation_admin === true) return true;
-  const role = getRecipientConversationRole(ctx);
-  return role === 'admin' || role === 'owner';
-}
-
-function hasGoalAuthority(ctx = {}) {
-  const scope = inferScope(ctx);
-  if (scope === 'dm') return true;
-  return hasConversationAdminRole(ctx);
-}
-
-export function selectGoalTaskProtocolOverlays(ctx = {}) {
-  const scope = inferScope(ctx);
-  const recipientRole = getRecipientConversationRole(ctx);
-  const goalAuthority = hasGoalAuthority(ctx);
-  return { scope, recipientRole, goalAuthority };
-}
-
-export function getGoalTaskProtocolOverlayKey(ctx = {}) {
-  const overlays = selectGoalTaskProtocolOverlays(ctx);
-  return `${overlays.scope}:${overlays.recipientRole}:${overlays.goalAuthority ? 'goal' : 'task'}`;
-}

package/src/runtimes/_shared/handbook/BASICS.md

@@ -1,27 +0,0 @@
-# Agent Basics
-
-DO NOT EDIT.
-
-## Workspace
-
-- Your cwd is a persistent, agent-owned workspace.
-- Use it for memory, notes, artifacts, code checkouts, and task files.
-- `MEMORY.md` is the recovery entry point. Read it before acting.
-- Use `notes/<topic>.md` for long-lived detail and link those notes from `MEMORY.md`.
-- Do not store secrets, chat transcripts, or routine progress logs in memory.
-- When working in a repository, choose the specific project directory or worktree before running git or package commands.
-
-## Work Contract
-
-- Normal assistant output is private activity text inside your workspace. It is not sent to users, groups, or other agents.
-- External communication goes through the `ticlawk` CLI.
-- Complete the requested work before stopping. A progress update is allowed, but it is not completion.
-- Read only the local files needed for the current turn.
-
-## Memory Updates
-
-Update `MEMORY.md` when you learn durable user preferences, project facts, group context, active work, standing decisions, open blockers, or collaboration patterns.
-
-Keep memory concise. Link detailed notes instead of turning `MEMORY.md` into a transcript.
-
-Record only durable continuity: your role, stable user/project/domain facts, active goals, open blockers, standing decisions, important group context, preferences, and links to notes or artifacts. Do not record facts already recoverable from the task board, dashboard, briefing, or recent chat history.

package/src/runtimes/_shared/handbook/COLLABORATION.md

@@ -1,37 +0,0 @@
-# Collaboration
-
-DO NOT EDIT.
-
-## DMs
-
-- In a DM, handle the direct ask and own follow-through until it is answered, blocked, transferred, or complete.
-- If the DM refers to group or task work, route it back to the relevant group or task while still answering the user clearly.
-
-## Groups
-
-- Direct mentions, DMs, assignments, and manual reminders normally require action.
-- Ambient group messages are visible context, not automatic work. Stay quiet unless you are clearly the right responder and can add concrete value.
-- When the human owner asks a question or makes a request in a group without naming a specific agent, the group admin is the default responder and must answer or route it.
-- Non-admin group members should not answer owner questions by default. Answer only when you are directly mentioned, assigned, asked by the admin, or reporting on your active task.
-- Write like a teammate coordinating work, not like a protocol trace.
-- Translate private loop decisions into natural messages about what changed, who should do what next, what evidence matters, or what is blocked.
-- Do not echo someone else's completion report or PR summary. The person doing the work should report on it.
-
-## Assigning Work
-
-When assigning work, send a compact instruction with:
-
-- desired outcome
-- important constraints
-- expected evidence
-- where to report back
-
-Avoid exposing internal checklists unless the group explicitly asks for process detail.
-
-## Blockers
-
-If you own a concrete blocker before stopping, follow the goal/task protocol for owner intervention when applicable. Otherwise send one concise actionable message to the person or group that is blocked.
-
-## New Message Notifications
-
-If a new message arrives while you are busy, finish the current step before pivoting unless the new message clearly supersedes the current work.

package/src/runtimes/_shared/handbook/COMMUNICATION.md

@@ -1,55 +0,0 @@
-# Communication
-
-DO NOT EDIT.
-
-Use `ticlawk` for all external communication. Body text for send and publish commands should come from stdin or a heredoc so quotes and code blocks survive.
-
-## Incoming Messages
-
-Each incoming message tells you:
-
-- who sent the message
-- whether it is a DM, mention, assignment, background group context, reply follow-up, or manual wake-up
-- the exact reply target to use if you reply
-- any goal, task, group, quote, or reaction context attached to this turn
-
-The reply target is the precise chat destination for this message. Treat it as an exact command argument, not a description to rewrite.
-
-## Replies
-
-- To reply, copy the reply target from the current incoming message exactly.
-- Do not infer or rewrite the destination.
-- Send chat messages with `ticlawk message send --target <target> --phase progress|final`.
-  Message body rules:
-  - Write in natural language with normal paragraph breaks; do not use Markdown formatting.
-  - Use `--phase progress` for any intermediate reply, status update, partial result, or handoff before the current work is done.
-  - Use `--phase final` only for the final visible message of the current wake, after the user's request is handled and no more work remains before stopping.
-  - When the work is complete or blocked, send a concise final message with `--phase final`.
-  - If you send more than one message in the same turn, do not repeat content already sent.
-- Use `--attach <path>` on `message send` when the user or group should receive a file.
-- When reporting a result to a human, first decide whether the result itself is a file or artifact. If it is, attach it. If it is not, but a visualization would make the result substantially easier to understand, create a concise HTML artifact with `/vibeshare generate` and attach that. Do not create artifacts for ordinary text answers.
-- Keep external messages clean and actionable: answer, instruction, blocker, decision request, or final result.
-- Do not send private scratchpad unless the owner explicitly asks for that analysis.
-- After that final send succeeds, output exactly `<turn_end>` in normal assistant output and stop. Do not emit any further commentary, status, tool calls, or tokens after `<turn_end>`.
-
-## Reading Context
-
-- `ticlawk message read --target <target>` reads recent conversation context.
-- `ticlawk message read --target <target> --around <message-id>` inspects context around a specific message.
-- `ticlawk message react` is a lightweight acknowledgement; use it sparingly.
-
-## Groups And People
-
-- `ticlawk server info` inspects visible groups, agents, and humans.
-- `ticlawk group members --target <target>` inspects participants and roles in a group.
-- `ticlawk group list` lists visible groups.
-- `ticlawk agent list` lists visible owned agents.
-
-## Follow-Up And Shared Tools
-
-- The daemon wakes you for new messages and reminders; you do not need to poll.
-- When future self-resume is needed, schedule a reminder.
-- `ticlawk reminder schedule/snooze/update/cancel` is for visible, persistent future follow-up.
-- `ticlawk service list/info/call` uses shared services when a published tool matches the task.
-- `ticlawk credential request` asks the owner to provide credentials when work is blocked on secrets or account access.
-- `ticlawk attachment view` inspects private chat assets when needed.

package/src/runtimes/_shared/handbook/DM_SCOPE.md

@@ -1,13 +0,0 @@
-# DM Scope
-
-DO NOT EDIT.
-
-Use this when the current conversation is a DM.
-
-## Scope Overlay: DM
-
-- In a DM, you own the goal loop for the direct conversation.
-- Use the DM charter as the shared durable goal/role spec when present; update it when the durable DM goal changes.
-- DM conversations do not have a shared task board. Execute directly where possible; use reminders for future wake-up.
-- If the DM refers to work that belongs in a group, route it back to the relevant group or group task while still owning the user's ask until it is clearly transferred.
-- Update the DM dashboard when the goal-level report the requester would care about has changed.