@markjaquith/agency 3.2.2 → 3.2.4

package/src/usage-log.ts

@@ -1,21 +1,92 @@
 import { Database } from "bun:sqlite"
+import { createHash } from "node:crypto"
 import { mkdir } from "node:fs/promises"
 import { dirname, join } from "node:path"
 
 const USAGE_EVENT_VERSION = 2 as const
 const DEFAULT_RETENTION_DAYS = 90
 
+const INVOCATION_SOURCES = new Set(["human", "agent", "automation"])
+const USAGE_EVENT_COLUMNS = new Set([
+	"id",
+	"event_version",
+	"journey_id",
+	"journey_sequence",
+	"invocation_source",
+	"is_test",
+	"occurred_at",
+	"agency_version",
+	"command_path",
+	"flag_names",
+	"duration_ms",
+	"outcome",
+	"outcome_code",
+	"exit_status",
+	"vcs",
+	"terminal_stage",
+	"category",
+])
+
+export type UsageOutcomeCode =
+	| "SUCCESS"
+	| "NONZERO_EXIT"
+	| "CLI_USAGE"
+	| "WORKBASE_NOT_FOUND"
+	| "WORKBASE_INVALID"
+	| "VALIDATION_FAILED"
+	| "CONFLICT"
+	| "FILESYSTEM_ERROR"
+	| "PROCESS_ERROR"
+	| "COMMAND_FAILED"
+
 export interface UsageEvent {
 	readonly commandPath: string
 	readonly flagNames: readonly string[]
 	readonly durationMs: number
 	readonly exitStatus: number
 	readonly outcome: "success" | "failure"
+	readonly outcomeCode: UsageOutcomeCode
 	readonly vcs?: "git"
 	readonly terminalStage?: string
 	readonly category?: string
 }
 
+export const usageOutcomeCode = (error: unknown): UsageOutcomeCode => {
+	const tag =
+		typeof error === "object" &&
+		error !== null &&
+		"_tag" in error &&
+		typeof error._tag === "string"
+			? error._tag
+			: error instanceof Error
+				? error.name
+				: undefined
+	switch (tag) {
+		case "CliUsageError":
+			return "CLI_USAGE"
+		case "WorkbaseNotFoundError":
+			return "WORKBASE_NOT_FOUND"
+		case "WorkbaseConfigError":
+		case "WorkbaseRegistryError":
+		case "FrontmatterParseError":
+			return "WORKBASE_INVALID"
+		case "ValidationFailedError":
+			return "VALIDATION_FAILED"
+		case "ClaimConflictError":
+		case "ClaimOwnershipError":
+		case "RevisionConflictError":
+		case "ExecutionGuardError":
+			return "CONFLICT"
+		case "FileNotFoundError":
+		case "FileSystemError":
+			return "FILESYSTEM_ERROR"
+		case "ProcessError":
+			return "PROCESS_ERROR"
+		default:
+			return "COMMAND_FAILED"
+	}
+}
+
 const stateDirectory = (env: NodeJS.ProcessEnv) =>
 	env.XDG_STATE_HOME ?? join(env.HOME ?? ".", ".local", "state")
 
@@ -32,36 +103,68 @@ const retentionDays = (env: NodeJS.ProcessEnv) => {
 		: DEFAULT_RETENTION_DAYS
 }
 
+const invocationSource = (env: NodeJS.ProcessEnv) => {
+	const source = env.AGENCY_INVOCATION_SOURCE?.toLowerCase()
+	if (source && INVOCATION_SOURCES.has(source)) return source
+	return env.AGENCY_SESSION_ID ? "agent" : "human"
+}
+
+const isTestInvocation = (env: NodeJS.ProcessEnv) =>
+	["1", "true", "yes"].includes((env.AGENCY_USAGE_TEST ?? "").toLowerCase())
+
+const journeyId = (env: NodeJS.ProcessEnv) => {
+	if (!env.AGENCY_SESSION_ID) return null
+	return `sha256:${createHash("sha256").update(env.AGENCY_SESSION_ID).digest("hex")}`
+}
+
+const pruneExpiredEvents = (database: Database, env: NodeJS.ProcessEnv) => {
+	database
+		.query(
+			"DELETE FROM usage_events WHERE datetime(occurred_at) < datetime('now', ?)",
+		)
+		.run(`-${retentionDays(env)} days`)
+}
+
 const openDatabase = async (env: NodeJS.ProcessEnv) => {
 	const path = usageDatabasePath(env)
 	await mkdir(dirname(path), { recursive: true, mode: 0o700 })
 	const database = new Database(path, { create: true, strict: true })
 	database.run("PRAGMA journal_mode = WAL")
 	database.run("PRAGMA busy_timeout = 1000")
+	const existingColumns = database
+		.query("PRAGMA table_info(usage_events)")
+		.all() as { name: string }[]
+	if (
+		existingColumns.length > 0 &&
+		(existingColumns.length !== USAGE_EVENT_COLUMNS.size ||
+			existingColumns.some(({ name }) => !USAGE_EVENT_COLUMNS.has(name)))
+	) {
+		// Version 1 could contain positional values. Do not preserve unsafe telemetry.
+		database.run("DROP TABLE usage_events")
+	}
 	database.run(`
 		CREATE TABLE IF NOT EXISTS usage_events (
 			id INTEGER PRIMARY KEY AUTOINCREMENT,
 			event_version INTEGER NOT NULL,
-			session_id TEXT NOT NULL,
-			session_sequence INTEGER NOT NULL,
+			journey_id TEXT,
+			journey_sequence INTEGER,
+			invocation_source TEXT NOT NULL,
+			is_test INTEGER NOT NULL,
 			occurred_at TEXT NOT NULL,
 			agency_version TEXT NOT NULL,
 			command_path TEXT NOT NULL,
 			flag_names TEXT NOT NULL,
 			duration_ms INTEGER NOT NULL,
 			outcome TEXT NOT NULL,
-			exit_status INTEGER NOT NULL
+			outcome_code TEXT NOT NULL,
+			exit_status INTEGER NOT NULL,
+			vcs TEXT,
+			terminal_stage TEXT,
+			category TEXT
 		)
 	`)
-	for (const column of ["vcs", "terminal_stage", "category"]) {
-		try {
-			database.run(`ALTER TABLE usage_events ADD COLUMN ${column} TEXT`)
-		} catch {
-			// Existing databases already have migrated columns.
-		}
-	}
 	database.run(
-		"CREATE INDEX IF NOT EXISTS usage_events_session ON usage_events(session_id, session_sequence)",
+		"CREATE INDEX IF NOT EXISTS usage_events_journey ON usage_events(journey_id, journey_sequence)",
 	)
 	database.run(
 		"CREATE INDEX IF NOT EXISTS usage_events_command ON usage_events(command_path, occurred_at)",
@@ -78,42 +181,42 @@ export async function recordUsageEvent(
 	let database: Database | undefined
 	try {
 		database = await openDatabase(env)
-		const sessionId = env.AGENCY_SESSION_ID || `process-${process.pid}`
+		pruneExpiredEvents(database, env)
+		const eventJourneyId = journeyId(env)
 		database
 			.query(`
 					INSERT INTO usage_events (
-						event_version, session_id, session_sequence, occurred_at,
+						event_version, journey_id, journey_sequence,
+						invocation_source, is_test, occurred_at,
 						agency_version, command_path, flag_names, duration_ms,
-						outcome, exit_status, vcs, terminal_stage, category
+						outcome, outcome_code, exit_status, vcs, terminal_stage, category
 					) VALUES (
 						?, ?,
-						(SELECT COALESCE(MAX(session_sequence), 0) + 1 FROM usage_events WHERE session_id = ?),
-						?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+						CASE WHEN ? IS NULL THEN NULL ELSE
+							(SELECT COALESCE(MAX(journey_sequence), 0) + 1 FROM usage_events WHERE journey_id = ?)
+						END,
+						?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
 					)
 				`)
 			.run(
 				USAGE_EVENT_VERSION,
-				sessionId,
-				sessionId,
+				eventJourneyId,
+				eventJourneyId,
+				eventJourneyId,
+				invocationSource(env),
+				isTestInvocation(env) ? 1 : 0,
 				new Date().toISOString(),
 				agencyVersion,
 				event.commandPath,
 				JSON.stringify([...new Set(event.flagNames)].sort()),
 				Math.max(0, Math.round(event.durationMs)),
 				event.outcome,
+				event.outcomeCode,
 				event.exitStatus,
 				event.vcs ?? null,
 				event.terminalStage ?? null,
 				event.category ?? null,
 			)
-		if (Math.random() < 0.01) {
-			const days = retentionDays(env)
-			database
-				.query(
-					"DELETE FROM usage_events WHERE occurred_at < datetime('now', ?)",
-				)
-				.run(`-${days} days`)
-		}
 	} catch {
 		// Usage logging must never affect command behavior.
 	} finally {
@@ -128,24 +231,29 @@ export async function exportUsageEvents(
 	let database: Database | undefined
 	try {
 		database = await openDatabase(env)
+		pruneExpiredEvents(database, env)
 		const rows = database
 			.query(`
-				SELECT event_version, session_id, session_sequence, occurred_at,
+				SELECT event_version, journey_id, journey_sequence,
+					invocation_source, is_test, occurred_at,
 					agency_version, command_path, flag_names, duration_ms,
-					outcome, exit_status, vcs, terminal_stage, category
+					outcome, outcome_code, exit_status, vcs, terminal_stage, category
 				FROM usage_events ORDER BY occurred_at, id
 			`)
-			.all() as Record<string, string | number>[]
+			.all() as Record<string, string | number | null>[]
 		return rows.map((row) => ({
 			version: row.event_version,
-			sessionId: row.session_id,
-			sessionSequence: row.session_sequence,
+			journeyId: row.journey_id,
+			journeySequence: row.journey_sequence,
+			invocationSource: row.invocation_source,
+			isTest: row.is_test === 1,
 			occurredAt: row.occurred_at,
 			agencyVersion: row.agency_version,
 			commandPath: row.command_path,
 			flagNames: JSON.parse(String(row.flag_names)),
 			durationMs: row.duration_ms,
 			outcome: row.outcome,
+			outcomeCode: row.outcome_code,
 			exitStatus: row.exit_status,
 			...(row.vcs == null ? {} : { vcs: row.vcs }),
 			...(row.terminal_stage == null

package/src/workbase/AGENTS.md

@@ -46,9 +46,7 @@ retain `--if-revision` guards when shown, and do not add flags that are not show
     `agency push --json`. Create and record a pull request with
     `agency pr create <task> [phase] [--draft] [--title <title>] [--label <label>] --json`;
     do not run a separate push first because `pr create` owns publication.
-12. Complete genuine non-PR work. For an active claim, run
-    `agency finish <task> [phase] --session-id <id> --revision <revision> --outcome done --no-pull-request --summary <text> [--evidence-url <url>]`.
-    Without a claim, run
+12. Complete genuine non-PR work. Run
     `agency task status <task> done --if-revision <revision> --no-pull-request --summary <text> [--evidence-url <url>] --json`
     or
     `agency phase status <task> <phase> done --if-revision <revision> --no-pull-request --summary <text> [--evidence-url <url>] --json`.
@@ -162,14 +160,14 @@ revision stale, and Agency must not silently rewrite that evidence.
 
 ## Safety
 
-- Stop on validation errors, dependency blockers, an unexpected writable
-  repository, or a conflicting active claim.
+- Stop on validation errors, dependency blockers, or an unexpected writable
+  repository.
 - Do not manually create, move, or remove worktrees under `code/`.
 - Use `agency archive`, rather than moving work item folders manually.
 - Do not edit bare repositories or repository symlinks under `repos/`.
 - Never invent entity IDs, revisions, PR state, dependency completion, or
   checkout state. Preserve parent backlinks and dependency declarations.
-- Do not bypass dirty-worktree, active-claim, revision, or readiness protections.
+- Do not bypass dirty-worktree, revision, or readiness protections.
 - Do not run `agency work` from an active agent session unless the user
   explicitly asks to launch another agent.
 - Run `agency validate` before worktree or pull-request operations.
@@ -189,10 +187,8 @@ resolve its reported commits and remediation commands before retrying.
 
 `agency work` is the human launch flow: it reconciles managed integration,
 selects work, checks readiness, prepares checkouts, marks execution work
-`working` without creating a claim, and starts the agent. Epic and multi-phase
-task launches remain orchestration-only. External orchestrators instead claim
-an execution unit, launch and monitor their agent separately, and finish or
-release the claim with the current document revision.
+`working`, and starts the agent. Epic and multi-phase task launches remain
+orchestration-only.
 
 An Agency-launched agent receives process-local worker identity through both
 the `AGENCY_SESSION_ID` and `AGENCY_TARGET` environment variables and a generated
@@ -228,13 +224,11 @@ intent, `--no-pull-request`, and a durable outcome summary.
 At each closeout trigger (creating or updating a PR, marking it ready, completing
 a refinement loop, or pausing or handing off completed implementation work):
 
-- Finish an active claim with the current revision via `agency finish`; a
-  successful claim outcome leaves unmerged work `working`. For unclaimed work,
-  keep the execution unit `working` through review and merge.
+- Keep the execution unit `working` through review and merge.
 - After merge, run `agency sync` to reconcile the execution unit to
   `done`.
-- For an approved non-PR outcome, finish an active claim or update unclaimed
-  status with `--no-pull-request --summary <text>` and optional supporting URL.
+- For an approved non-PR outcome, update status with
+  `--no-pull-request --summary <text>` and an optional supporting URL.
 - Refresh durable delivery context in `TASK.md` or `PHASE.md`, including recorded
   PR state, current head, diff summary, and verification results after later
   pushes when those details are maintained there.

package/src/workbase/agent-command.test.ts

@@ -12,9 +12,7 @@ const variables = {
 	target: "execution-unit:phase/task/build",
 	task: "task",
 	phase: "build",
-	claimant: "orchestrator",
 	sessionId: "session-1",
-	claimRevision: "revision-1",
 }
 
 describe("agent commands", () => {
@@ -116,7 +114,7 @@ describe("agent commands", () => {
 
 		expect(environment).toMatchObject({
 			AGENCY_AGENT: "custom",
-			AGENCY_CLAIMANT: "orchestrator",
+			AGENCY_INVOCATION_SOURCE: "agent",
 			AGENCY_SESSION_ID: "session-1",
 			AGENCY_WORKBASE: "/workbase",
 			AGENCY_TARGET: "execution-unit:phase/task/build",

package/src/workbase/agent-command.ts

@@ -6,9 +6,7 @@ export interface AgentCommandVariables {
 	readonly target: string
 	readonly task: string
 	readonly phase: string
-	readonly claimant: string
 	readonly sessionId: string
-	readonly claimRevision: string
 }
 
 interface AgentDefinition {
@@ -25,9 +23,7 @@ const PLACEHOLDERS = new Set<keyof AgentCommandVariables>([
 	"target",
 	"task",
 	"phase",
-	"claimant",
 	"sessionId",
-	"claimRevision",
 ])
 
 const BUILTIN_AGENTS: Readonly<Record<string, AgentDefinition>> = {
@@ -122,9 +118,8 @@ export const agentEnvironment = (
 	variables: AgentCommandVariables,
 ): Record<string, string> => ({
 	AGENCY_AGENT: agent,
-	AGENCY_CLAIMANT: variables.claimant,
+	AGENCY_INVOCATION_SOURCE: "agent",
 	AGENCY_SESSION_ID: variables.sessionId,
-	AGENCY_CLAIM_REVISION: variables.claimRevision,
 	AGENCY_WORKBASE: variables.workbase,
 	AGENCY_TARGET: variables.target,
 	AGENCY_TASK_ID: variables.task,

package/src/workbase/document-revision.ts

@@ -3,9 +3,6 @@ import { Data } from "effect"
 export const documentRevision = (content: string) =>
 	new Bun.CryptoHasher("sha256").update(content).digest("hex")
 
-export const isDocumentRevision = (revision: string) =>
-	/^[a-f0-9]{64}$/.test(revision)
-
 export class RevisionConflictError extends Data.TaggedError(
 	"RevisionConflictError",
 )<{
@@ -14,5 +11,4 @@ export class RevisionConflictError extends Data.TaggedError(
 	readonly target?: string
 	readonly expectedRevision: string
 	readonly currentRevision: string
-	readonly claim?: unknown
 }> {}

package/src/workbase/opencode-plugin-file.ts

@@ -195,6 +195,7 @@ const plugin: Plugin = async ({ directory }) => {
       if (!sessionID) return
       const context = workerSessions.get(sessionID)
       if (!context?.target) return
+      output.env.AGENCY_INVOCATION_SOURCE = "agent"
       output.env.AGENCY_SESSION_ID = sessionID
       output.env.AGENCY_TARGET = context.target
       if (context.root) output.env.AGENCY_WORKBASE = context.root

package/src/workbase/schemas.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test"
 import { Schema } from "@effect/schema"
 import {
 	EntityId,
-	ClaimRecord,
 	EpicFrontmatter,
 	PhaseFrontmatter,
 	TaskFrontmatter,
@@ -401,30 +400,18 @@ describe("work status", () => {
 	})
 })
 
-describe("claim records", () => {
-	const record = {
-		claimant: "orchestrator",
-		agent: "agent",
-		sessionId: "job-1",
-		startedAt: "2026-07-17T12:00:00.000Z",
-		targetRevision: "0".repeat(64),
-		expiresAt: "2026-07-17T13:00:00.000Z",
-		state: "active" as const,
-	}
-
-	test("accepts explicit ownership and revision metadata", () => {
-		expect(Schema.decodeUnknownSync(ClaimRecord)(record)).toEqual(record)
-	})
-
-	test("rejects malformed timestamps, revisions, and empty identities", () => {
-		for (const invalid of [
-			{ ...record, claimant: "" },
-			{ ...record, startedAt: "today" },
-			{ ...record, targetRevision: "abc" },
-		]) {
-			expect(() => Schema.decodeUnknownSync(ClaimRecord)(invalid)).toThrow()
-		}
-	})
+test("rejects removed claim frontmatter", () => {
+	expect(() =>
+		Schema.decodeUnknownSync(TaskFrontmatter, { onExcessProperty: "error" })({
+			ticketUrl: null,
+			repo: "agency",
+			branch: "task/example",
+			base: "main",
+			pr: null,
+			status: "working",
+			claim: { state: "active" },
+		}),
+	).toThrow()
 })
 
 describe("workbase registry", () => {

package/src/workbase/schemas.ts

@@ -50,19 +50,6 @@ export const DocumentRevision = Schema.String.pipe(
 	Schema.pattern(/^[a-f0-9]{64}$/),
 )
 
-export const ClaimRecord = Schema.Struct({
-	claimant: NonEmptyString,
-	agent: NonEmptyString,
-	sessionId: NonEmptyString,
-	startedAt: IsoTimestamp,
-	targetRevision: DocumentRevision,
-	expiresAt: Schema.optional(IsoTimestamp),
-	state: Schema.Literal("active", "released", "finished"),
-	releasedAt: Schema.optional(IsoTimestamp),
-	finishedAt: Schema.optional(IsoTimestamp),
-	outcome: Schema.optional(Schema.Literal("done", "dropped")),
-})
-
 const Url = NonEmptyString.pipe(Schema.pattern(/^[a-zA-Z][a-zA-Z0-9+.-]*:/))
 
 const GitHubPullRequestUrl = NonEmptyString.pipe(
@@ -163,7 +150,6 @@ const ExecutionUnit = {
 	base: NonEmptyString,
 	pr: Schema.NullOr(Schema.Union(GitHubPullRequestUrl, PullRequestRecord)),
 	status: Schema.optionalWith(WorkStatus, { default: () => "open" as const }),
-	claim: Schema.optional(ClaimRecord),
 	completion: Schema.optional(CompletionRecord),
 }
 
@@ -262,7 +248,6 @@ const ReviewTaskFrontmatter = Schema.Struct({
 	...TaskMetadata,
 	review: ReviewRecord,
 	status: Schema.optionalWith(WorkStatus, { default: () => "open" as const }),
-	claim: Schema.optional(ClaimRecord),
 	completion: Schema.optional(CompletionRecord),
 })
 
@@ -288,7 +273,6 @@ export type RepositoryDeclaration = Schema.Schema.Type<
 	typeof RepositoryDeclaration
 >
 export type WorkStatus = Schema.Schema.Type<typeof WorkStatus>
-export type ClaimRecord = Schema.Schema.Type<typeof ClaimRecord>
 export type PullRequestRecord = Schema.Schema.Type<typeof PullRequestRecord>
 export type ReviewSource = Schema.Schema.Type<typeof ReviewSource>
 export type ReviewRecord = Schema.Schema.Type<typeof ReviewRecord>

package/src/commands/claim.ts

@@ -1,122 +0,0 @@
-import { Effect } from "effect"
-import { ClaimService } from "../services/ClaimService"
-import type { BaseCommandOptions } from "../utils/command"
-import { createLoggers } from "../utils/effect"
-
-interface ClaimCommandOptions extends BaseCommandOptions {
-	readonly operation: "claim" | "release" | "finish"
-	readonly taskId?: string
-	readonly phaseId?: string
-	readonly claimant?: string
-	readonly agent?: string
-	readonly sessionId?: string
-	readonly revision?: string
-	readonly expiresAt?: string
-	readonly outcome?: string
-	readonly noPullRequest?: boolean
-	readonly summary?: string
-	readonly evidenceUrl?: string
-	readonly json?: boolean
-}
-
-export const claimCommand = (options: ClaimCommandOptions) =>
-	Effect.gen(function* () {
-		const claims = yield* ClaimService
-		const { log } = createLoggers(options)
-		const cwd = options.cwd ?? process.cwd()
-		if (!options.taskId || !options.sessionId || !options.revision) {
-			return yield* Effect.fail(new Error("Missing required claim arguments"))
-		}
-		if (
-			options.operation === "claim" &&
-			(!options.claimant || !options.agent)
-		) {
-			return yield* Effect.fail(
-				new Error("Claimant and agent identities are required"),
-			)
-		}
-		if (options.noPullRequest && !options.summary?.trim()) {
-			return yield* Effect.fail(
-				new Error("Non-PR completion requires a non-empty summary"),
-			)
-		}
-		if (options.noPullRequest && options.outcome !== "done") {
-			return yield* Effect.fail(
-				new Error("Non-PR completion is valid only with a done outcome"),
-			)
-		}
-		if (
-			options.operation === "finish" &&
-			options.outcome !== "done" &&
-			options.outcome !== "dropped"
-		) {
-			return yield* Effect.fail(
-				new Error("Finish outcome must be done or dropped"),
-			)
-		}
-
-		const common = {
-			taskId: options.taskId,
-			...(options.phaseId ? { phaseId: options.phaseId } : {}),
-			sessionId: options.sessionId,
-			revision: options.revision,
-		}
-		const result =
-			options.operation === "claim"
-				? yield* claims.claim(
-						{
-							...common,
-							claimant: options.claimant!,
-							agent: options.agent!,
-							...(options.expiresAt ? { expiresAt: options.expiresAt } : {}),
-						},
-						cwd,
-					)
-				: options.operation === "release"
-					? yield* claims.release(common, cwd)
-					: yield* claims.finish(
-							{
-								...common,
-								outcome: options.outcome as "done" | "dropped",
-								...(options.noPullRequest
-									? {
-											nonPrCompletion: {
-												summary: options.summary!,
-												...(options.evidenceUrl
-													? { evidenceUrl: options.evidenceUrl }
-													: {}),
-											},
-										}
-									: {}),
-							},
-							cwd,
-						)
-
-		const { data: _, ...output } = result
-		log(
-			options.json
-				? JSON.stringify(output, null, 2)
-				: `${options.operation === "claim" ? "Claimed" : options.operation === "release" ? "Released" : "Finished"} ${result.target} at revision ${result.revision}`,
-		)
-	})
-
-export const claimHelp = `
-Usage: agency claim <task-id> [phase-id] --claimant <id> --agent <id> --session-id <id> --revision <sha256>
-
-Claim an execution unit. Use distinct claimant and agent identities for delegated
-work. --expires-at accepts an optional future ISO-8601 timestamp.
-`
-
-export const releaseHelp = `
-Usage: agency release <task-id> [phase-id] --session-id <id> --revision <sha256>
-
-Release an execution unit owned by the session.
-`
-
-export const finishHelp = `
-Usage: agency finish <task-id> [phase-id] --session-id <id> --revision <sha256> --outcome <done|dropped> [--no-pull-request --summary <text> [--evidence-url <url>]]
-
-Finish a claim owned by the session. A done claim outcome leaves unmerged work
-working; agency sync marks the execution unit done after merge. Use
---no-pull-request with a summary for an explicit non-PR completion.
-`