ftown-bridge 0.19.37 → 0.19.39

package/dist/wire-types.d.ts

@@ -43,6 +43,8 @@ export interface Session {
     shellType?: string;
     model?: string;
     parentSessionId?: string;
+    /** Historical automation provenance; new sessions cannot set it. */
+    loopId?: string;
     usage?: SessionUsage;
 }
 export type MailType = 'message' | 'task' | 'result' | 'escalation';
@@ -60,54 +62,8 @@ export interface MailMessage {
     deliveredAt?: string;
     deliveredVia?: string;
 }
-export type LoopHarness = 'claude' | 'cursor' | 'codex' | 'grok' | 'muse' | 'pi' | 'kimi-code' | 'opencode' | 'shell';
-export type LoopSchedule = {
-    kind: 'interval';
-    everyMs: number;
-} | {
-    kind: 'cron';
-    expression: string;
-    tz?: string;
-};
-/** Body for POST /api/loops and PATCH /api/loops/:id (as a Partial). */
-export interface LoopDraft {
-    name: string;
-    schedule: LoopSchedule;
-    harness: LoopHarness;
-    workdir?: string;
-    task: string;
-    model?: string;
-    enabled: boolean;
-    overlapPolicy: 'skip' | 'allow';
-    retention: {
-        autoClearAfterRuns: number | null;
-    };
-    preflight?: {
-        command: string;
-        timeoutMs?: number;
-    };
-    postflight?: {
-        command: string;
-        timeoutMs?: number;
-        runOnSkip?: boolean;
-    };
-    maxRuntimeMs?: number;
-    group?: string;
-}
-/** Loop shape as returned by GET /api/loops and /api/loops/:id. */
-export interface LoopInfo extends LoopDraft {
-    id: string;
-    bridgeId: string;
-    createdAt: string;
-    updatedAt: string;
-    lastRunAt?: string;
-    nextRunAt?: string;
-    lastStatus?: 'ok' | 'error' | 'running' | 'skipped';
-    lastSessionId?: string;
-    runCount: number;
-    skipCount: number;
-    runNowRequested?: boolean;
-}
+export declare const AUTOMATION_REMOVED_CODE: "automation_removed";
+export declare const AUTOMATION_REMOVED_MESSAGE = "Recurring loops and factory automation have been removed";
 /**
  * Keystrokes appended after `send`/`keys` text to submit it, keyed by shell type.
  *

package/dist/wire-types.js

@@ -7,6 +7,8 @@
 // are the shapes as seen over the wire by those CLIs — not necessarily identical to the
 // richer internal types in ./types.ts.
 export const MAIL_TYPES = ['message', 'task', 'result', 'escalation'];
+export const AUTOMATION_REMOVED_CODE = 'automation_removed';
+export const AUTOMATION_REMOVED_MESSAGE = 'Recurring loops and factory automation have been removed';
 /**
  * Keystrokes appended after `send`/`keys` text to submit it, keyed by shell type.
  *

package/dist/wire-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"wire-types.js","sourceRoot":"","sources":["../src/wire-types.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,mFAAmF;AACnF,6FAA6F;AAC7F,EAAE;AACF,mFAAmF;AACnF,sFAAsF;AACtF,wFAAwF;AACxF,uCAAuC;AAsDvC,MAAM,CAAC,MAAM,UAAU,GAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC;AAsD3F;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAAC,UAAmB;IAC9C,OAAO,IAAI,CAAC;AACd,CAAC;AAED,0DAA0D;AAC1D,MAAM,UAAU,iBAAiB,CAAC,CAAc;IAC9C,OAAO,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;AACpE,CAAC"}
+{"version":3,"file":"wire-types.js","sourceRoot":"","sources":["../src/wire-types.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,mFAAmF;AACnF,6FAA6F;AAC7F,EAAE;AACF,mFAAmF;AACnF,sFAAsF;AACtF,wFAAwF;AACxF,uCAAuC;AAwDvC,MAAM,CAAC,MAAM,UAAU,GAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC;AAgB3F,MAAM,CAAC,MAAM,uBAAuB,GAAG,oBAA6B,CAAC;AACrE,MAAM,CAAC,MAAM,0BAA0B,GAAG,0DAA0D,CAAC;AAErG;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAAC,UAAmB;IAC9C,OAAO,IAAI,CAAC;AACd,CAAC;AAED,0DAA0D;AAC1D,MAAM,UAAU,iBAAiB,CAAC,CAAc;IAC9C,OAAO,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;AACpE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ftown-bridge",
-  "version": "0.19.37",
+  "version": "0.19.39",
   "description": "CLI bridge for ftown — generic PTY-over-Centrifugo relay",
   "type": "module",
   "main": "dist/index.js",
@@ -54,7 +54,6 @@
     "@xterm/headless": "^6.0.0",
     "centrifuge": "^5.2.2",
     "commander": "^13.1.0",
-    "cron-parser": "^4.9.0",
     "express": "^5.3.0",
     "express-rate-limit": "^8.7.1",
     "jsonwebtoken": "^9.0.3",

package/pi-extension/API.md

@@ -8,7 +8,6 @@ The bundled Pi extension exposes ftown's authenticated local bridge API as a sma
 | --- | --- | --- | --- |
 | Session | Opaque UUID, or a unique exact name for lookup | Optional parent session; owns inbox, usage, screen, and log | Create, inspect, rename, reparent, stop, remove, revive |
 | Mail message | Assigned by the session inbox | Sent from one session to another; optional thread | Send, peek/read, delivered |
-| Loop | Opaque ID, or a unique exact name for lookup | Owns loop runs | Create, inspect, update, run, delete |
 
 All tools talk only to the local bridge selected by `FTOWN_HOOK_PORT` or `~/.ftown/bridge.json`. The extension supplies that bridge's bearer token and never sends credentials to the model.
 
@@ -31,15 +30,8 @@ All tools talk only to the local bridge selected by `FTOWN_HOOK_PORT` or `~/.fto
 | `ftown_session_manage` | `reparent` | `target`, `parent` | Updated session | Yes |
 | `ftown_session_manage` | `remove` | `target` | Removal acknowledgement | Yes |
 | `ftown_session_manage` | `revive` | `target` | Recreated session and resume state | Yes |
-| `ftown_loops` | `list` | None | `{ loops }` | No |
-| `ftown_loops` | `get` | `target` | `{ loop }` | No |
-| `ftown_loops` | `create` | `name`, `task`, `schedule` | `{ loop }` | Yes |
-| `ftown_loops` | `update` | `target` and changed fields | `{ loop }` | Yes |
-| `ftown_loops` | `delete` | `target` | Removal acknowledgement | Yes |
-| `ftown_loops` | `runs` | `target` | Loop run history | No |
-| `ftown_loops` | `run_now` | `target` | Requested loop run | Yes |
 
-`target` accepts an opaque ID or a unique exact name. Mail additionally accepts `parent`. Reparenting with `parent: null` clears the parent. Session and loop creation intentionally accept structured fields only; arbitrary session commands, environment variables, and loop preflight/postflight shell commands are not part of the model-facing contract.
+`target` accepts an opaque ID or a unique exact name. Mail additionally accepts `parent`. Reparenting with `parent: null` clears the parent. Session creation intentionally accepts structured fields only; arbitrary session commands and environment variables are not part of the model-facing contract.
 
 The extension also registers `/ftown-mail read [--peek]`, `/ftown-mail send <session> <message>`, and `/ftown-sessions` for interactive use.
 
@@ -57,11 +49,11 @@ into the terminal.
 
 The local bridge bearer token authorizes access to the current ftown user's bridge resources. Session name resolution is performed against that same authenticated bridge. The model can inspect a terminal screen or search its captured log, but it cannot inject raw terminal keystrokes, resize terminals, clear terminal history, or call hook/conversation-resolution internals through these tools.
 
-Mutation executions are deduplicated in the running extension by `(tool name, Pi tool-call ID)`, including concurrent retries. Failed attempts are not cached. This prevents a retried model tool call from duplicating mail, sessions, management actions, or loop runs; it is not a durable idempotency key across Pi process restarts.
+Mutation executions are deduplicated in the running extension by `(tool name, Pi tool-call ID)`, including concurrent retries. Failed attempts are not cached. This prevents a retried model tool call from duplicating mail, sessions, or management actions; it is not a durable idempotency key across Pi process restarts.
 
 ## Pagination and errors
 
-Inbox reads accept `limit` from 1 to 100. Screen and log operations accept zero-based `offset`; screen `limit` is 1 to 1,000, log `limit` is 1 to 1,000, and grep context is 0 to 10 lines. Session and loop collection endpoints currently return the bridge's complete local collection and inherit its unpaginated behavior.
+Inbox reads accept `limit` from 1 to 100. Screen and log operations accept zero-based `offset`; screen `limit` is 1 to 1,000, log `limit` is 1 to 1,000, and grep context is 0 to 10 lines. Session collection endpoints currently return the bridge's complete local collection and inherit its unpaginated behavior.
 
 Transport failures, missing/ambiguous names, unavailable parent context, validation failures, and bridge `{ "error": string }` responses become Pi tool errors. No response body, token, stack trace, or upstream URL is exposed to the model.
 
@@ -71,4 +63,4 @@ The tool schemas ship with `ftown-bridge` and follow its semantic version. Addin
 
 ## Consumer walkthrough
 
-An agent can call `ftown_sessions.list`, use the returned session ID with `ftown_sessions.get` or `usage`, and then send context with `ftown_mail.send`. To delegate, it can create a child with `ftown_session_create`, retain the returned ID, inspect its output, and later rename, reparent, stop, remove, or revive it. For scheduled work, it can create or update a structured loop, request `run_now`, then inspect `runs` without leaving Pi.
+An agent can call `ftown_sessions.list`, use the returned session ID with `ftown_sessions.get` or `usage`, and then send context with `ftown_mail.send`. To delegate, it can create a child with `ftown_session_create`, retain the returned ID, inspect its output, and later rename, reparent, stop, remove, or revive it.

package/pi-extension/ftown.js

@@ -638,144 +638,6 @@ export function registerFtownPiExtension(pi, options = {}) {
     },
   });
 
-  async function listLoops() {
-    const payload = await requestJson('/api/loops', { method: 'GET' });
-    return Array.isArray(payload?.loops) ? payload.loops : [];
-  }
-
-  function resolveLoop(loops, target) {
-    const normalized = target?.trim();
-    if (!normalized) throw new Error('A loop id or name is required');
-    const byId = loops.find((loop) => loop.id === normalized);
-    if (byId) return byId;
-    const byName = loops.filter((loop) => loop.name === normalized);
-    if (byName.length === 1) return byName[0];
-    if (byName.length > 1) throw new Error(`Multiple loops are named "${normalized}"; use an id`);
-    throw new Error(`Loop not found: ${normalized}`);
-  }
-
-  const loopScheduleProperty = {
-    type: 'object',
-    properties: {
-      kind: { type: 'string', enum: ['interval', 'cron'] },
-      everyMs: { type: 'integer', minimum: 1000 },
-      expression: { type: 'string', minLength: 1 },
-      tz: { type: 'string', minLength: 1 },
-    },
-    required: ['kind'],
-    additionalProperties: false,
-  };
-  const loopDraftProperties = {
-    name: { type: 'string', minLength: 1 },
-    task: { type: 'string', minLength: 1 },
-    schedule: loopScheduleProperty,
-    shell: { type: 'string', enum: ['claude', 'cursor', 'codex', 'grok', 'pi', 'kimi-code', 'opencode', 'shell'] },
-    workdir: { type: 'string' },
-    model: { type: 'string' },
-    enabled: { type: 'boolean' },
-    overlapPolicy: { type: 'string', enum: ['skip', 'allow'] },
-    retention: { type: ['integer', 'null'], minimum: 0 },
-    maxRuntimeMs: { type: 'integer', minimum: 1000 },
-    group: { type: 'string' },
-  };
-  const loopDraftFields = Object.keys(loopDraftProperties);
-
-  function validateLoopSchedule(schedule) {
-    requireProperty({ schedule }, 'schedule');
-    if (schedule === null || typeof schedule !== 'object') throw new Error('schedule is required');
-    requireOperation({ operation: schedule.kind }, ['interval', 'cron']);
-    if (schedule.kind === 'interval') requireProperty(schedule, 'everyMs', 'schedule.everyMs');
-    if (schedule.kind === 'cron') requireString(schedule, 'expression', 'schedule.expression');
-  }
-
-  function validateLoopParams(params) {
-    requireOperation(params, ['list', 'get', 'runs', 'run_now', 'delete', 'create', 'update']);
-    if (['get', 'runs', 'run_now', 'delete', 'update'].includes(params.operation)) {
-      requireString(params, 'target');
-    }
-    if (params.operation === 'create') {
-      requireString(params, 'name');
-      requireString(params, 'task');
-      requireProperty(params, 'schedule');
-    }
-    if (params.operation === 'update' && !loopDraftFields.some((field) => hasOwn(params, field))) {
-      throw new Error('At least one field to update is required');
-    }
-    if (hasOwn(params, 'schedule')) validateLoopSchedule(params.schedule);
-  }
-
-  function loopBody(params, create = false) {
-    const body = {};
-    for (const field of ['name', 'task', 'schedule', 'workdir', 'model', 'enabled', 'overlapPolicy', 'maxRuntimeMs', 'group']) {
-      if (Object.prototype.hasOwnProperty.call(params, field)) body[field] = params[field];
-    }
-    if (Object.prototype.hasOwnProperty.call(params, 'shell')) body.harness = params.shell;
-    if (Object.prototype.hasOwnProperty.call(params, 'retention')) {
-      body.retention = { autoClearAfterRuns: params.retention };
-    }
-    if (create) {
-      body.harness ??= 'pi';
-      body.enabled ??= true;
-      body.overlapPolicy ??= 'skip';
-      body.retention ??= { autoClearAfterRuns: 10 };
-    }
-    return body;
-  }
-
-  pi.registerTool({
-    name: 'ftown_loops',
-    label: 'ftown loops',
-    description: 'List, inspect, create, update, delete, or run scheduled ftown loops.',
-    parameters: {
-      type: 'object',
-      properties: {
-        operation: {
-          type: 'string',
-          enum: ['list', 'get', 'runs', 'run_now', 'delete', 'create', 'update'],
-        },
-        target: { type: 'string' },
-        ...loopDraftProperties,
-      },
-      required: ['operation'],
-      additionalProperties: false,
-    },
-    async execute(toolCallId, params) {
-      try {
-        validateLoopParams(params);
-        if (params.operation === 'create') {
-          return await executeOnce('ftown_loops', toolCallId, async () =>
-            toolResult(await requestJson('/api/loops', {
-              method: 'POST', body: JSON.stringify(loopBody(params, true)),
-            })));
-        }
-        const loops = await listLoops();
-        if (params.operation === 'list') return toolResult({ loops });
-        const loop = resolveLoop(loops, params.target);
-        const loopPath = `/api/loops/${encodeURIComponent(loop.id)}`;
-        if (params.operation === 'get') {
-          return toolResult(await requestJson(loopPath, { method: 'GET' }));
-        }
-        if (params.operation === 'runs') {
-          return toolResult(await requestJson(`${loopPath}/runs`, { method: 'GET' }));
-        }
-        const mutate = async () => {
-          if (params.operation === 'run_now') {
-            return toolResult(await requestJson(`${loopPath}/run-now`, { method: 'POST' }));
-          }
-          if (params.operation === 'delete') {
-            return toolResult(await requestJson(loopPath, { method: 'DELETE' }));
-          }
-          return toolResult(await requestJson(loopPath, {
-            method: 'PATCH', body: JSON.stringify(loopBody(params)),
-          }));
-        };
-        return await executeOnce('ftown_loops', toolCallId, mutate);
-      } catch (error) {
-        return toolError(error);
-      }
-    },
-  });
-
   async function deliverMail(wait = 0, signal) {
     const messages = await drainMail(wait, signal);
     if (signal?.aborted || messages.length === 0) return 0;

package/skills/ftown/SKILL.md

@@ -2,31 +2,23 @@
 name: ftown
 description: >-
   Control ftown from inside agent sessions: create/list/read/drive sibling
-  sessions, send ftown mail, manage recurring scheduled loops, coordinate worker
-  agents through fticket when available, and run deterministic ftown-workflows. Use when a task mentions ftown,
-  ftown sessions, bridge sessions, child/sibling agents, mail/inbox, scheduled
-  loops, recurring agent runs, orchestration, fan-out, or ftown-workflows.
+  sessions, send ftown mail, and coordinate worker agent sessions. Use when a task
+  mentions ftown, ftown sessions, bridge sessions, child/sibling agents, mail/inbox,
+  orchestration, or fan-out.
 ---
 
 # ftown
 
 Use the local bridge CLIs installed under `~/.ftown`. They read
 `~/.ftown/bridge.json`; anyone who can read that file can control the bridge's
-sessions and loops.
+sessions.
 
 ## Pick The Reference
 
 - Session control, mail, terminal output, archive/revive, or local API:
   read `references/sessions.md`.
-- Recurring scheduled work, cron/interval loops, loop run history:
-  read `references/loops.md`.
 - Ad-hoc multi-agent coordination from an orchestrator session:
   read `references/orchestrator.md`.
-- Ticket-backed multi-agent coordination, durable status/context, dependencies, and
-  resource leases: read the installed `fticket` skill. Prefer FTS over direct messages
-  whenever an existing `FTS_DB`/ticket is available.
-- Scripted, resumable, deterministic multi-session fan-out:
-  read `references/workflows.md`.
 
 ## Quick Commands
 
@@ -36,20 +28,6 @@ sessions and loops.
 ~/.ftown/ftown-sessions create --prompt "Run tests" --workdir "$PWD" --parent
 ~/.ftown/ftown-sessions screen <session-id> --limit 200
 ~/.ftown/ftown-sessions tell <session-id> --type task "continue with the API client"
-
-# Loops
-~/.ftown/ftown-sessions loops
-~/.ftown/ftown-sessions loop create --name repo-watch --every 30m --shell codex --workdir "$PWD" --task "Review recent changes"
-~/.ftown/ftown-sessions loop run <loop-id>
-
-# Workflows
-~/.ftown/ftown-workflows run path/to/script.mjs --workdir "$PWD"
-
-# FTS-backed coordination (when FTS_DB/TICKET_ID are supplied)
-fts show --db "$FTS_DB" "$TICKET_ID" --json
-fts resources --db "$FTS_DB" --json
 ```
 
-Prefer loops for unattended recurrence. Prefer workflows for deterministic
-control flow inside one run. Prefer orchestrator guidance for ad-hoc
-human-in-the-loop multi-agent coordination.
+Use orchestrator guidance for ad-hoc multi-agent coordination.

package/skills/ftown/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "ftown"
-  short_description: "Control ftown sessions, loops, orchestration, and workflows."
-  default_prompt: "Use ftown to manage sessions, loops, or workflows."
+  short_description: "Control ftown sessions, mail, and orchestration."
+  default_prompt: "Use ftown to manage sessions and mail."

package/skills/ftown/references/orchestrator.md

@@ -6,37 +6,6 @@ can coordinate worker agent sessions on this machine using the
 
 See `references/sessions.md` for the full session CLI reference.
 
-## Coordination priority: FTS first
-
-FTS (`fticket`) is the primary coordination plane whenever the task supplies an
-`FTS_DB`/`TICKET_ID` or the repository already has `.ffactory/factory.db`. Read the
-installed `fticket` skill before operating it.
-
-- **Context:** read `fts show --db "$FTS_DB" "$TICKET_ID" --json` and the ticket's
-  immutable artifact folder. Write durable handoffs there instead of sending them in chat.
-- **Status:** use claims, lifecycle transitions, renewals, notes, `fts board`, and
-  `fts events`; these are the shared source of truth for every worker and orchestrator.
-- **Resources:** register named shared surfaces once, then require workers to acquire an
-  exclusive/shared lease before use and release it afterward. A waitlisted lease means
-  the worker must not touch that resource; the FTS scheduler promotes it FIFO.
-- **Dependencies:** express ordering with ticket dependencies rather than messages such as
-  "wait until worker A is done."
-
-Do not initialize a new FTS database merely because one is absent unless creating that
-control plane is within the user's requested scope. When no FTS database/ticket exists,
-or when a fenced worker cannot write to FTS, ftown mail is the fallback. Use mail for
-urgent escalation that needs to wake a human/agent; do not duplicate routine context and
-status in both systems.
-
-Useful inspection commands:
-
-```bash
-fts board --db "$FTS_DB"
-fts show --db "$FTS_DB" "$TICKET_ID" --json
-fts resources --db "$FTS_DB" --json
-fts events --db "$FTS_DB" --after <cursor>
-```
-
 ## Spawning workers
 
 Omit `--shell` to inherit the orchestrator's current harness. Use `--shell` only
@@ -53,10 +22,9 @@ parent to `$FTOWN_SESSION_ID`.
   --prompt "Review the auth module and summarize findings"
 ```
 
-Returns JSON containing `session.id` — save it to inspect the worker later. For
-FTS-backed work, put `FTS_DB`, `TICKET_ID`, `WORKER_ID`, and the claim fence in the
-worker briefing; the ticket/artifacts remain the durable handoff. Workers spawned with
-`--parent` are also auto-briefed about the FTS-first policy and mail fallback.
+Returns JSON containing `session.id` — save it to inspect the worker later.
+Workers spawned with `--parent` are auto-briefed about reporting results and
+escalations through mail, then removing themselves when finished.
 Provider-flavored workers require a bridge-host token configured with
 `ftown env set <flavor> <token>`; the bridge supplies their endpoint/model
 environment when it spawns them.
@@ -74,12 +42,10 @@ environment when it spawns them.
 ~/.ftown/ftown-sessions running <session-id>
 ```
 
-For FTS-backed work, observe `fts events --after <cursor>`, `fts show`, and
-`fts resources` rather than asking every worker for status. Use `screen` / `grep` to
-investigate a worker whose ticket/claim has gone quiet. When operating without FTS, end
-your turn and let fallback mail wake you instead of running a polling loop.
+Use `screen` / `grep` to investigate a worker that has gone quiet. When waiting for
+results, end your turn and let mail wake you instead of running a polling loop.
 
-## Messaging fallback (mail)
+## Messaging (mail)
 
 Each session has an inbox. Claude and codex receive mail automatically at turn
 boundaries via hooks. Pi's bundled extension maintains a long-poll and wakes idle
@@ -101,15 +67,14 @@ ftown-harness mail send <child> --thread <id> "use the v2 endpoint"
 ftown-harness mail read
 ```
 
-Without FTS, children report back with `mail send --parent --type result` (or
-`--type escalation` when blocked). With FTS, use this only for an urgent escalation or
-when a fenced/unavailable database prevents recording the outcome. Fan-out still works via
+Children report back with `mail send --parent --type result` (or
+`--type escalation` when blocked). Fan-out works via
 `~/.ftown/ftown-sessions tell --children "pause and report status"` (now mail
 under the hood; one of `--parent | --children | --siblings`).
 
 If a worker is idle and must be woken right now, terminal keystroke injection
 (`ftown-harness send <id> "..." -s` or `tell --keys`) is the **last resort** —
-prefer an FTS update/event, then fallback mail, which arrives at the next turn boundary.
+prefer mail, which arrives at the next turn boundary.
 
 ## Cleanup
 
@@ -126,30 +91,10 @@ Child briefings normally make workers report first and then remove themselves. E
 ask a worker to stay open when you need follow-up interaction; otherwise, clean up any
 worker that exits without honoring the self-removal instruction.
 
-## Recurring work
-
-For unattended recurring work, create a scheduled loop instead of keeping an
-orchestrator alive to poll or sleep. See `references/loops.md` for the full loop
-workflow:
-
-```bash
-~/.ftown/ftown-sessions loop create \
-  --name repo-watch \
-  --every 30m \
-  --shell codex \
-  --workdir /path/to/repo \
-  --task "Inspect recent changes, run the focused checks, and report issues"
-```
-
-Loop runs show as normal ftown sessions grouped under their loop in the
-dashboard. Use `~/.ftown/ftown-sessions loop runs <loop-id>` to inspect run
-sessions from the CLI.
-
 ## Practical guidance
 
 - **Parallelize** independent tasks: spawn multiple workers before waiting for any.
-- **Observe shared state**: prefer `fts events`/`show`/`resources`; use `screen` / `grep`
-  for diagnosis and mail only as fallback.
+- **Follow worker results**: read incoming mail and use `screen` / `grep` for diagnosis.
 - **Name workers clearly**: `--name` shows in `list` output and as the sender
   name on incoming mail.
 - **Check `list` first**: see what's already running before spawning duplicates.

package/skills/ftown/references/sessions.md

@@ -51,12 +51,6 @@ top-level `~/.ftown/ftown` dispatcher.
 ~/.ftown/ftown-sessions revive <session-id>
 ```
 
-## Scheduled loops
-
-Loop runs are normal sessions tagged with `loopId`. For loop creation,
-schedule syntax, manual runs, pause/resume, and run history, read
-`references/loops.md`.
-
 ## Messaging (mail)
 
 `tell` posts to the target session's **inbox**. Mail is delivered into the
@@ -137,11 +131,9 @@ Spawned ftown sessions receive:
 
 Agent children (any `--shell` except `shell`) spawned with a parent also get an
 automatic one-paragraph briefing prepended to their first input: it states their
-name/id and parent name/id. When the task provides `FTS_DB` and `TICKET_ID`, the
-briefing makes fticket the primary coordination plane for context, status, and
-resource leases; mail is reserved for fallback/urgent escalation. Without FTS,
-it explains how to report via `ftown-harness mail send --parent --type result`.
-After recording or reporting the outcome, the child is instructed to remove itself as
+name/id and parent name/id. It explains how to report via
+`ftown-harness mail send --parent --type result` (or `--type escalation` when blocked).
+After reporting the outcome, the child is instructed to remove itself as
 its final command unless the user explicitly asked it to stay open. The creator's
 `--prompt` follows after a `Task:` line.
 
@@ -171,11 +163,6 @@ The CLI wraps the loopback API. Raw access if needed:
 | DELETE | `/api/sessions/:id` | Remove (tombstone-archived) |
 | GET | `/api/archive` | List removed-session tombstones |
 | POST | `/api/sessions/:id/revive` | Recreate a removed session (new id) |
-| GET | `/api/loops` | List scheduled loops |
-| POST | `/api/loops` | Create a scheduled loop on this bridge |
-| GET/PATCH/DELETE | `/api/loops/:id` | Inspect, update, or delete a loop |
-| POST | `/api/loops/:id/run-now` | Request an immediate loop run; returns 404 `reason: not_found` if the loop no longer exists |
-| GET | `/api/loops/:id/runs` | List run sessions for a loop |
 
 To move a session under a different parent, PATCH it with the new parent's id:
 

package/skills/ftown/references/workflows.md

@@ -11,9 +11,7 @@ This complements the by-hand orchestrator playbook in
 repeatable; use orchestrator guidance when you need to improvise or keep a
 human in the loop.
 
-This is separate from **scheduled loops** managed by `~/.ftown/ftown-sessions
-loop ...`. Scheduled loops create recurring ftown sessions over time. A workflow
-loop is control flow inside one deterministic workflow run.
+A workflow runs deterministic control flow inside one explicitly started run.
 
 ## Operating Contract
 

package/dist/loop-controller.d.ts

@@ -1,87 +0,0 @@
-import type { Loop, LoopDraft, LoopRunRecord, Session } from './types.js';
-/**
- * Transport-agnostic loop operations, defined ONCE and shared by the two
- * dispatch surfaces (the Centrifugo RPC switch in index.ts and the local HTTP
- * router in local-api-server.ts). Methods take already-parsed typed input and
- * return typed results/errors; the adapters own all wire concerns (command
- * envelopes, HTTP statuses, response payload shaping).
- *
- * Error-propagation contract (matches the pre-refactor adapters byte for byte):
- * - `create`/`update` catch store/publish failures and return `code: 'failed'`
- *   (the HTTP adapter mapped those to 400).
- * - `delete`/`runNow`/`runs` let unexpected failures THROW (the RPC adapter's
- *   outer catch and the HTTP router's 500 handler mapped those before).
- */
-export type LoopErrorCode = 'invalid' | 'not_found' | 'failed';
-export interface LoopControllerError {
-    ok: false;
-    code: LoopErrorCode;
-    message: string;
-}
-export type LoopControllerResult<T> = ({
-    ok: true;
-} & T) | LoopControllerError;
-/** Outcome of a manual fire request. `fired: false` is NOT an error at the
- * controller level — the RPC adapter reports it as a successful response with
- * a reason, while the HTTP adapter maps `not_found` to a 404. */
-export type RunLoopNowOutcome = {
-    fired: true;
-    loop: Loop;
-} | {
-    fired: false;
-    reason: 'not_found' | 'overlap';
-};
-/** Injectable persistence surface (defaults to the real file-backed module). */
-export interface LoopStoreApi {
-    createLoop(draft: LoopDraft): Loop;
-    getLoop(id: string): Loop | undefined;
-    listLoops(): Loop[];
-    updateLoop(id: string, patch: Partial<LoopDraft>): Loop | null;
-    deleteLoop(id: string): boolean;
-    mutateLoopRuntime(id: string, fn: (loop: Loop) => void): Loop | null;
-}
-export interface LoopRunStoreApi {
-    deleteLoopRunRecords(loopId: string): void;
-    listLoopRunRecordsWithFallback(loopId: string, sessions: Session[], loadLog?: (sessionId: string) => Promise<string>): Promise<LoopRunRecord[]>;
-}
-export interface LoopControllerDeps {
-    /** Loops are always owned by the bridge they were created on; every draft's
-     * bridgeId is forced to this value. */
-    bridgeId: string;
-    scheduler: {
-        kick(): void;
-        onLoopDeleted(loop: Loop): void;
-    };
-    /** runner.isRunning — used by the run-now overlap guard. */
-    isSessionRunning(sessionId: string): boolean;
-    publishLoopUpdate(loop: Loop): Promise<void>;
-    publishLoopRemoved(loopId: string): Promise<void>;
-    /** Wire-safe (env-stripped) session list, for the loop-runs fallback. */
-    listWireSessions(): Promise<Session[]>;
-    loadTerminalLog(sessionId: string): Promise<string>;
-    loopStore?: LoopStoreApi;
-    loopRunStore?: LoopRunStoreApi;
-}
-export declare class LoopController {
-    private readonly deps;
-    private readonly loopStore;
-    private readonly loopRunStore;
-    constructor(deps: LoopControllerDeps);
-    /** Create a loop owned by this bridge. bridgeId is forced to THIS bridge —
-     * a loop is always owned by its runner, whatever the caller sent. */
-    create(input: Partial<LoopDraft>): Promise<LoopControllerResult<{
-        loop: Loop;
-    }>>;
-    list(): Loop[];
-    get(loopId: string): LoopControllerResult<{
-        loop: Loop;
-    }>;
-    update(loopId: string, patch: Partial<LoopDraft>): Promise<LoopControllerResult<{
-        loop: Loop;
-    }>>;
-    delete(loopId: string): Promise<{
-        removed: boolean;
-    }>;
-    runNow(loopId: string): Promise<RunLoopNowOutcome>;
-    runs(loopId: string): Promise<LoopRunRecord[]>;
-}